Ml core apple: Core ML — Machine Learning

Содержание

Тестирование и обзор Core ML / Блог компании MobileUp / Хабр

На WWDC’17 Apple представила новый фреймворк для работы с технологиями машинного обучения Core ML. На основе него в iOS реализованы собственные продукты Apple: Siri, Camera и QuickType. Core ML позволяет упростить интеграцию машинного обучения в приложения и создавать различные «умные» функции с помощью пары строчек кода.


Возможности Core ML

С помощью Core ML в приложении можно реализовать следующие функции:


  • распознавание изображений в реальном времени;
  • предиктивный ввод текста;
  • распознавание образов;
  • анализ тональности;
  • распознавание рукописного текста;
  • ранжирование поиска;
  • стилизация изображений;
  • распознавание лиц;
  • идентификация голоса;
  • определение музыки;
  • реферирование текста;
  • и не только.

Core ML позволяет легко импортировать в ваше приложение различные алгоритмы машинного обучения, такие как: tree ensembles, SVMs и generalized linear models. Он использует низкоуровневые технологии, такие как Metal, Accelerate и BNNS. Результаты вычислений происходят почти мгновенно.


Vision

Фреймворк Vision работает на основе Core ML и помогает с отслеживанием и распознаванием лиц, текста, объектов, штрих-кодов. Также доступно определение горизонта и получение матрицы для выравнивания изображения.


NSLinguisticTagger

С iOS 5 Apple представила NSLinguisticTagger, который позволяет анализировать естественный язык, поддерживает множество языков и алфавитов. C выходом iOS 11 класс усовершенствовали, теперь ему можно скормить строку с текстом на разных языках и он вернет доминирующий язык в этой строке и еще много других улучшений. NSLinguisticTagger тоже использует машинное обучение для глубокого понимания текста и его анализа.


Core ML Model

На промо странице Core ML Apple предоставила 4 модели. Все они анализируют изображения. Модели Core ML работают локально и оптимизированы для работы на мобильных устройствах, сводя к минимуму объем используемой памяти и энергопотребление.

Вы можете сгенерировать собственные модели с помощью Core ML Tools.

Рабочий способ загружать модели во время выполнения:



  1. Положить файл модели в таргет приложения.
  2. Скомпилировать новую модель из .mlmodel в .mlmodelc, не изменяя её интерфейс.
  3. Положить эти файлы на сервер.
  4. Скачать их внутри приложения.
  5. Инициализировать новую модель, например:

CoreMLModelClass.init(contentOf: URL)

Работоспособность после выпуска приложения в App Store не протестирована.


Особенности Core ML


  • Решение от Apple не может принимать данные и обучать модели. Только принимать некоторые типы обученных моделей, преобразовывать их в собственный формат и делать прогнозы.
  • Модель не сжимается.
  • Она никак не шифруется. Вам придется позаботиться о защите данных самому.

Тестируем Core ML

Я подготовил тестовый проект с использованием Core ML. Мы сделаем простой локатор котов, который позволит отличить все в этой вселенной от кота.

Создаем проект и выбираем Single View Application. Предварительно нужно скачать Core ML модель, которая и будет анализировать объекты с камеры. В этом проекте я использую Inception v3. Далее нужно перенести модель в Project Navigator, Xcode автоматически сгенерирует интерфейс для нее.
На сториборд добавляем на весь экран View, туда мы будем выводить изображение с камеры. Поверх добавляем Visual Effect View и Label. Прокидываем аутлеты в ViewController.
Не забудьте в plist добавить разрешение на использование камеры.

Нам нужно вывести изображение с камеры в реальном времени, для этого создадим AVCaptureSession и очередь для получения новых кадров DispatchQueue. Добавим на наш View слой AVCaptureVideoPreviewLayer, на него будет выводится изображение с камеры, также нужно создать массив VNRequest — это запросы к Vision. Сразу в viewDidLoad проверим доступность камеры.

import UIKit
import AVFoundation
import Vision

class ViewController: UIViewController {

    @IBOutlet var resultLabel: UILabel!
    @IBOutlet var resultView: UIView!

    let session = AVCaptureSession()
    var previewLayer: AVCaptureVideoPreviewLayer!
    let captureQueue = DispatchQueue(label: "captureQueue")
    var visionRequests = [VNRequest]()

    override func viewDidLoad() {
        super.viewDidLoad()

        guard let camera = AVCaptureDevice.default(for: .video) else {
            return
        }
        do {
            previewLayer = AVCaptureVideoPreviewLayer(session: session)
            resultView.layer.addSublayer(previewLayer)
        } catch {
            let alertController = UIAlertController(title: nil, message: error.localizedDescription, preferredStyle: .alert)
            alertController.addAction(UIAlertAction(title: "Ok", style: .default, handler: nil))
            present(alertController, animated: true, completion: nil)
        }
    }
}

Далее настраиваем cameraInput и cameraOutput, добавляем их к сессии и стартуем ее для получения потока данных.

let cameraInput = try AVCaptureDeviceInput(device: camera)
let videoOutput = AVCaptureVideoDataOutput()
videoOutput.setSampleBufferDelegate(self, queue: captureQueue)
videoOutput.alwaysDiscardsLateVideoFrames = true
videoOutput.videoSettings = [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA]

session.sessionPreset = .high
session.addInput(cameraInput)
session.addOutput(videoOutput)

let connection = videoOutput.connection(with: .video)
connection?.videoOrientation = .portrait
session.startRunning()

Теперь нам нужно инициализировать Core ML модель для Vision и настроить запрос.

guard let visionModel = try? VNCoreMLModel(for: Inceptionv3().model) else {
    fatalError("Could not load model")
}

let classificationRequest = VNCoreMLRequest(model: visionModel, completionHandler: handleClassifications)
classificationRequest.imageCropAndScaleOption = VNImageCropAndScaleOptionCenterCrop
visionRequests = [classificationRequest]

Создаем метод, который будет обрабатывать полученные результаты. С учетом погрешности, берем 3 наиболее вероятных по мнению модели результата и ищем среди них слово cat.

private func handleClassifications(request: VNRequest, error: Error?) {
    if let error = error {
        print(error.localizedDescription)
        return
    }
    guard let results = request.results as? [VNClassificationObservation] else {
        print("No results")
        return
    }

    var resultString = "Это не кот!"
    results[0...3].forEach {
            let identifer = $0.identifier.lowercased()
            if identifer.range(of: "cat") != nil {
            resultString = "Это кот!"
        }
    }
    DispatchQueue.main.async {
        self.resultLabel.text = resultString
    }
}

Последнее, что нам осталось сделать – добавить метод делагата AVCaptureVideoDataOutputSampleBufferDelegate, который вызывается при каждом новом кадре, полученном с камеры. В нем мы конфигурируем запрос и выполняем его.

extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {

    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }

        var requestOptions: [VNImageOption: Any] = [:]
        if let cameraIntrinsicData = CMGetAttachment(sampleBuffer, kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix, nil) {
            requestOptions = [.cameraIntrinsics: cameraIntrinsicData]
        }

        let imageRequestHandler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: 1, options: requestOptions)
        do {
            try imageRequestHandler.perform(visionRequests)
        } catch {
            print(error)
        }
    }
}

Готово! Вы написали приложение, которое отличает котов от всех остальных объектов!

→ Ссылка на репозиторий.


Выводы

Несмотря на особенности, Core ML найдет свою аудиторию. Если вы не готовы мириться с ограничениями и небольшими возможностями, существуют много сторонних фреймворков. Например, YOLO или Swift-AI.

Тестирование и обзор Core ML

На WWDC’17 Apple представила новый фреймворк для работы с технологиями машинного обучения Core ML. На основе него в iOS реализованы собственные продукты Apple: Siri, Camera и QuickType. Core ML позволяет упростить интеграцию машинного обучения в приложения и создавать различные «умные» функции с помощью пары строчек кода.

Возможности Core ML

С помощью Core ML в приложении можно реализовать следующие функции:

  • распознавание изображений в реальном времени;
  • предиктивный ввод текста;
  • распознавание образов;
  • анализ тональности;
  • распознавание рукописного текста;
  • ранжирование поиска;
  • стилизация изображений;
  • распознавание лиц;
  • идентификация голоса;
  • определение музыки;
  • реферирование текста;
  • и не только.

Core ML позволяет легко импортировать в ваше приложение различные алгоритмы машинного обучения, такие как: tree ensembles, SVMs и generalized linear models. Он использует низкоуровневые технологии, такие как Metal, Accelerate и BNNS. Результаты вычислений происходят почти мгновенно.

Vision

Фреймворк Vision работает на основе Core ML и помогает с отслеживанием и распознаванием лиц, текста, объектов, штрих-кодов. Также доступно определение горизонта и получение матрицы для выравнивания изображения.

NSLinguisticTagger

С iOS 5 Apple представила NSLinguisticTagger, который позволяет анализировать естественный язык, поддерживает множество языков и алфавитов. C выходом iOS 11 класс усовершенствовали, теперь ему можно скормить строку с текстом на разных языках и он вернет доминирующий язык в этой строке и еще много других улучшений. NSLinguisticTagger тоже использует машинное обучение для глубокого понимания текста и его анализа.

Core ML Model

На промо странице Core ML Apple предоставила 4 модели. Все они анализируют изображения. Модели Core ML работают локально и оптимизированы для работы на мобильных устройствах, сводя к минимуму объем используемой памяти и энергопотребление.
Вы можете сгенерировать собственные модели с помощью Core ML Tools.

Рабочий способ загружать модели во время выполнения:


  1. Положить файл модели в таргет приложения.
  2. Скомпилировать новую модель из .mlmodel в .mlmodelc, не изменяя её интерфейс.
  3. Положить эти файлы на сервер.
  4. Скачать их внутри приложения.
  5. Инициализировать новую модель, например:

CoreMLModelClass.init(contentOf: URL)

Работоспособность после выпуска приложения в App Store не протестирована.

Особенности Core ML

  • Решение от Apple не может принимать данные и обучать модели. Только принимать некоторые типы обученных моделей, преобразовывать их в собственный формат и делать прогнозы.
  • Модель не сжимается.
  • Она никак не шифруется. Вам придется позаботиться о защите данных самому.

Тестируем Core ML

Я подготовил тестовый проект с использованием Core ML. Мы сделаем простой локатор котов, который позволит отличить все в этой вселенной от кота.

Создаем проект и выбираем Single View Application. Предварительно нужно скачать Core ML модель, которая и будет анализировать объекты с камеры. В этом проекте я использую Inception v3. Далее нужно перенести модель в Project Navigator, Xcode автоматически сгенерирует интерфейс для нее.
На сториборд добавляем на весь экран View, туда мы будем выводить изображение с камеры. Поверх добавляем Visual Effect View и Label. Прокидываем аутлеты в ViewController.

Не забудьте в plist добавить разрешение на использование камеры.

Нам нужно вывести изображение с камеры в реальном времени, для этого создадим AVCaptureSession и очередь для получения новых кадров DispatchQueue. Добавим на наш View слой AVCaptureVideoPreviewLayer, на него будет выводится изображение с камеры, также нужно создать массив VNRequest — это запросы к Vision. Сразу в viewDidLoad проверим доступность камеры.

import UIKit
import AVFoundation
import Vision

class ViewController: UIViewController {

    @IBOutlet var resultLabel: UILabel!
    @IBOutlet var resultView: UIView!

    let session = AVCaptureSession()
    var previewLayer: AVCaptureVideoPreviewLayer!
    let captureQueue = DispatchQueue(label: "captureQueue")
    var visionRequests = [VNRequest]()

    override func viewDidLoad() {
        super.viewDidLoad()

        guard let camera = AVCaptureDevice.default(for: .video) else {
            return
        }
        do {
            previewLayer = AVCaptureVideoPreviewLayer(session: session)
            resultView.layer.addSublayer(previewLayer)
        } catch {
            let alertController = UIAlertController(title: nil, message: error.localizedDescription, preferredStyle: .alert)
            alertController.addAction(UIAlertAction(title: "Ok", style: .default, handler: nil))
            present(alertController, animated: true, completion: nil)
        }
    }
}

Далее настраиваем cameraInput и cameraOutput, добавляем их к сессии и стартуем ее для получения потока данных.

let cameraInput = try AVCaptureDeviceInput(device: camera)
let videoOutput = AVCaptureVideoDataOutput()
videoOutput.setSampleBufferDelegate(self, queue: captureQueue)
videoOutput.alwaysDiscardsLateVideoFrames = true
videoOutput.videoSettings = [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA]

session.sessionPreset = .high
session.addInput(cameraInput)
session.addOutput(videoOutput)

let connection = videoOutput.connection(with: .video)
connection?.videoOrientation = .portrait
session.startRunning()

Теперь нам нужно инициализировать Core ML модель для Vision и настроить запрос.

guard let visionModel = try? VNCoreMLModel(for: Inceptionv3().model) else {
    fatalError("Could not load model")
}

let classificationRequest = VNCoreMLRequest(model: visionModel, completionHandler: handleClassifications)
classificationRequest.imageCropAndScaleOption = VNImageCropAndScaleOptionCenterCrop
visionRequests = [classificationRequest]

Создаем метод, который будет обрабатывать полученные результаты. С учетом погрешности, берем 3 наиболее вероятных по мнению модели результата и ищем среди них слово cat.

private func handleClassifications(request: VNRequest, error: Error?) {
    if let error = error {
        print(error.localizedDescription)
        return
    }
    guard let results = request.results as? [VNClassificationObservation] else {
        print("No results")
        return
    }

    var resultString = "Это не кот!"
    results[0...3].forEach {
            let identifer = $0.identifier.lowercased()
            if identifer.range(of: "cat") != nil {
            resultString = "Это кот!"
        }
    }
    DispatchQueue.main.async {
        self.resultLabel.text = resultString
    }
}

Последнее, что нам осталось сделать – добавить метод делагата AVCaptureVideoDataOutputSampleBufferDelegate, который вызывается при каждом новом кадре, полученном с камеры. В нем мы конфигурируем запрос и выполняем его.

extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {

    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }

        var requestOptions: [VNImageOption: Any] = [:]
        if let cameraIntrinsicData = CMGetAttachment(sampleBuffer, kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix, nil) {
            requestOptions = [.cameraIntrinsics: cameraIntrinsicData]
        }

        let imageRequestHandler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: 1, options: requestOptions)
        do {
            try imageRequestHandler.perform(visionRequests)
        } catch {
            print(error)
        }
    }
}

Готово! Вы написали приложение, которое отличает котов от всех остальных объектов!
Ссылка на репозиторий.

Выводы

Несмотря на особенности, Core ML найдет свою аудиторию. Если вы не готовы мириться с ограничениями и небольшими возможностями, существуют много сторонних фреймворков. Например, YOLO или Swift-AI.

Автор: dmrozov

Источник

Core ML: машинное обучение в iOS

Ну и конечно не обошлось без искусственного интеллекта и машинного обучения. Теперь разработчикам доступна новый фреймворк Core ML, на основе которой работают собственные приложения Apple — Siri, Camera и QuickType.

Core ML позволяет использовать на iOS предобученные серверные модели. На самом устройстве обучать модели пока нельзя. Уже сейчас можно использовать Core ML, например, для отслеживания и распознавания лиц, определения штрих-кодов, объектов на фото и видео, анализа движений (Vision) или для понимания и распознавания текста (Natural Language).

Apple сделала конвертер моделей для всех популярных фреймворков: Caffe, Keras, scikit-learn, XGBoost, LIBSVM.

Android-разработчики тоже скоро получат специальную версию TensorFlow, которая будет работать на мобильных устройствах.

Если вы нашли опечатку — выделите ее и нажмите Ctrl + Enter! Для связи с нами вы можете использовать [email protected]

Преобразование моделей машинного обучения в формат ONNX с помощью WinMLTools

  • Чтение занимает 9 мин

В этой статье

WinMLTools позволяет преобразовывать модели машинного обучения, созданные с использованием разных платформ обучения, в формат ONNX.WinMLTools enables you to convert machine learning models created with different training frameworks into ONNX. Это расширение ONNXMLTools и TF2ONNX, предназначенное для преобразования моделей в формат ONNX для использования с Windows ML.It is an extension of ONNXMLTools and TF2ONNX to convert models to ONNX for use with Windows ML.

Сейчас WinMLTools поддерживает преобразование из следующих платформ:WinMLTools currently supports conversion from the following frameworks:

  • Apple Core ML;Apple Core ML
  • Keras;Keras
  • scikit-learn;scikit-learn
  • lightgbm;lightgbm
  • xgboost;xgboost
  • libSVM;libSVM
  • TensorFlow (в экспериментальном режиме).TensorFlow (experimental)

См. сведения о том, как экспортировать модели из других платформ машинного обучения, в руководствах по ONNX на GitHub.To learn how to export from other ML frameworks, take a look at the ONNX tutorials on GitHub.

В этой статье описано, как с помощью WinMLTools выполнять следующие действия:In this article, we demonstrate how to use WinMLTools to:

  • преобразование моделей Core ML в формат ONNX;Convert Core ML models into ONNX
  • преобразование моделей scikit-learn в формат ONNX;Convert scikit-learn models into ONNX
  • преобразование моделей TensorFlow в формат ONNX;Convert TensorFlow models into ONNX
  • применение дискретизации весовых коэффициентов к моделям ONNX после обучения;Apply post-training weight quantization to ONNX models
  • преобразование моделей с плавающей запятой в модели 16-разрядной точности с плавающей запятой;Convert floating point models to 16-bit floating point precision models
  • создание пользовательских операторов ONNX.Create custom ONNX operators

Примечание

Последняя версия WinMLTools поддерживает преобразование в формат ONNX версий 1.2.2, 1.3 и 1.4 (определяется наборами операций ONNX версий 7, 8 и 9 соответственно).The latest version of WinMLTools supports conversion to ONNX versions 1.2.2, 1.3, and 1.4, as specified respectively by ONNX opsets 7 and 8, and 9. Предыдущие версии средства не поддерживают ONNX версии 1.4.Previous versions of the tool do not have support for ONNX 1.4.

WinMLTools предоставляется в виде пакета Python (winmltools), который поддерживает Python версий 2.7 и 3.6.WinMLTools is a Python package (winmltools) that supports Python versions 2.7 and 3.6. При работе над проектом анализа данных лучше всего применять такой дистрибутив Python для научных вычислений, как Anaconda.If you are working on a data science project, we recommend installing a scientific Python distribution such as Anaconda.

Примечание

Сейчас WinMLTools не поддерживает Python версии 3.7.WinMLTools does not currently support Python 3.7.

WinMLTools поддерживает стандартный процесс установки пакетов Python.WinMLTools follows the standard Python package installation process. В среде Python выполните следующую команду:From your Python environment, run:

pip install winmltools

WinMLTools имеет следующие зависимости:WinMLTools has the following dependencies:

  • numpy версии 1.10.0 и выше;numpy v1.10.0+
  • protobuf версии 3.6.0 или выше;protobuf v.3.6.0+
  • onnx версии 1.3.0 и выше;onnx v1.3.0+
  • onnxmltools версии 1.3.0 и выше;onnxmltools v1.3.0+
  • tf2onnx версии 0.3.2 и выше.tf2onnx v0.3.2+

Чтобы обновить зависимые пакеты, выполните команду pip с аргументом -U.To update the dependent packages, run the pip command with the -U argument.

pip install -U winmltools

Для разных преобразователей нужно использовать разные пакеты.For different converters, you will have to install different packages.

Для libsvmможно скачать libsvm wheel из любого источника в Интернете.For libsvm, you can download libsvm wheel from various web sources. Один из примеров доступен на веб-сайте Калифорнийского университета в Ирвайне.One example can be found at the University of California, Irvine’s website.

Для coremltools компания Apple пока не предоставляет пакет Core ML для Windows.For coremltools, currently Apple does not distribute Core ML packaging on Windows. Вы можете выполнить установку из исходного кода:You can install from source:

pip install git+https://github.com/apple/coremltools

Подпишитесь на onnxmltools на GitHub, чтобы получать дополнительные сведения о зависимостях onnxmltools.Follow onnxmltools on GitHub for further information on onnxmltools dependencies.

См. сведения о том, как использовать WinMLTools, в документации по пакетам с помощью функции help.Additional details on how to use WinMLTools can be found on the package-specific documentation with the help function.

help(winmltools)

Преобразование моделей Core MLConvert Core ML models

Здесь мы предполагаем, что файл примера модели Core ML размещен в каталоге example.mlmodel.Here, we assume that the path of an example Core ML model file is example.mlmodel.

from coremltools.models.utils import load_spec
# Load model file
model_coreml = load_spec('example.mlmodel')
from winmltools import convert_coreml
# Convert it!
# The automatic code generator (mlgen) uses the name parameter to generate class names.
model_onnx = convert_coreml(model_coreml, 7, name='ExampleModel')

Примечание

Вторым параметром в вызове convert_coreml() является target_opset. Он обозначает номер версии операторов в пространстве имен по умолчанию ai.onnx.The second parameter in the call to convert_coreml() is the target_opset, and it refers to the version number of the operators in the default namespace ai.onnx. См. сведения об этих операциях.See more details on these operators here. Этот параметр доступен только в последней версии WinMLTools. Он позволяет разработчикам использовать разные версии ONNX (сейчас поддерживаются версии 1.2.2 и 1.3).This parameter is only available on the latest version of WinMLTools, enabling developers to target different ONNX versions (currently versions 1.2.2 and 1.3 are supported). Чтобы преобразовать модели для работы с обновлением Windows от 10 октября 2018 г., используйте target_opset версии 7 (ONNX 1.2.2).To convert models to run with the Windows 10 October 2018 update, use target_opset 7 (ONNX v1.2.2). В Windows 10 сборки 17763 и выше WinML поддерживаются модели с target_opset версий 7 и 8 (ONNX 1.3).For Windows 10 builds greater than 17763, WinML accepts models with target_opset 7 and 8 (ONNX v.1.3). В разделе заметок о выпуске также указаны минимальная и максимальная версии ONNX, поддерживаемые в WinML разных сборок.The Release Notes section also contains the min and max ONNX versions supported by WinML in different builds.

model_onnx является объектом ONNX ModelProto.model_onnx is an ONNX ModelProto object. Его можно сохранить в двух разных форматах.We can save it in two different formats.

from winmltools.utils import save_model
# Save the produced ONNX model in binary format
save_model(model_onnx, 'example.onnx')
# Save the produced ONNX model in text format
from winmltools.utils import save_text
save_text(model_onnx, 'example.txt')

Примечание

CoreMLTools — это пакет Python, предоставляемый компанией Apple, который недоступен для Windows.Core MLTools is a Python package provided by Apple, but is not available on Windows. Если вам нужно установить этот пакет в Windows, установите его непосредственно из репозитория:If you need to install the package on Windows, install the package directly from the repo:

pip install git+https://github.com/apple/coremltools

Преобразование моделей Core ML с форматом изображений для входных и выходных данныхConvert Core ML models with image inputs or outputs

Из-за отсутствия типов изображений в ONNX для преобразования моделей изображений Core ML (т. е. моделей, в которых изображения используются в качестве входных или выходных данных) требуется предварительные обработка и постобработка.Because of the lack of image types in ONNX, converting Core ML image models (that is, models using images as inputs or outputs) requires some pre-processing and post-processing steps.

Задача предварительной обработки — правильное форматирование входного изображения в виде тензора ONNX.The objective of pre-processing is to make sure the input image is properly formatted as an ONNX tensor. Предположим, X — это входное изображение Core ML с размерами [C, H, W].Assume X is an image input with shape [C, H, W] in Core ML. В ONNX переменная X будет тензором с плавающей запятой тех же размеров, а X[0, :, :]/X[1, :, :]/X[2, :, :] содержат красный, зеленый и синий каналы изображения соответственно.In ONNX, the variable X would be a floating-point tensor with the same shape and X[0, :, :]/X[1, :, :]/X[2, :, :] stores the image’s red/green/blue channel. Для изображений Core ML в градациях серого тензоры ONNX будут иметь формат [1, H, W], так как используется только один канал.For grayscale images in Core ML, their format is [1, H, W]-tensors in ONNX because we only have one channel.

Если первоначальная модель Core ML выводит изображение, вручную преобразуйте выходные тензоры с плавающей запятой ONNX обратно в изображения.If the original Core ML model outputs an image, manually convert ONNX’s floating-point output tensors back into images. Для этого выполните два шага:There are two basic steps. Первый — усечение всех значений больше 255 до 255 и изменение всех отрицательных значений на 0.The first step is to truncate values greater than 255 to 255 and change all negative values to 0. Второй — округление всех значений пикселей до целых чисел (путем добавления 0,5 и усечения дробной части).The second step is to round all pixel values to integers (by adding 0.5 and then truncating the decimals). Порядок выходных каналов (например, RGB или BGR) указывается в модели Core ML.The output channel order (for example, RGB or BGR) is indicated in the Core ML model. Для создания допустимого выходного изображения нам может потребоваться выполнить транспозицию или изменение порядка для восстановления требуемого формата.To generate proper image output, we may need to transpose or shuffle to recover the desired format.

Здесь мы рассмотрим преобразование на примере модели Core ML, FNS-Candy, скачанной на GitHub. Этот пример демонстрирует разницу между форматами ONNX и Core ML.Here we consider a Core ML model, FNS-Candy, downloaded from GitHub, as a concrete conversion example to demonstrate the difference between ONNX and Core ML formats. Обратите внимание, что все последующие команды выполняются в среде Python.Note that all the subsequent commands are executed in a Python environment.

Во-первых, мы загружаем модель Core ML и проверяем ее входной и выходной форматы.First, we load the Core ML model and examine its input and output formats.

from coremltools.models.utils import load_spec
model_coreml = load_spec('FNS-Candy.mlmodel')
model_coreml.description # Print the content of Core ML model description

Вывод на экран:Screen output:

...
input {
    ...
      imageType {
      width: 720
      height: 720
      colorSpace: BGR
    ...
}
...
output {
    ...
      imageType {
      width: 720
      height: 720
      colorSpace: BGR
    ...
}
...

В нашем случае входные и выходные данные представлены изображением BGR размером 720 x 720 пикселей.In this case, both the input and output are 720×720 BGR-images. Следующий шаг — преобразование модели Core ML с помощью WinMLTools.Our next step is to convert the Core ML model with WinMLTools.

# The automatic code generator (mlgen) uses the name parameter to generate class names.
from winmltools import convert_coreml
model_onnx = convert_coreml(model_coreml, 7, name='FNSCandy')

Альтернативный метод просмотра входного и выходного форматов модели в ONNX — использовать следующую команду:An alternative method to view the model input and output formats in ONNX is to use the following command:

model_onnx.graph.input # Print out the ONNX input tensor's information

Вывод на экран:Screen output:

...
  tensor_type {
    elem_type: FLOAT
    shape {
      dim {
        dim_param: "None"
      }
      dim {
        dim_value: 3
      }
      dim {
        dim_value: 720
      }
      dim {
        dim_value: 720
      }
    }
  }
...

Полученные входные данные (обозначены как X) в ONNX представляют собой четырехмерный тензор.The produced input (denoted by X) in ONNX is a 4-D tensor. Последними тремя осями являются: C, H и W соответственно.The last 3 axes are C-, H-, and W-axes, respectively. Первое измерение обозначается как None, то есть эта модель ONNX может применяться к любому количеству изображений.The first dimension is «None» which means that this ONNX model can be applied to any number of images. Если эта модель применяется для обработки пакета, состоящего из двух изображений, первому изображение соответствует X[0, :, :, :], а второму — X[1, :, :, :].To apply this model to process a batch of 2 images, the first image corresponds to X[0, :, :, :] while X[1, :, :, :] corresponds to the second image. Синий, зеленый и красный каналы первого изображения сохраняются в X[0, 0, :, :]/X[0, 1, :, :]/X[0, 2, :, :]. То же справедливо и для второго изображения.The blue/green/red channels of the first image are X[0, 0, :, :]/X[0, 1, :, :]/X[0, 2, :, :], and similar for the second image.

model_onnx.graph.output # Print out the ONNX output tensor's information

Вывод на экран:Screen output:

...
  tensor_type {
    elem_type: FLOAT
    shape {
      dim {
        dim_param: "None"
      }
      dim {
        dim_value: 3
      }
      dim {
        dim_value: 720
      }
      dim {
        dim_value: 720
      }
    }
  }
...

Как видно, создаваемый формат идентичен формату входных данных исходной модели.As you can see, the produced format is identical to the original model input format. Но этот пример не является изображением, так как значения пикселей представлены целыми числами, а не числами с плавающей запятой.However, in this case, it’s not an image because the pixel values are integers, not floating-point numbers. Чтобы преобразовать его обратно в изображение, усеките числа больше 255 до 255, измените отрицательные значения на 0 и округлите все десятичные числа до целых чисел.To convert back to an image, truncate values greater than 255 to 255, change negative values to 0, and round all decimals to integers.

Преобразование моделей scikit-learnConvert scikit-learn models

В следующем фрагменте кода метод опорных векторов обучается в scikit-learn, и модель преобразуется в ONNX.The following code snippet trains a linear support vector machine in scikit-learn and converts the model into ONNX.

# First, we create a toy data set.
# The training matrix X contains three examples, with two features each.
# The label vector, y, stores the labels of all examples.
X = [[0.5, 1.], [-1., -1.5], [0., -2.]]
y = [1, -1, -1]

# Then, we create a linear classifier and train it.
from sklearn.svm import LinearSVC
linear_svc = LinearSVC()
linear_svc.fit(X, y)

# To convert scikit-learn models, we need to specify the input feature's name and type for our converter.
# The following line means we have a 2-D float feature vector, and its name is "input" in ONNX.
# The automatic code generator (mlgen) uses the name parameter to generate class names.
from winmltools import convert_sklearn
from winmltools.convert.common.data_types import FloatTensorType
linear_svc_onnx = convert_sklearn(linear_svc, 7, name='LinearSVC',
                                  initial_types=[('input', FloatTensorType([1, 2]))])

# Now, we save the ONNX model into binary format.
from winmltools.utils import save_model
save_model(linear_svc_onnx, 'linear_svc.onnx')

# If you'd like to load an ONNX binary file, our tool can also help.
from winmltools.utils import load_model
linear_svc_onnx = load_model('linear_svc.onnx')

# To see the produced ONNX model, we can print its contents or save it in text format.
print(linear_svc_onnx)
from winmltools.utils import save_text
save_text(linear_svc_onnx, 'linear_svc.txt')

# The conversion of linear regression is very similar. See the example below.
from sklearn.svm import LinearSVR
linear_svr = LinearSVR()
linear_svr.fit(X, y)
linear_svr_onnx = convert_sklearn(linear_svr, 7, name='LinearSVR',
                                  initial_types=[('input', FloatTensorType([1, 2]))])

Как и раньше, convert_sklearn принимает модель scikit-learn в качестве первого аргумента и target_opset в качестве второго.As before convert_sklearn takes a scikit-learn model as its first argument, and the target_opset for the second argument. Пользователи могут заменить LinearSVC другими моделями scikit-learn, например RandomForestClassifier.Users can replace LinearSVC with other scikit-learn models such as RandomForestClassifier. Обратите внимание, что mlgen использует для создания имен классов и переменных параметр name.Please note that mlgen uses the name parameter to generate class names and variables. Если name не предоставляется, создается идентификатор GUID, который не будет соответствовать соглашениям об именовании для таких языков, как C++/C#.If name is not provided, then a GUID is generated, which will not comply with variable naming conventions for languages like C++/C#.

Преобразование конвейеров scikit-learnConvert scikit-learn pipelines

Теперь мы рассмотрим, как преобразовать в формат ONNX конвейеры scikit-learn.Next, we show how scikit-learn pipelines can be converted into ONNX.

# First, we create a toy data set.
# Notice that the first example's last feature value, 300, is large.
X = [[0.5, 1., 300.], [-1., -1.5, -4.], [0., -2., -1.]]
y = [1, -1, -1]

# Then, we declare a linear classifier.
from sklearn.svm import LinearSVC
linear_svc = LinearSVC()

# One common trick to improve a linear model's performance is to normalize the input data.
from sklearn.preprocessing import Normalizer
normalizer = Normalizer()

# Here, we compose our scikit-learn pipeline.
# First, we apply our normalization.
# Then we feed the normalized data into the linear model.
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(normalizer, linear_svc)
pipeline.fit(X, y)

# Now, we convert the scikit-learn pipeline into ONNX format.
# Compared to the previous example, notice that the specified feature dimension becomes 3.
# The automatic code generator (mlgen) uses the name parameter to generate class names.
from winmltools import convert_sklearn
from winmltools.convert.common.data_types import FloatTensorType, Int64TensorType
pipeline_onnx = convert_sklearn(linear_svc, name='NormalizerLinearSVC',
                                input_features=[('input', FloatTensorType([1, 3]))])

# We can print the fresh ONNX model.
print(pipeline_onnx)

# We can also save the ONNX model into a binary file for later use.
from winmltools.utils import save_model
save_model(pipeline_onnx, 'pipeline.onnx')

# Our conversion framework provides limited support of heterogeneous feature values.
# We cannot have numerical types and string types in one feature vector.
# Let's assume that the first two features are floats and the last feature is integers (encoded a categorical attribute).
X_heter = [[0.5, 1., 300], [-1., -1.5, 400], [0., -2., 100]]

# One popular way to represent categorical is one-hot encoding.
from sklearn.preprocessing import OneHotEncoder
one_hot_encoder = OneHotEncoder(categorical_features=[2])

# Let's initialize a classifier.
# It will be right after the one-hot encoder in our pipeline.
linear_svc = LinearSVC()

# Then, we form a two-stage pipeline.
another_pipeline = make_pipeline(one_hot_encoder, linear_svc)
another_pipeline.fit(X_heter, y)

# Now, we convert, save, and load the converted model.
# For heterogeneous feature vectors, we need to separately specify their types for
# all homogeneous segments.
# The automatic code generator (mlgen) uses the name parameter to generate class names.
another_pipeline_onnx = convert_sklearn(another_pipeline, name='OneHotLinearSVC',
                                        input_features=[('input', FloatTensorType([1, 2])),
                                        ('another_input', Int64TensorType([1, 1]))])
save_model(another_pipeline_onnx, 'another_pipeline.onnx')
from winmltools.utils import load_model
loaded_onnx_model = load_model('another_pipeline.onnx')

# Of course, we can print the ONNX model to see if anything went wrong.
print(another_pipeline_onnx)

Преобразование моделей TensorFlowConvert TensorFlow models

Следующий пример кода преобразует зафиксированную модель TensorFlow.The following code is an example of how to convert a model from a frozen TensorFlow model. Чтобы получить возможные выходные имена модели TensorFlow, можно использовать средство summarize_graph.To get the possible output names of a TensorFlow model, you can use the summarize_graph tool.

import winmltools
import tensorflow

filename = 'frozen-model.pb'
output_names = ['output:0']

graph_def = graph_pb2.GraphDef()
with open(filename, 'rb') as file:
  graph_def.ParseFromString(file.read())
g = tf.import_graph_def(graph_def, name='')

with tf.Session(graph=g) as sess:
  converted_model = winmltools.convert_tensorflow(sess.graph, 7, output_names=['output:0'])
  winmltools.save_model(converted_model)

Преобразователь WinMLTools использует tf2onnx.tfonnx.process_tf_graph в TF2ONNX.The WinMLTools converter uses tf2onnx.tfonnx.process_tf_graph in TF2ONNX.

Преобразование в 16-разрядные значения с плавающей запятойConvert to floating point 16

WinMLTools поддерживает преобразование моделей, представленных в формате 32-разрядных значений с плавающей запятой, в представление 16-разрядных значений с плавающей запятой (IEEE 754 half), что позволяет вдвое уменьшить размер модели.WinMLTools supports the conversion of models represented in floating point 32 into a floating point 16 representation (IEEE 754 half), effectively compressing the model by reducing its size in half.

Примечание

Преобразование модели в 16-разрядным значениям с плавающей запятой может привести к снижению точности.Converting your model to floating point 16 could result in a loss of accuracy. Не забудьте проверить точность модели перед ее развертыванием в приложении.Make sure you verify the model’s accuracy before deploying into your application.

Ниже приведен полный пример преобразования непосредственно из двоичного файла ONNX.Below is a full example if you want to convert directly from an ONNX binary file.

from winmltools.utils import convert_float_to_float16
from winmltools.utils import load_model, save_model
onnx_model = load_model('model.onnx')
new_onnx_model = convert_float_to_float16(onnx_model)
save_model(new_onnx_model, 'model_fp16.onnx')

См. сведения об этом средстве с помощью help(winmltools.utils.convert_float_to_float16).With help(winmltools.utils.convert_float_to_float16), you can find more details about this tool. 16-разрядные значения с плавающей запятой в WinMLTools сейчас соответствуют только числам с плавающей запятой половинной точности (стандарт IEEE 754 (2008)).The floating point 16 in WinMLTools currently only complies with IEEE 754 floating point standard (2008).

Применение дискретизации весовых коэффициентов после обученияPost-training weight quantization

WinMLTools также поддерживает сжатие моделей, представленных в формате 32-разрядных значений с плавающей запятой, в 8-разрядные целочисленные представления.WinMLTools also supports the compression of models represented in floating point 32 into 8-bit integer representations. Это может снизить размер модели на диске на 75 %, в зависимости от модели.This could yield a disk footprint reduction of up to 75% depending on the model. Такое сокращение выполняется методом дискретизации весовых коэффициентов, в котором значения параметров модели анализируются. При этом сохраненные в тензоре весовые коэффициенты преобразуются из 32-разрядных чисел с плавающей запятой в 8-разрядные данные.This reduction is done via a technique called post-training weight quantization, where the model is analyzed and the stored tensor weights are reduced from 32-bit floating point data into 8-bit data.

Примечание

Дискретизация весовых коэффициентов после обучения может привести к снижению точности результирующей модели.Post-training weight quantization may result in loss of accuracy in the resulting model. Не забудьте проверить точность модели перед ее развертыванием в приложении.Make sure you verify the model’s accuracy before deploying into your application.

Ниже приведен полный пример, в котором демонстрируется преобразование непосредственно из двоичного файла ONNX.The following is a complete example that demonstrates how to convert directly from an ONNX binary file.

import winmltools

model = winmltools.load_model('model.onnx')
packed_model = winmltools.quantize(model, per_channel=True, nbits=8, use_dequantize_linear=True)
winmltools.save_model(packed_model, 'quantized.onnx')

Вот еще некоторые сведения о входных параметрах quantize:Here is some information about the input parameters to quantize:

  • per_channel: Если задано значение True, применяется линейная дискретизация каждого канала для каждого инициализированного тензора в формате [n, c, h, w].per_channel: If set to True, this will linearly quantize each channel for each initialized tensor in [n,c,h,w] format. По умолчанию этот параметр имеет значение True.By default, this parameter is set to True.
  • nbits: Число битов для представления квантованных значений.nbits: The number of bits to represent quantized values. Сейчас поддерживается только 8 битов.Currently only 8 bits is supported.
  • use_dequantize_linear: Если задано значение True, применяется линейный процесс, обратный квантованию каждого канала, в инициализированных тензорах для операторов Conv в формате [n, c, h, w].use_dequantize_linear: If set to True, this will linearly dequantize each channel in initialized tensors for Conv operators in [n,c,h,w] format. По умолчанию устанавливается значение True.By default, this is set to True.

создание пользовательских операторов ONNX.Create custom ONNX operators

Для преобразования модели Keras или Core ML можно написать пользовательскую функцию оператора, чтобы внедрять пользовательские операторы в граф ONNX.When converting from a Keras or a Core ML model, you can write a custom operator function to embed custom operators into the ONNX graph. Во время преобразования преобразователь вызывает эту функцию, чтобы перевести слой Keras или объект LayerParameter из Core ML в оператор ONNX, а затем подключает узел оператора ко всему графу.During the conversion, the converter invokes your function to translate the Keras layer or the Core ML LayerParameter to an ONNX operator, and then it connects the operator node into the whole graph.

  1. Создайте пользовательскую функцию для создания вложенного графа ONNX.Create the custom function for the ONNX sub-graph building.
  2. Вызовите winmltools.convert_keras или winmltools.convert_coreml с картой сопоставления имен пользовательских слоев и пользовательских функций.Call winmltools.convert_keras or winmltools.convert_coreml with the map of the custom layer name to the custom function.
  3. Если применимо, реализуйте пользовательский слой для среды выполнения вывода.If applicable, implement the custom layer for the inference runtime.

В следующем примере показано, как это работает в Keras.The following example shows how it works in Keras.

# Define the activation layer.
class ParametricSoftplus(keras.layers.Layer):
    def __init__(self, alpha, beta, **kwargs):
    ...
    ...
    ...

# Create the convert function.
def convert_userPSoftplusLayer(scope, operator, container):
      return container.add_node('ParametricSoftplus', operator.input_full_names, operator.output_full_names,
        op_version=1, alpha=operator.original_operator.alpha, beta=operator.original_operator.beta)

winmltools.convert_keras(keras_model, 7,
    custom_conversion_functions={ParametricSoftplus: convert_userPSoftplusLayer })

Примечание

Используйте следующие ресурсы для получения справки по машинному обучению в Windows:Use the following resources for help with Windows ML:

  • Чтобы задать технические вопросы о машинном обучении в Windows или ответить на них, используйте тег windows-machine-learning в Stack Overflow.To ask or answer technical questions about Windows ML, please use the windows-machine-learning tag on Stack Overflow.
  • Сообщить об ошибке можно в нашем репозитории GitHub.To report a bug, please file an issue on our GitHub.
  • Чтобы отправить запрос на добавление функции, перейдите на сайт Windows Developer Feedback.To request a feature, please head over to Windows Developer Feedback.
Машинное обучение

— модели — Apple Developer

PoseNetMobileNet075S8FP16.mlmodel Эта модель использует архитектуру MobileNetV1 с множителем ширины 0,75 и шагом вывода 8, сохраняя свои веса с использованием чисел с плавающей запятой половинной точности (16 бит).
2,6 МБ

PoseNetMobileNet075S16FP16.млмодель Эта модель использует архитектуру MobileNetV1 с множителем ширины 0,75 и шагом вывода 16, сохраняя свои веса с использованием чисел с плавающей запятой половинной точности (16 бит).
2,6 МБ

PoseNetMobileNet100S8FP16.mlmodel В этой модели используется архитектура MobileNetV1 с множителем ширины 1.00 и выходной шаг 8, сохраняя его веса с использованием чисел с плавающей запятой половинной точности (16 бит).
6,7 МБ

PoseNetMobileNet100S16FP16.mlmodel Эта модель использует архитектуру MobileNetV1 с множителем ширины 1,00 и шагом вывода 16, сохраняя свои веса с использованием чисел с плавающей запятой половинной точности (16 бит).
6,7 МБ

Определение позы человеческого тела на изображении Найдите людей и положение их тел, анализируя изображение с помощью модели PoseNet.

.

Используйте развертывание модели и безопасность с Core ML — WWDC 2020 — Видео

Скачать

Здравствуйте и добро пожаловать на WWDC.

Здравствуйте. Меня зовут Анил Катти, и я рад поделиться с вами некоторыми из замечательных новых функций, которые мы представили в этом году в Core ML. Core ML позволяет легко интегрировать машинное обучение в ваше приложение, открывая двери к бесчисленным удивительным возможностям для ваших пользователей. Ваша модель Core ML — это то, что делает все эти возможности возможными.Сегодня мы представляем новые функции, связанные с этой моделью. В этом сеансе мы собираемся охватить несколько тем, от нового способа развертывания ваших моделей до их шифрования и некоторых улучшений в Xcode. Давайте начнем. Мы разработали Core ML с учетом рабочего процесса разработки приложений. Когда у вас есть модель, вы можете интегрировать ее в свое приложение, просто перетащив ее в свой проект Xcode. Xcode компилирует вашу модель в оптимальный формат для работы на устройстве. Когда вы отправляете свое приложение, скомпилированная модель связывается с вашим приложением.Вместе они попадают в App Store, а затем на устройства ваших пользователей. Объединение модели с вашим приложением отлично работает, и мы настоятельно рекомендуем это сделать. Таким образом, модель становится доступной, как только пользователь устанавливает приложение. Есть сценарии, в которых может потребоваться большая гибкость и контроль над процессом доставки модели. Сегодня мы представляем развертывание базовой модели машинного обучения, чтобы предоставить вам такую ​​гибкость.

Core ML Model Deployment предоставляет вам новый способ доставки моделей в ваши приложения. С помощью панели управления развертыванием моделей можно хранить, управлять и развертывать модели через облако Apple.Устройства периодически получают обновления по мере их появления. Развертывание моделей дает вам возможность разрабатывать и развертывать модели независимо от цикла обновления приложения, новый способ группировки и управления моделями, которые работают вместе, а также возможность нацеливать модели на определенные группы устройств.

Нам очень нравятся эти функции, поэтому давайте рассмотрим каждую из них более подробно. Начнем с самостоятельной разработки.

Обычно, когда вы переобучаете свои модели, вы, вероятно, планируете объединить их с вашим следующим обновлением приложения.

Но что, если вы обновляете свои модели с другой скоростью, чем ваше приложение? В прошлом вам приходилось выпускать больше обновлений приложений, чтобы получить новые модели в руки ваших пользователей.

Теперь, с помощью развертывания моделей, вы можете быстро и легко обновить свои модели, не обновляя само приложение. Далее: коллекции моделей.

Коллекции моделей — отличный способ сгруппировать одну или несколько моделей, связанных с функцией в вашем приложении. Например, предположим, что вы работаете над игрой, и для одного из ее уровней требуется набор моделей для поддержки функции.Вы можете синхронизировать эти модели, сгруппировав их в одну коллекцию моделей. Когда вы развертываете коллекцию моделей, это развертывание хранит все модели в коллекции вместе и атомарно доставляет их в ваше приложение. Я очень хочу показать все это в действии, но прежде чем мы перейдем к демонстрации, позвольте мне описать, как мы будем использовать эту функцию.

Итак, внедрение модели развертывания состоит из трех шагов. Первый шаг — использовать новый Core ML API, чтобы подписаться на развертывание модели.Затем подготовьте модель к развертыванию, создав архив модели. Вы можете сделать это в Xcode.

Последний шаг — загрузить подготовленную модель и развернуть ее на панели мониторинга развертывания модели. Вам нужно будет только повторять шаги два и три каждый раз при обновлении модели. Давайте подробнее рассмотрим эти шаги на демонстрации. У меня есть простое приложение, которое классифицирует цветы и применяет классные визуальные эффекты при двойном нажатии на картинку. Он использует две модели Core ML: классификатор изображений и модель передачи стилей.

Я решил интегрировать развертывание моделей, чтобы можно было отделить обновление моделей от процесса обновления приложения и выполнять итерацию моделей независимо.

Итак, первым шагом является использование нового API для подписки на развертывание модели. Посмотрим, как это сделать в Xcode. У меня открыт проект Xcode. Хотя это приложение выполняет несколько функций, в этой демонстрации давайте сосредоточимся на функции классификации цветов.

Вот ключевой метод, который мы собираемся реализовать сегодня. Он классифицирует цветок в данном изображении и обновляет пользовательский интерфейс с помощью метки класса.

Первое, что я хочу сделать при вызове этого метода, — это создать экземпляр FlowerClassifier и сохранить его в переменной. Это позволило бы мне получить доступ к предварительно загруженной модели в последующих вызовах и не загружать модель каждый раз.

Итак, позвольте мне начать с проверки предварительно загруженного корпуса.

Здесь я проверяю, установлена ​​ли уже переменная, и если да, то использую ее для классификации изображения и немедленного возврата. Далее давайте реализуем логику загрузки модели.

Напомним, что модели сгруппированы по коллекциям. Я покажу, как создавать и развертывать коллекции моделей на новой панели инструментов за несколько минут. Но здесь меня интересует доступ к уже развернутой коллекции. Я могу сделать это, просто вызвав метод beginAccessing в MLModelCollection.

При первом вызове этого метода для коллекции моделей с идентификатором система загружает все модели в этой коллекции в фоновой очереди и регистрируется для будущих обновлений этих моделей.Вы можете отслеживать загрузку с помощью объекта progress.

Здесь мы используем идентификатор коллекции моделей «FlowerModels». Давайте просто запомним это, поскольку это потребуется при создании коллекции моделей позже.

Этот метод также асинхронно возвращает экземпляр MLModelCollection в качестве типа результата. Давайте посмотрим, как мы можем получить доступ к загруженным моделям из этого результата.

Когда эта операция завершается успешно, мы получаем экземпляр коллекции моделей, который содержит записи коллекции моделей.Для каждой модели есть одна запись. Я могу получить доступ к записи коллекции моделей для нашей модели FlowerClassifier, используя имя модели в качестве ключа. Внутри записи находится URL-адрес модели, указывающий на скомпилированную модель, которая была загружена и помещена в контейнер приложения системой.

Не удалось получить доступ к коллекции моделей. Например, если при первом вызове нет подключения к сети, загрузка моделей завершится ошибкой. Важно уладить случай отказа. В этом примере мы просто регистрируем ошибку и возвращаемся к использованию связанной модели.Далее давайте реализуем логику загрузки модели.

Я реализовал простой вспомогательный метод для загрузки модели. Он принимает необязательный modelURL в качестве входных данных и использует его для загрузки модели FlowerClassifier. Если URL-адрес равен нулю, он просто откатывается и загружает модель, которая связана с приложением.

Последний шаг — использовать этот FlowerClassifier для классификации изображения.

Вот код для этого. Когда загрузка модели завершается успешно, мы используем загруженную модель для классификации изображения, а также сохраняем ее в переменной для последующих запросов классификации.У нас есть отдельный метод для обработки сбоев загрузки модели, который в этом случае отображает подходящее сообщение об ошибке для пользователя.

Это весь код, необходимый для подготовки приложения к развертыванию модели. Как теперь подготовить саму модель к развертыванию? Что ж, я могу сделать это в Xcode. Если вы щелкните модель в Xcode, вы увидите, что в этом году мы представили новую вкладку утилит, в которой есть раздел для развертывания модели.

Я могу подготовить модель к развертыванию, создав архив модели.

Хорошо, Xcode создал FlowerClassifier.mlarchive и сохранил его на диске. Я могу найти файл, нажав здесь.

Он находится рядом с файлом исходной модели. Последний шаг — развернуть эту модель на панели управления развертыванием модели. Xcode предоставляет кнопку, которая переводит вас прямо на панель мониторинга развертывания модели в Safari. Первое, что вы заметите на панели инструментов, это то, что у нас есть способ создать коллекцию моделей. Я начну с создания новой коллекции моделей для наших цветочных моделей и назову ее «FlowerModels».«Это должно совпадать с тем, что было указано в приложении.

Затем давайте дадим хорошее описание. Что-то вроде …

« Коллекция моделей, созданных для изображений цветов ». А затем укажите две модели, которые мы планируем собрать. в этой коллекции первым является FlowerClassfier.

А затем у нас есть FlowerStylizer.

И затем нажмите кнопку создания.

Затем я могу развернуть модели, создав новое развертывание. Я назову это глобальным развертыванием. поскольку я намерен развернуть эти модели в своем приложении на всех устройствах.

Я могу загрузить архивы моделей, которые я создал для каждого из этих названий моделей. Позвольте мне сначала выбрать FlowerClassfier, затем Stylizer и нажать кнопку развертывания в правом верхнем углу.

На странице коллекции моделей я могу проверить, что только что созданное мной развертывание находится в активном состоянии. Так что это выглядит хорошо.

Эти модели доступны на всех устройствах, на которых работает версия моего приложения, в которой используется эта коллекция моделей. Позвольте мне запустить приложение и попробовать классифицировать цветы сейчас.

Я сорвал георгин и увидел, что он классифицируется как георгин. Дай мне на этот раз попробовать гибискус.

Приложение, кажется, тоже правильно понимает это. Модель, которую я использовал здесь, была обучена только на трех разных классах, и Роуз не был одним из них. Позвольте мне попробовать изображение розы и посмотреть, что получится.

Как и ожидалось, приложение не распознает розу.

Допустим, я хочу улучшить свое приложение для классификации роз. Поскольку я уже использовал развертывание моделей в этом приложении, я могу легко добавить эту функцию, развернув модель, переобученную с изображениями роз, с помощью развертывания модели.Для этой демонстрации я уже подготовил обновленную модель к развертыванию.

Перейдем к панели мониторинга развертывания и посмотрим, как обновить модель. Я могу развернуть обновленную модель, создав новое развертывание. На этот раз я выберу улучшенный классификатор и тот же стилизатор и нажму кнопку развертывания.

Как и раньше, эти обновленные модели доступны в моем приложении на всех устройствах, но это может произойти не сразу. Каждое устройство определяет подходящее время для загрузки модели в фоновом режиме и делает ее доступной для приложения при следующем запуске.

Давайте посмотрим, что произойдет, когда мое приложение запустится после того, как ОС синхронизирует обновленные модели с устройством. Выбирая ту же розу, которая не была классифицирована ранее, я вижу, что на этот раз она классифицируется как роза.

Итак, не меняя ни одной строчки кода, мы улучшили взаимодействие с пользователем, улучшив модель, и я думаю, что это действительно здорово.

Далее поговорим о целевых развертываниях.

Обычно, когда ваше приложение молодое, у него может быть только один набор моделей для всех ваших пользователей.Однако по мере развития вашего приложения для вас может иметь больше смысла использовать специализированные модели для разных групп населения. Одно из решений — просто объединить все модели в свое приложение и использовать правильную во время выполнения, но это не очень эффективно. А что, если модели большие, а размер загружаемого приложения должен быть небольшим? При целевом развертывании вы можете определить правила, чтобы устройство каждого пользователя получало только ту модель, которая ему нужна.

Давайте посмотрим, как настроить один из них.

Недавно я улучшил наш FlowerClassifier, но специально сделал это для iPad.Оказывается, угол камеры и настройки освещения на изображениях, сделанных на iPad, немного отличаются от таковых на iPhone. Хотя я хочу использовать новую модель на iPad, существующая модель отлично работает на всех других устройствах. Давайте посмотрим, как мы можем нацелить конкретную модель iPad только на iPad.

Вернувшись на панель инструментов, я могу либо клонировать существующее развертывание, либо создать новое. А пока я создам новый и назову его Targeting iPads.

Сначала я выбираю модели по умолчанию для этого развертывания.Эти модели будут доставлены на все устройства, не соответствующие правилам развертывания.

После этого я могу добавить дополнительное правило таргетинга. Вы можете увидеть все различные критерии, на которые я могу ориентироваться. Я выберу класс устройства и выберу iPad. Итак, для этого правила таргетинга я выбираю модели для iPad.

Теперь я могу развернуть эти модели. Устройства выбирают правильную модель в зависимости от класса устройства. Никаких дополнительных изменений в приложении не требуется. Мы показали вам, как легко использовать Core ML Model Deployment, чтобы помочь с некоторыми интересными примерами использования.Вот некоторые вещи, о которых следует помнить при использовании этой функции. Во-первых, мы настоятельно рекомендуем протестировать каждую модель локально, прежде чем загружать ее на панель управления развертыванием. Это гарантирует, что у ваших пользователей не останутся модели, которые не работают.

Затем имейте в виду, что развертываемые модели не будут доступны на устройствах сразу. Система каждого устройства решает, когда загружать модель в фоновом режиме. Следовательно, у вашего приложения всегда должен быть запасной план, когда развернутые модели недоступны.

Наконец, коллекция моделей предоставляет удобный способ систематизировать модели. Мы рекомендуем группировать коллекции моделей по каждой функции вашего приложения. Итак, подведем итог тому, что мы вам показали: Развертывание Core ML Model Deployment — это новый способ доставки моделей вашим пользователям, независимо от обновлений приложений. Коллекции моделей дают вам новый способ группировки и работы с вашими моделями, а целевые развертывания очень полезны, когда вы хотите развернуть модели для разделения групп. Мы думаем, что эти функции дадут вам большую гибкость и сделают более удобным предоставление моделей вашим пользователям.Я передам его Джону Дюранту, и он расскажет нам больше о некоторых других интересных функциях, которые у нас есть для вас в этом году.

Спасибо, Анил. Всем привет, спасибо, что присоединились к нам. Мы очень рады поделиться с вами этими функциями, и нам не терпится увидеть потрясающие приложения, которые вы создадите с их помощью. Пока что мы рассмотрели несколько новых и более быстрых способов предоставить ваши модели вашим пользователям. Теперь давайте посмотрим, как можно зашифровать эти модели. С помощью шифрования моделей вы можете распространять свои модели, зная, что они зашифрованы в состоянии покоя и при передаче.Давайте посмотрим, что это значит и как это работает. Независимо от того, связана ли ваша модель с вашим приложением или развернута в облаке, Xcode фактически шифрует скомпилированную модель Core ML. Эта скомпилированная модель, а не исходный файл .mlmodel, на самом деле находится внутри вашего приложения на устройстве пользователя. Итак, как вы зашифруете эту скомпилированную модель? Легко. С Xcode. Первое, что вам понадобится, это ключ шифрования. Я покажу вам, как сделать ключ за несколько минут. С помощью ключа вы можете указать Xcode зашифровать вашу модель во время сборки.Или вы можете использовать ключ для шифрования архива модели при его создании. В любом случае скомпилированная модель остается зашифрованной при передаче и хранении на устройстве пользователя. Итак, как использовать зашифрованную модель во время выполнения? Что ж, вы используете зашифрованную модель так же, как и обычную. Core ML автоматически расшифровывает модель за вас, но расшифрованная модель существует только в памяти. Скомпилированная модель в файловой системе всегда остается зашифрованной.

При первой загрузке зашифрованной модели ОС безопасно извлекает и надежно сохраняет ключ дешифрования модели от имени вашего приложения.После этого вашему приложению не потребуется сетевое соединение для повторной загрузки той же модели. Давайте перейдем к Xcode и посмотрим, насколько легко применить шифрование модели. Я вернусь к тому же приложению, которое Анил использовал раньше. Допустим, я хочу зашифровать нашу модель классификации изображений.

Первое, что мне нужно сделать, это создать ключ шифрования. Для этого я открою модель в Xcode, перейду сюда на вкладку утилит и нажму «Создать ключ шифрования». Здесь мы видим, что Xcode связывает ключ шифрования с командой, поэтому важно выбрать ту же учетную запись группы, которую вы используете для создания своего приложения.Когда я нажимаю «Продолжить», Xcode отправляет запрос в облако Apple, которое генерирует новый ключ шифрования. Сервер надежно хранит ключ и отправляет копию обратно в Xcode. Итак, теперь мы видим, что Xcode сгенерировал новый файл с расширением .mlmodelkey ​​и сбросил его рядом с моей моделью Core ML. Итак, мы видим, что у нас есть .mlmodel и .mlmodelkey.

Хорошо, отлично. Теперь у нас есть ключ. Теперь мы можем взять этот ключ и поделиться им в защищенном репозитории ключей нашей команды, чтобы другие разработчики в нашей команде могли его использовать.

Теперь, когда у нас есть ключ, мы можем использовать его для шифрования нашей модели. Во-первых, давайте посмотрим на сценарий, который Анил показал ранее, где он развернул модель с помощью Core ML Model Deployment. На этот раз, когда я создаю архив модели, Xcode предварительно выбирает ключ .mlmodel, расположенный рядом с моей моделью. Давайте нажмем «Продолжить», и мы увидим, что Xcode генерирует архив модели, как и раньше, но на этот раз он шифрует содержимое архива. Остальные шаги точно такие же, как и раньше. Я могу просто развернуть этот зашифрованный архив модели, загрузив его на панель управления Core ML Model Deployment, как это сделал ранее Анил.Хорошо, это отлично подходит для развертываний. Но что, если я хочу связать модель в самом приложении? Что ж, есть способ зашифровать и эти модели. В этом приложении у меня есть вторая модель под названием FlowerStylizer.

Я снова запущу приложение, чтобы мы увидели, что оно делает. Когда я выбираю изображение и дважды нажимаю на него, мы видим, что применяется крутой эффект переноса стиля. Хорошо выглядеть! Если вы хотите построить одну из этих моделей самостоятельно, вы можете проверить сеанс под названием «Создание моделей передачи стилей изображений и видео в Create ML».«Теперь эта модель входит в комплект моего пакета приложений. Если я хочу ее зашифровать, я должен сгенерировать для нее ключ, а затем сказать Xcode, что нужно зашифровать модель во время сборки. Сначала я сгенерирую ключ для этой модели.

Мы видим, что FlowerClassifier.mlmodelkey ​​был сохранен на диск.

Теперь мне нужно сказать Xcode использовать этот ключ для шифрования во время сборки.

Я собираюсь взять эти флаги компилятора. Я перейду к свойствам своего проекта, фазам сборки, исходным кодам компиляции и поищу свою модель.Вот оно. У меня есть FlowerStylizer.mlmodel. И я собираюсь перейти сюда к флагам компилятора.

И я собираюсь вставить шифрование тире, а затем указатель на файл .mlmodelkey ​​на диске.

Как только мы это сделаем, мы сможем продолжить и строить заново.

Итак, теперь, каждый раз, когда я создаю приложение, Core ML Compiler будет компилировать модель, а затем шифровать ее с помощью ключа шифрования модели. Это означает, что теперь в приложение встроена зашифрованная скомпилированная модель.Хорошо, теперь давайте посмотрим, как мы можем загрузить зашифрованную модель.

Если мы перейдем сюда, то увидим, что у нас есть функция под названием «Стилизация изображения». Теперь, поскольку для загрузки модели в первый раз требуется сетевое соединение, мы представили метод асинхронной загрузки модели. Вот прямо здесь. FlowerStylizer.load. Мы собираемся отказаться от инициализатора по умолчанию и настоятельно рекомендуем перейти на новый метод .load, так как он дает вам возможность обрабатывать ошибки загрузки модели.

Load автоматически получает ключ из облака Apple и работает так, как вы ожидаете.Несмотря на то, что Core ML требуется доступ к сети для получения ключа в первый раз, ему никогда не потребуется получать этот ключ снова. Например, предположим, что вы закрываете свое приложение, а затем снова запускаете его. На этот раз Core ML не выполняет сетевой запрос, потому что ОС надежно хранит ключ локально.

Вы можете видеть, что мы возвращаем результат «T», который содержит модель, и мы можем развернуть его в случае успеха, после чего у нас есть наша модель, и мы можем продолжить стилизацию, как раньше, или у нас также есть случай отказа.В случае сбоя у нас есть вспомогательный метод, и вы заметите, что здесь мы специально перехватываем ошибку modelKeyFetch. И в этом случае мы можем сообщить пользователю, что ему необходимо подключение к сети, или повторить попытку позже. И это все. Принять модель шифрования действительно так просто. Таким образом, вы можете использовать шифрование модели в три простых шага. Сначала сгенерируйте ключ шифрования с помощью Xcode. Затем зашифруйте вашу модель с помощью ключа шифрования. И, наконец, загрузите и используйте зашифрованную модель на устройстве.Создать, зашифровать, загрузить. Это так просто.

Шифрование модели работает без проблем, независимо от того, объединяете ли вы модель в свое приложение или отправляете ее через развертывание модели. Все, что вам нужно сделать, это создать ключ, зашифровать вашу модель и вызвать .load. Мы позаботимся обо всем остальном, чтобы вы могли сосредоточиться на создании отличного приложения. Прежде чем мы закончим, у нас есть еще несколько интересных обновлений Xcode для Core ML, которыми мы хотели бы поделиться с вами.

Во время наших демонстраций вы могли заметить, что Xcode теперь показывает вам гораздо больше информации о вашей модели.Теперь вы можете сразу увидеть, какие версии ОС поддерживает модель, ее метки классов и даже некоторые детали внутренней нейронной сети. Еще одна новая функция, которую мы считаем особенно полезной, не говоря уже о развлечениях, — это интерактивный предварительный просмотр модели.

Теперь вы можете в интерактивном режиме предварительно просмотреть и поэкспериментировать с вашей моделью прямо в Xcode, прежде чем писать одну строку кода. Мы поддерживаем предварительный просмотр для широкого спектра моделей, таких как сегментация изображения, определение позы, оценка глубины и многие другие, включая все модели, которые вы можете обучить с помощью Create ML.Полный список типов предварительного просмотра приведен здесь, и мы рекомендуем вам изучить модели, доступные на developer.apple.com.

Мы также рады сообщить, что модели Core ML теперь являются первоклассными гражданами в Xcode Playgrounds. Просто перетащите модель Core ML в папку с ресурсами. Теперь ваша площадка получает тот же автоматически созданный интерфейс класса, что и проект Xcode. Это позволяет вам программно экспериментировать с вашей моделью в интерактивном сеансе программирования. Игровые площадки — также отличный способ поделиться демонстрациями моделей с друзьями и коллегами.

Сегодня мы рассмотрели много вопросов, поэтому давайте подведем итоги. Мы представили развертывание Core ML Model Deployment, которое позволяет вам доставлять модели Core ML независимо от вашего приложения. Это упрощает быстрое распространение и нацеливание ваших моделей по мере их улучшения. Мы думаем, что это значительно ускорит процесс разработки приложений и ускорит внедрение машинного обучения.

Мы также представили шифрование моделей, которое защищает ваши модели во время транспортировки и в состоянии покоя, без необходимости настраивать собственный хостинг и управлять ключами.Теперь вы можете зашифровать модели Core ML, независимо от того, поставляются ли они с вашим приложением или как часть развертывания модели. И, наконец, мы добавили в Xcode некоторые улучшения Core ML, которые упростили понимание, предварительный просмотр и взаимодействие с вашими моделями. Спасибо за просмотр нашего сеанса и наслаждайтесь остальной частью WWDC.

.

Представляем приложение Create ML — WWDC 2019 — Видео

Скачать

В этом году наша версия Create ML содержит новые модели и совершенно новый рабочий процесс.

Каждый рабочий процесс начинается с ввода.

Устройства, которые мы разрабатываем, используем и любим, богаты информацией от различных датчиков, таких как камера, микрофон, клавиатура, акселерометр и даже гироскоп.

И все эти типы ввода можно использовать, чтобы вы могли обучать модели машинного обучения и делать свои приложения более персонализированными и интеллектуальными.

В прошлом году мы поддержали три из этих типов ввода; изображения, текст и табличные данные.

В этом году мы увеличиваем набор доступных доменов с трех до пяти. А теперь представляем Activity и Sound.

Мы также расширяем спектр доступных моделей для всех из них. И все это переносится в новую среду.

Мы называем это приложением Create ML.

Все начинается с определения вашего домена.

И как только вы отфильтруете свой ввод, вы увидите все доступные типы моделей, которые вы можете создать.

Create ML затем разбивает задачу создания модели машинного обучения на три простых этапа; ввод, обучение и вывод.

Эта новая среда меняет способ взаимодействия с машинным обучением в системе.

Затем приложение отображает обзор ваших данных и богатый набор аналитических данных по мере обучения.

Вы можете визуализировать прогресс вашей модели в удобном для понимания графическом виде, который отображает точность вашей модели по итерациям.

Вы также можете увидеть разбивку значений точности и отзыва для каждого класса, на котором была обучена ваша модель.

Таблица является интерактивной, поэтому вы можете фильтровать по классу или по проценту, чтобы лучше понять производительность вашей модели.

Процесс тестирования так же прост, как перетаскивание новых данных.

Вы можете пройти обучение и повторить тест, просто нажав кнопку «Тест».

И что действительно уникально в Create ML, так это то, что вы можете легко предварительно просмотреть обученные модели на вкладке «Вывод».

Эта новая функция позволяет вам точно видеть, как ваша модель будет прогнозировать, без необходимости включать ваши модели в свои приложения.

Это означает, что больше не нужно ждать их развертывания.

Вы можете сделать это прямо в Create ML, сэкономив время на совершенствование ваших моделей.

Раздел предварительного просмотра также настраивается для каждого шаблона, обеспечивая полное сквозное взаимодействие для каждой задачи.

Но что может быть лучше, чем показать это вам вживую? Давайте взглянем.

Теперь, в Xcode, я работаю над классификатором цветов, чтобы помочь мне идентифицировать разные типы цветов.

И я использовал модель, которую я скачал из галереи моделей, под названием Resnet50.

И это хорошо известная модель классификатора изображений, обученная распознавать 1000 различных классов.

Но эта модель занимает около 100 мегабайт моего приложения.

И мы видим, когда я на самом деле пробую его на разных изображениях, он знает, что этот гибискус — цветок, но не знает его точного типа.

Значит, мне не совсем подходит. Теперь я могу из Xcode открыть Инструменты разработчика и запустить Create ML.

Затем мне будет предложено создать новый документ. И мы видим, что я запущен в представление шаблона, где я могу видеть все доступные модели, которые мы можем создать. Поскольку я работаю с изображениями, я буду фильтровать изображения и выбирать классификатор изображений.

Тогда мы можем назвать это.

А затем выберите место для сохранения, чтобы мы могли вернуться к нему позже.

Затем откройте представление «Новое приложение».

И вы можете видеть, что меня сначала просят перетащить ввод в качестве данных обучения.И если я прохожу через некоторые другие вкладки, они еще не разблокированы, потому что я не прошел через поток.

Итак, попробуем последовательно.

На своем рабочем столе я отложил несколько изображений разных видов цветов.

И вы видите, у меня есть немного гибискуса, немного пассифлоры, а затем даже несколько роз, георгинов и маргариток.

Я мог бы взять эту папку, перетащить ее и сразу увидеть, что в ней содержится 65 различных изображений, относящихся к пяти разным классам.Теперь, когда у нас есть входные данные, я могу нажать кнопку «Выполнить», и эта модель автоматически начнет обучение.

Сначала он начинается с извлечения элементов из изображений.

Затем мы можем увидеть прогресс по мере начала обучения.

Я могу видеть разбивку того, как модель работает с этими данными.

Но что я действительно хотел бы сделать, так это посмотреть, как модель работает с новыми данными, которых она не видела.

Итак, я перейду на вкладку Testing, перетащу эти новые цветы, которые я отложил, и нажму Test.

Теперь то, что мне действительно хотелось бы сделать, это взглянуть на обученную модель на вкладке «Вывод». И мы видим, что у меня есть классификатор цветов на 66 килобайт.

Теперь, чтобы предварительно просмотреть это, я сделал несколько других фотографий и, возможно, этого гибискуса, который раньше не работал с Resnet.

И теперь я вижу, что эта модель может правильно предсказать, что это такое.

И я могу видеть другие прогнозы, сделанные моделью, и значения достоверности для каждого из них. Я даже могу взять целую папку, перетащить их и отладить любое изображение, предсказанное этой моделью.

Теперь, когда я доволен, я могу взять эту модель и вытащить ее.

А затем реинтегрируйте это в мое приложение.

Более того, вы также можете использовать всю мощь камеры Continuity в Create ML.

Из этого я могу импортировать данные со своего телефона, который подключен.

И я могу попробовать сфотографировать этот цветок, который у меня здесь, на сцене, и мы увидим, как это получается.

И вообще-то все нормально.

Теперь, если вы недовольны своей производительностью или просто хотите провести еще несколько экспериментов, здесь также есть кнопка «Плюс».

И вы можете выбрать больше обучающих данных. Вы можете переключать, как указываются наши данные проверки, и даже данные тестирования.

На этот раз я, возможно, захочу подправить некоторые улучшения.

И тогда я могу нажать «Беги, чтобы тренироваться».

Это новый рабочий процесс в Create ML.

Вернемся к слайдам.

Итак, вы видели, что Create ML дает вам совершенно новый способ обучения пользовательским моделям машинного обучения на Mac с красивым внешним видом.

А с такими дополнениями, как визуализация показателей, прогресс в реальном времени и интерактивный предварительный просмотр, приложение Create ML устанавливает планку для отличного обучения модели.

В демонстрации мы рассмотрели только одну модель, которую вы можете создать с помощью Create ML.

Но в этом выпуске мы представляем девять.

Итак, давайте подробно рассмотрим все модели, которые вы можете создать, и несколько примеров примеров приложений.

Начиная с области изображений, у нас есть классификатор изображений и детектор объектов.

Классификатор изображений можно использовать для категоризации изображений на основе их содержимого.

Например, идентификатор художественного стиля использует настраиваемый классификатор изображений для определения наиболее вероятного движения части.

Затем он отдельно предоставляет обзор известных художников, чтобы завершить работу с приложением.

В Create ML классификатор изображений использует базовую технологию Apple, выполняя переносное обучение поверх модели печати с функциями машинного зрения, уже имеющейся в ОС.

Это позволяет сократить время обучения и уменьшить размер модели в приложении.

Кроме того, у вас есть возможность тренироваться с дополнениями, чтобы сделать ваши модели более надежными для невидимого ввода.

Если вместо этого вы хотите идентифицировать несколько объектов в изображении, а не один, вы можете создать детектор объектов.

Детекторы объектов могут использоваться для локализации и распознавания содержимого изображения.

Например, их можно обучить обнаруживать один или несколько классов, таких как определенные игральные карты или точные масти, содержащиеся на них.

Детектор объектов — это модель, основанная на глубоком обучении, которая выполняет дополнение данных, чтобы сделать ее более надежной.

И делает это полностью на GPU вашего Mac. Наша следующая область — звук.

В Sound у нас есть новая модель под названием Sound Classifier.

Эта модель позволяет определить наиболее доминирующий звук в аудиопотоке.

Поскольку аудиоданные основаны на временных рядах, вы можете различать начальную и конечную точки разных звуков, например, когда заканчивается гитарное соло и толпа сходит с ума.

В этой модели используется трансферное обучение, поэтому вы можете сократить время обучения.

И мы также понимаем, что оптимизация производительности сложных приложений является сложной задачей.

Вот почему мы хотим подчеркнуть, что эти модели легкие и работают на Neural Engine, что делает их идеальными для приложений реального времени на любом устройстве.

Наш третий домен — Activity.

А в Activity у нас впервые есть классификатор деятельности.

Эта модель также работает с данными на основе временных рядов. А классификаторы активности можно обучить категоризировать содержимое данных о движении от различных датчиков, таких как акселерометр и гироскоп.

Эти модели основаны на глубоком обучении и обучаются на графическом процессоре.

В результате получаются модели небольших размеров, которые также идеально подходят для развертывания на любом устройстве.

Наш предпоследний ввод — это текст.

В тексте доступны два типа моделей; классификатор текста и средство тегирования слов.

Классификация текста может использоваться для обозначения предложений, абзацев или даже целых статей на основе их содержания.

Вы можете обучить их для пользовательских задач идентификации тем или категоризации.

В Create ML есть множество различных алгоритмов, которые вы можете попробовать, и даже новый вариант обучения передачи в этом году.

В Word Tagger немного больше нюансов.

Идеально подходит для маркировки токенов или интересующих слов в тексте.

Примерами этого общего назначения являются такие вещи, как маркировка различных частей речи или распознавание именованных объектов, хотя вы можете настроить свои собственные, чтобы делать такие вещи, как маркировка сыров.

С помощью Cheese Tagger вы можете быть уверены в том, что в любом описании сыра вы сможете определить различные вкусовые нотки.

Наш последний домен является самым общим из всех пяти; Табличные данные.

И в этом у нас есть три типа моделей; Табличный классификатор, Табличный Регрессор и Рекомендатель.

Классификаторы предназначены для категоризации образцов на основе их представляющих интерес характеристик.

Возможности могут быть различных типов, например целые числа, числа с двойной точностью, строки, при условии, что ваша цель — дискретное значение.

Они позволяют вам определять, комфортно ли сиденье или нет, в зависимости от роста и веса конкретного человека, а также конкретных свойств сиденья, таких как количество места для ног.

Уникальность табличного классификатора заключается в том, что он извлекает за вас базовый алгоритм. И определяет несколько лучших классификаторов для ваших данных.

Если вместо этого вам нужна модель, которая предсказывает числовое значение, такое как рейтинг или балл, вы можете вместо этого использовать табличный регрессор.

Эта модель количественно оценивает образцы на основе их определяющих характеристик. Итак, вы можете научить оценивать стоимость дома в зависимости от его местоположения и количества спален, ванных комнат и парковочных мест.

Подобно классификатору, регрессор также автоматически определяет лучший из множества регрессоров для ваших данных.

Тем не менее, у вас по-прежнему есть гибкость, чтобы выбрать конкретное усиленное дерево или дерево решений, случайный лес или линейный регрессор, если хотите.

И наша последняя модель — это рекомендатель, который позволяет вам рекомендовать контент на основе поведения пользователя.

Рекомендателя можно обучить взаимодействию элементов пользователя с рейтингом или без него. И его можно развернуть на устройстве, избавляя вас от хлопот по настройке сервера.

Как мы уже видели, Create ML имеет отличные функции, которые помогут вам настроить эксперименты с машинным обучением, использовать встроенную поддержку для визуализации данных, показателей и производительности.

Модели машинного обучения, которые вы обучаете, можно легко сохранить и поделиться ими с членами вашей команды.

Конечно, все это позволяет использовать мощность и эффективность обучения на вашем Mac.

Эта новая среда дополняет другие доступные вам способы создания моделей машинного обучения, такие как Swift Playgrounds, Swift Scripts или Swift Frepple, Xcode Playground.

Но позволяет сделать это, не написав ни единой строчки кода.

Мы считаем, что благодаря этому машинное обучение станет доступно каждому.

Подводя итог, в Create ML в этом году у вас есть новые модели, девять шаблонов и совершенно новый рабочий процесс.

.

Что нового в Core ML, часть 1 — WWDC 2018 — видео

Скачать

Доброе утро.

Добро пожаловать. Я Майкл, и эта сессия посвящена тому, что нового в Core ML.

Представленное год назад Core ML призвано максимально упростить интеграцию моделей машинного обучения в ваше приложение.

Приятно было видеть принятие за последний год.

Мы надеемся, что все вы задумались о том, какие замечательные новые возможности вы могли бы включить, если бы ваше приложение могло выполнять такие функции, как понимание содержимого изображений или, возможно, анализ текста.

Что бы вы сделали, если бы ваше приложение могло рассуждать о звуке или музыке, или интерпретировать действия ваших пользователей на основе их активности движения, или даже преобразовывать или генерировать для них новый контент? Все это и многое, многое другое легко достижимо.

И это потому, что этот тип функциональности может быть закодирован в модели Core ML.

Теперь, если мы заглянем внутрь одного из них, мы можем найти нейронную сеть, ансамбль деревьев или некоторую другую модельную архитектуру.

У них могут быть миллионы параметров, значения которых получены из больших объемов данных.

Но вы могли бы сосредоточиться на одном файле.

Вы можете сосредоточиться на предоставляемых им функциональных возможностях и возможностях, а не на деталях реализации.

Добавить модель Core ML в ваше приложение просто: нужно добавить этот файл в проект Xcode.

Xcode даст вам простое представление, опишет, что он делает, с точки зрения требуемых входных данных и предоставляемых выходных данных.

Xcode сделает еще один шаг вперед и сгенерирует для вас интерфейс, так что взаимодействие с этой моделью — это всего лишь несколько строк кода, одна для загрузки модели, одна для прогнозирования, а иногда и для извлечения конкретного вывод, который вас интересует.

Обратите внимание, что в некоторых случаях вам даже не нужно писать обратно код, потому что Core ML интегрируется с некоторыми из наших высокоуровневых API и позволяет настраивать их поведение, если вы дадите им модель Core ML.

Итак, в Vision это делается через объект запроса VNCoreML.

А в новой среде естественного языка вы можете создать экземпляр MLModel из модели CoreML.

Итак, это в двух словах о Core ML.

Но мы здесь, чтобы поговорить о том, что нового.

Мы учли все отличные отзывы, полученные от вас за последний год, и сосредоточились на некоторых ключевых улучшениях CoreML 2.

И мы поговорим об этом в двух сессиях.

На первом сеансе, в котором вы все сидите прямо сейчас, мы поговорим о том, что нового с точки зрения вашего приложения. Во втором сеансе, который начинается сразу после этого в 10 часов утра после небольшого перерыва, мы поговорим об инструментах и ​​о том, как вы можете обновлять и преобразовывать модели, чтобы воспользоваться новыми функциями Core ML 2.

Когда дело доходит до вашего приложения, мы собираемся сосредоточиться на трех ключевых областях.

Во-первых, вы можете уменьшить размер и количество моделей с помощью вашего приложения, сохранив при этом ту же функциональность.

Затем мы рассмотрим, как можно повысить производительность одной модели.

А затем мы сделаем вывод о том, как использование Core ML позволит вам идти в ногу с современной и быстро развивающейся областью машинного обучения.

Итак, для начала поговорим о размере модели.Я передам это Франческо.

Спасибо, Майкл.

Здравствуйте. Любые способы уменьшить размер вашего приложения Core ML очень важны.

Меня зовут Франческо, и я собираюсь представить квантование и гибкие формы, две новые функции в Core ML 2, которые могут помочь уменьшить размер вашего приложения. Итак, Core ML, зачем вам изучать модели и устройства. Это дает вашему приложению четыре ключевых преимущества по сравнению с их запуском в облаке.

Прежде всего, полностью соблюдается конфиденциальность пользователей.На устройстве есть много моделей машинного обучения.

Мы гарантируем, что данные никогда не покидают устройство пользователя.

Во-вторых, это может помочь вам достичь производительности в реальном времени.

И для кремний, и для устройств суперэффективны для рабочих нагрузок машинного обучения.

Кроме того, вам не нужно обслуживать и оплачивать Интернет-серверы.

И вывод Core ML доступен в любом месте в любое время, несмотря на естественные проблемы с подключением.

Все эти огромные преимущества связаны с тем, что теперь вам нужно хранить модели машинного обучения на устройстве.

А если модели машинного обучения велики, вас может беспокоить размер вашего приложения.

Например, у вас есть карта, и она полна интересных функций.

И ваши пользователи очень этому рады.

И теперь вы хотите воспользоваться новыми возможностями, предлагаемыми машинным обучением на устройстве, и хотите добавить новые удивительные возможности в свое приложение. Итак, что вы делаете, вы обучаете несколько моделей Core ML и добавляете их в свое приложение.

Это означает, что ваше приложение стало еще круче, а пользователи стали еще счастливее.

Но некоторые из них могут заметить, что ваше приложение немного увеличилось в размере.

Нередко можно увидеть, как приложения вырастают до десятков или сотен мегабайт после добавления к ним возможностей машинного обучения.

По мере того, как вы продолжаете добавлять в приложение все больше и больше функций, размер вашего приложения может просто выйти из-под контроля.

Итак, это первое, что вы можете с этим сделать.И если эти модели машинного обучения поддерживают другие функции вашего приложения, вы можете оставить их вне своего первоначального пакета. А затем, когда пользователь использует другие функции, вы можете загрузить их по запросу, скомпилировать на устройстве.

Итак, в данном случае этот пользователь сначала доволен, потому что размер установки не изменился.

Но поскольку пользователь загружает и использует все текущие функции Core ML в вашем приложении, в конце концов, размер — вашего приложения по-прежнему велик.

Так не лучше ли было бы вместо этого решить эту проблему, уменьшив размер самих моделей? Это даст нам меньший пакет в случае, если мы отправляем модели внутри приложения, более быстрые и меньшие загрузки, если вместо доставки моделей в приложение мы загружаем их. И в любом случае ваше приложение получит меньше памяти.

Использование меньшего объема памяти лучше для производительности вашего приложения и отлично подходит для системы в целом.

Итак, давайте посмотрим, как мы можем разложить размер приложения Core ML на факторы, чтобы лучше решить эту проблему.

Во-первых, это количество моделей. Это зависит от того, сколько функций машинного обучения имеет ваше приложение.

Тогда есть количество весов.

Количество весов зависит от архитектуры, которую вы выбрали для решения вашей задачи машинного обучения.

Как упоминал Майкл, число веса — веса — это место, в котором модель машинного обучения хранит информацию, которую она изучила во время обучения.

Так оно и есть — если он был обучен выполнять сложную задачу, нередко можно увидеть модель, требующую десятков миллионов весов.

И, наконец, размер веса. Как мы сохраняем эти параметры, которые мы изучаем во время тренировки? Давайте сначала сосредоточимся на этом факторе.

Для нейронных сетей у нас есть несколько вариантов представления и хранения весов.

И первый, действительно, Core ML в iOS 11.

Нейронные сети хранились с использованием 32-битных весов с плавающей запятой.

В iOS 11.2 мы услышали ваши отзывы и представили вес с плавающей запятой половинной точности.

Это дает вашему приложению половину памяти, необходимой для той же точности.

Но в этом году мы хотели сделать несколько шагов вперед и вводим квантованные веса.

С квантованными весами мы больше не ограничены использованием значений Float 32 или Float 16.

Но нейронные сети можно кодировать с использованием 8 бит, 4 бит, любых битов вплоть до 1 бита. Итак, давайте теперь посмотрим, что такое квантование.

Здесь мы представляем подмножество весов наших нейронных сетей.

Как мы видим, эти веса могут принимать любые значения в непрерывном диапазоне.

Это означает, что теоретически один вес может принимать бесконечное количество возможных значений.

Итак, на практике в нейронных сетях мы храним веса, используя числа с плавающей запятой 32 — числа с плавающей запятой 32.

Это означает, что этот вес может принимать миллиарды значений, чтобы лучше представить их непрерывный характер.

Но оказалось, что нейронные сети также работают с весами меньшей точности.

Квантование — это процесс, который требуется для прерывания цепочки значений и ограничения их для принятия очень маленького и дискретного подмножества возможных значений.

Например, здесь квантование превратило этот непрерывный спектр весов только в 256 возможных значений.

Итак, перед квантованием веса будут принимать любые возможные значения.

После квантования у них есть только 256 вариантов.

Теперь, поскольку его вес можно взять из этого небольшого набора, Core ML теперь требуется только 8 бит сохраненной информации о весе.

Но здесь нас ничто не остановит.

Можем пойти дальше. И, например, мы можем ограничить сеть принимать вместо одного из 56 различных значений, например, только 8.

И поскольку теперь у нас есть только 8 вариантов, Core ML потребуется 3-битные значения на вес для хранения. ваша модель.

Теперь есть некоторые подробности о том, как мы собираемся выбирать эти значения для представления весов.

Они могут быть равномерно распределены в этом диапазоне, и в этом случае у нас есть линейное квантование вместо квантования таблицы поиска, мы можем иметь эти значения, разбросанные в этом диапазоне произвольным образом.

Итак, давайте посмотрим на практике, как квантование может помочь нам уменьшить размер нашей модели. В этом примере вы сосредотачиваетесь на Resnet50, которая является распространенной архитектурой, используемой многими приложениями для множества различных задач.

Он включает 25 миллионов обученных параметров, а это означает, что вам нужно использовать 32-битные числа с плавающей запятой для его представления.

Тогда общий размер модели больше 100 мегабайт.

Если квантовать его до 8 бит, то архитектура не изменилась; у нас осталось 25 миллионов параметров.

Но сейчас мы используем только 1 байт для хранения одного веса, а это означает, что размер модели уменьшен в 4 раза.

Это всего лишь — сейчас для хранения этой модели требуется всего 26 мегабайт.

А можно пойти дальше.

Мы можем использовать то квантованное представление, которое использует только 4 бита на вес в этой модели, и в итоге получить модель еще меньшего размера.

И снова Core ML поддерживает все режимы квантования вплоть до 8 бит.

Теперь квантование — это мощный метод, позволяющий использовать существующую архитектуру и ее уменьшенную версию.

Но как получить квантованную модель? Если у вас есть нейронная сеть в формате Core ML, вы можете использовать Core ML Tools, чтобы получить ее квантованное представление. Таким образом, Core ML 2 должен выполнять квантование автоматически.

Или вы можете обучать квантованные модели.

Вы можете либо обучить квантованные — с ограничением квантования с нуля, либо переобучить существующие модели с ограничениями квантования.

После того, как вы получили квантованную модель с помощью инструментов обучения, вы можете преобразовать ее в Core ML как обычно.

И в приложении ничего не изменится в том, как вы используете модель.

Внутри модели числа будут храниться с разной точностью, но интерфейс для использования модели вообще не изменится.

Однако мы всегда должны учитывать, что квантованные модели имеют более низкую точность аппроксимации исходных эталонных моделей с плавающей запятой.

А это означает, что квантованные модели имеют компромисс между точностью и размером модели.

Этот компромисс зависит от модели и варианта использования.К тому же это очень активная область исследований.

Поэтому всегда рекомендуется проверять точность квантованной модели и сравнивать ее с указанной версией с плавающей запятой для получения соответствующих данных и показателей формы, которые действительны для вашего приложения и варианта использования.

Теперь давайте посмотрим на демонстрацию того, как мы можем использовать квантованные модели, чтобы уменьшить размер приложения.

Я хотел бы показать вам приложение для переноса стилей.

При передаче стилей нейронная сеть была обучена визуализировать пользовательские изображения с использованием стилей, которые были изучены при просмотре картин или других изображений.

Итак, позвольте мне загрузить мое приложение. Как мы видим, я поставляю это приложение с четырьмя стилями; Город, стекло, масла и волны.

Затем я могу выбрать изображения из фото-библиотеки пользователей и затем обработать их, смешивая их в разных стилях, прямо на устройстве.

Итак, это исходное изображение, и я собираюсь визуализировать стиль города, стекло, масло и волны.

Давайте посмотрим, как это приложение было создано в Xcode.

Это приложение использует Core ML и Vision API для выполнения этой стилизации.

И, как мы видим, у нас есть четыре модели Core ML, объединенные в Xcode; City, Glass, Oils и Waves — те же самые, что мы видим в приложении. И мы видим — можем осмотреть эту модель.

Они рассматриваются как квантованные модели, поэтому каждая из этих моделей занимает 6,7 мегабайта этого пространства на диске.

Мы видим, что модели берут входное изображение с определенным разрешением и создают изображение, называемое стилизованным, с таким же разрешением.

Теперь мы хотим исследовать, сколько места для хранения и памяти мы можем использовать — мы можем сэкономить, переключившись на квантованные модели.Итак, я поигрался с Core ML Tools и получил представление квантователя для этих моделей.

И чтобы узнать о том, как получить эти модели, перейдите к Части 2, в которой подробно рассматривается квантование с помощью Core ML Tools.

Итак, я хочу сначала сосредоточиться на стиле Glass и посмотреть, как разные версии квантования работают для этих стилей.

Итак, все, что мне нужно сделать, это перетащить эти новые модели в проект Xcode и повторно запустить приложение. А потом посмотрим, как ведут себя эти модели.

Сначала мы видим, что размер сильно уменьшился. Например, 8-битная версия уже с 6 или 7 мегабайт снизилась до 1,7.

В 4-битном режиме мы можем сэкономить еще больше, и теперь модель меньше 1 мегабайта.

В 3-битном он — это еще меньше, 49 килобайт. И так далее.

А теперь вернемся в приложение.

Давайте сделаем это же изображение для справки и применим стиль Стекло к исходной версии.

По-прежнему выглядит как прежде.

Теперь можно сравнить с 8-битной версией.

И видно, что ничего не изменилось.

Это потому, что 8-битные методы квантования очень надежны.

Мы также можем рискнуть и попробовать 4-битную версию этой модели.

Вау. Результаты по-прежнему отличные.

А теперь попробуем 3-х битную версию.

Видим, что есть — видим первое изменение цвета. Так что, вероятно, будет хорошо, если мы пойдем и посоветуемся с дизайнерами, приемлем ли этот эффект.

И теперь, когда мы видим 2-битную версию, это не совсем то, что мы искали. Может, приберем для хоррор-приложения, но я не собираюсь показывать это дизайнеру.

Вернемся к 4-битной версии и скроем эту.

Это было просто напоминанием о том, что квантованные модели являются приближением исходных моделей.

Так что всегда рекомендуется проверять их и сравнивать с оригинальными версиями.

Теперь для каждой модели и техники квантования всегда есть момент, в котором вещи начинают не совпадать.Теперь мы — после некоторого обсуждения с дизайнером и обширной оценки многих изображений, мы решили выпустить 4-битную версию этой модели, которая имеет наименьший размер для наилучшего качества.

Итак, давайте удалим все версии моделей с плавающей запятой, которые занимали много места в нашем приложении, и заменим их 4-битной версией.

А теперь запустим приложение в последний раз.

ОК. Давайте снова выберем то же изображение и покажем все стили. Это был Город, Стекло, Масла и Большая Волна.

Итак, в этой демонстрации мы увидели, как начали с четырех моделей, и они были огромными, в 32-битном формате — или общий размер приложения составлял 27 мегабайт.

Затем мы оценили качество и перешли на 4-битные модели, и общий размер нашего приложения уменьшился до 3,4 мегабайта. Теперь — это нам ничего не стоит с точки зрения качества, потому что все эти версии — эти квантованные версии выглядят одинаково, и качество по-прежнему потрясающее.

Мы показали, как квантование может помочь нам уменьшить размер приложения за счет уменьшения размера веса на очень микроскопическом уровне.Теперь давайте посмотрим, как можно уменьшить количество моделей, необходимых вашему приложению.

В самом простом случае, если ваше приложение имеет три функции машинного обучения, вам понадобятся три разные модели машинного обучения.

Но в некоторых случаях одна и та же модель может поддерживать две разные функции.

Например, вы можете обучить многозадачную модель. А многозадачные модели были обучены выполнять несколько задач одновременно.

Есть пример переноса стилей, сеанс Turi Create о многозадачных моделях.

Или, в некоторых случаях, вы можете использовать еще одну новую функцию в Core ML под названием «Гибкие формы и размеры».

Вернемся к нашей демонстрации Style Transfer.

В Xcode мы увидели, что размер входного и выходного изображений был закодирован как часть определения модели.

Но что, если мы хотим запустить один и тот же стиль при разном разрешении изображения? Что, если мы хотим запустить одну и ту же сеть с изображениями разных размеров? Например, пользователь может захотеть увидеть передачу стиля высокой четкости.

Итак, они используют — они дают нам изображение высокой четкости.

Теперь, если бы я был моделью Core ML, все, что для этого требовалось, — это более низкое разрешение в качестве входных данных, все, что мы могли сделать, поскольку разработчики — это размер — или уменьшить размер изображения, обработать его, а затем снова масштабировать.

Это не особо удивит пользователя. Даже в прошлом мы могли повторно отправить эту модель с помощью Corel ML Tools и заставить ее принимать любое разрешение, в частности, изображение с более высоким разрешением.

Таким образом, даже в прошлом мы могли использовать эту функцию и напрямую передавать изображение с высоким разрешением в модель Corel ML, получая результат высокой четкости.Это потому, что мы хотели добавить более мелкие детали в стилизацию и более тонкие штрихи, которые удивительны при увеличении масштаба, потому что они — они добавляют много работы в окончательное изображение. Раньше мы могли это сделать, но мы могли сделать это, продублировав модель и создав две разные версии: одну для стандартного разрешения и одну для высокого разрешения.

И это, конечно же, означает, что наше приложение в два раза больше размера — не считая того факта, что сеть была обучена поддерживать любое разрешение.

Больше нет.

Мы представляем гибкие формы.

А с гибкими формами у вас есть — если у вас есть — вы можете иметь единую модель для обработки большего количества разрешений и многих других разрешений.

Итак, теперь в Xcode — — в Xcode вы увидите, что это — входные данные все еще являются изображением, но размер полного разрешения, модель также принимает гибкие разрешения. В этом простом примере SD и HD. Это означает, что теперь вам нужно отправить одну модель.Вам не обязательно иметь избыточный код.

А если вам нужно переключиться между стандартным и высоким разрешением, вы можете сделать это намного быстрее, потому что нам не нужно перезагружать модель с нуля; нам просто нужно изменить его размер.

У вас есть две возможности указать гибкость модели.

Вы можете определить диапазон его размеров, чтобы вы могли определить минимальную ширину и высоту и максимальную ширину и высоту.

И затем при выводе выберите любое промежуточное значение.

Но есть и другой способ. Вы можете перечислить все формы, которые собираетесь использовать.

Например, все разные соотношения сторон, все разные разрешения, и это лучше для производительности. Core ML знает больше о вашем варианте использования раньше, поэтому может — у него есть возможности для выполнения дополнительных оптимизаций.

И это также дает вашему приложению меньшую поверхность для тестирования.

Какие модели гибкие? Какие модели можно обучить для поддержки нескольких разрешений? Полностью сверточные нейронные сети, обычно используемые для задач обработки MS, таких как передача стилей, улучшение изображения, суперразрешение и т. Д., А также некоторые элементы архитектуры.

Core ML Tools может проверить, есть ли у модели такая возможность.

Итак, у нас все еще есть количество моделей, которые Core ML использует в гибких размерах, а размер весов можно уменьшить путем квантования.

А как насчет количества весов? Core ML, учитывая тот факт, что он поддерживает множество, множество различных архитектур на любой платформе, всегда помогал вам выбрать правильный — модель правильного размера для вашей задачи машинного обучения.

Итак, Core ML может помочь вам решить проблему размера вашего приложения, используя все эти три фактора.

В любом случае вывод будет высокопроизводительным. А чтобы представить новые функции в производительности и настройке, поприветствуем Билла Марча.

Спасибо.

Спасибо.

Один из фундаментальных принципов проектирования Core ML с самого начала заключался в том, что оно должно обеспечивать максимально возможную производительность вашего приложения.

И в соответствии с этой целью я хотел бы выделить новую функцию Core ML, которая поможет гарантировать, что ваше приложение будет сиять на любом устройстве Apple.

Давайте посмотрим на пример передачи стиля, который показал нам Франческо.

С точки зрения вашего приложения, оно берет изображение ввода и просто возвращает стилизованное изображение.

И есть два ключевых компонента, которые делают это: во-первых, файл MLModel, в котором хранятся конкретные параметры, необходимые для применения этого стиля; и во-вторых, механизм логического вывода, который принимает модель ML и изображение и выполняет вычисления, необходимые для получения результата.

Итак, давайте заглянем под капот этого механизма вывода и посмотрим, как мы используем технологию Apple для эффективного выполнения передачи этого стиля.

Эта модель является примером нейронной сети, которая состоит из серии математических операций, называемых слоями.

Каждый слой применяет к изображению некоторые преобразования, в результате чего получается стилизованный результат.

Модель хранит веса для каждого слоя, которые определяют конкретное преобразование и стиль, который мы собираемся применить.

Механизм логического вывода нейронной сети Core ML имеет высокооптимизированные реализации для каждого из этих уровней.

На GPU мы используем шейдеры MTL. На CPU мы можем использовать Accelerate, профессиональный расчет.

И мы можем динамически отправлять разные части вычислений разным частям оборудования в зависимости от модели, состояния устройства и других факторов.

Мы также можем найти возможности для объединения слоев в сети, что приведет к меньшему количеству необходимых вычислений.

Здесь мы можем оптимизировать, потому что знаем, что происходит. Мы знаем детали модели; они содержатся в файле MLModel, который вы нам предоставили.

И мы знаем детали механизма вывода и устройства, потому что мы их разработали. Мы можем позаботиться обо всех этих оптимизациях за вас, а вы можете сосредоточиться на обеспечении наилучшего взаимодействия с пользователем в своем приложении.

А как насчет вашей рабочей нагрузки? Что, в частности, если вам нужно сделать несколько прогнозов? Если Core ML не знает об этом, то Core ML не сможет оптимизировать для этого.

Итак, в прошлом, если у вас была такая рабочая нагрузка, вам нужно было сделать что-то вроде этого: простой цикл for, обернутый вокруг вызова существующего API прогнозирования Core ML. Таким образом, вы перебираете некоторый массив входных данных и производите массив выходных данных.

Давайте подробнее рассмотрим, что происходит под капотом, когда это — когда мы это делаем.

Для каждого изображения нам потребуется выполнить некоторую предварительную обработку.

Во всяком случае, нам нужно отправить данные на GPU.

Как только мы это сделаем, мы сможем произвести расчет и создать выходное изображение. Но затем есть этап постобработки, на котором нам нужно получить данные из графического процессора и вернуть их в ваше приложение.

Ключом к улучшению этого изображения является устранение пузырей в конвейере графического процессора.

Это приводит к повышению производительности по двум основным причинам. Во-первых, поскольку нет времени, когда графический процессор простаивает, общее время вычислений сокращается.

Во-вторых, поскольку графический процессор продолжает работать непрерывно, он может работать в состоянии с более высокой производительностью и сокращать время, необходимое для вычисления каждого конкретного вывода.

Но основная привлекательность Core ML состоит в том, что вам вообще не нужно беспокоиться о подобных деталях.

Фактически, для вашего приложения все, что вас действительно беспокоит для пользователей, — это переход от долгого времени к получению результатов до короткого времени.

Итак, в этом году мы представляем новый пакетный API, который позволит вам делать именно это.

Там, где раньше вам приходилось перебирать входные данные и вызывать отдельные прогнозы, новый API очень прост.

Однострочные прогнозы, он потребляет вход — массив входов и производит массив выходов.

Core ML позаботится об остальном.

Итак, давайте посмотрим на это в действии.

Итак, в соответствии с нашим примером передачи стиля, давайте рассмотрим случай, когда мы хотели применить стиль ко всей нашей библиотеке фотографий.

Итак, у меня есть простое приложение, которое сделает именно это. Я собираюсь применить стиль к 200 изображениям. Слева, как и слева, есть реализация, использующая прошлогодний API в цикле for.

А справа у нас новый пакетный API.

Итак, приступим.

Мы выезжаем.

И мы видим, что новое уже сделано. Подождем минутку прошлогодней технологии, и поехали.

В этом примере мы видим заметное улучшение с новым пакетным API.

В целом улучшение, которое вы увидите в своем приложении, зависит от модели, устройства и рабочей нагрузки.

Но если вам нужно вызвать большое количество прогнозов, используйте новый API и предоставьте Core ML все возможности для ускорения вычислений.

Конечно, самое высокопроизводительное приложение в мире не вызывает особого впечатления, если оно не дает пользователям того опыта, которого вы хотите.

Мы хотим быть уверены, что независимо от того, каким будет этот опыт или каким он может быть в будущем, Core ML будет столь же производительным и простым в использовании, как и прежде.

Но область машинного обучения быстро растет.

Как мы продолжим? И насколько быстро? Позвольте мне рассказать вам об этом немного из личной истории.

Давайте взглянем на обманчиво простой вопрос, на который мы можем ответить с помощью машинного обучения.

Учитывая изображение, я хочу знать: есть ли на нем лошади? Думаю, я услышал пару смешков. Может быть, это похоже на глупую задачу. Кстати, маленьким детям это нравится. Но — так, давным-давно, когда я впервые поступал в аспирантуру, я думал об этой проблеме и впервые узнал о машинном обучении, мои идеи в верхней части сводились к примерно следующему: я не знаю — кажется трудным.

У меня нет для вас ничего хорошего.

Так прошло несколько лет. Я становлюсь старше, надеюсь, немного поумнею. Но, безусловно, эта область движется очень, очень быстро, потому что с использованием глубоких нейронных сетей появилось много интересных новых результатов.

И тогда мой взгляд на эту проблему изменился. И вдруг, вау, это передовое исследование действительно может дать ответы на подобные вопросы, и компьютеры могут догнать маленьких детей и технологии распознавания лошадей.Какое захватывающее развитие.

Так прошло еще несколько лет. Сейчас я работаю в Apple, и мой взгляд на эту проблему снова изменился. Теперь просто возьмите Create ML. Интерфейс прекрасный. У вас будет классификатор лошадей всего за несколько минут.

Итак, вы знаете, если вы эксперт по машинному обучению, возможно, вы смотрите на это и думаете: «О, этот парень не знает, о чем говорит. Знаете, в 2007 году я знал, как Решите эту проблему.В 2012 году я решал ее сто раз.»Не моя точка зрения.

Если вы из тех, кто заботится о долговечном высококачественном программном обеспечении, это должно заставить вас нервничать, потому что за 11 лет мы увидели, как полностью изменилась картина этой проблемы.

Итак, давайте возьмем взглянем на еще несколько функций в Core ML, которые помогут вам расслабиться.

Для этого давайте снова откроем капот и взглянем на одну из этих новых моделей системы поиска лошадей, которая, опять же, является нейронной сеть

Как мы показали ранее, нейронная сеть состоит из ряда высоко оптимизированных слоев.Это серия уровней, и у нас есть оптимизированные реализации для каждого из них в нашем механизме вывода.

Наш список поддерживаемых операций обширен и постоянно растет, чтобы не отставать от новых разработок в этой области.

Но что, если есть уровень, который просто не поддерживается в Core ML? Раньше нужно было либо ждать, либо нужна была другая модель. Но что, если этот слой является ключевым для поиска лошадей? Это прорыв, которого ждала ваша лошадь.

Можете ли вы позволить себе подождать? Учитывая скорость машинного обучения, это могло стать серьезным препятствием.

Итак, мы ввели собственные слои для моделей нейронных сетей.

Теперь, если уровень нейронной сети отсутствует, вы можете предоставить реализацию с — будет бесшовно взаимодействовать с остальной частью модели Core ML.

Внутри модели на настраиваемом уровне хранится имя реализующего класса — в данном случае AAPLCustomHorseLayer.

Класс реализации выполняет роль отсутствующей реализации в механизме вывода.

Подобно тому, как уровень встроен в Core ML, представленная здесь реализация должна быть общей и применимой к любому экземпляру нового уровня.

Его просто нужно включить в ваше приложение во время выполнения.

Затем параметры для этого конкретного уровня инкапсулируются в модель ML с остальной информацией о модели.

Создать собственный слой просто.

Выставляем протокол MLCustomLayer.

Вы просто предоставляете методы для инициализации уровня на основе данных, хранящихся в модели машинного обучения.

Вам необходимо предоставить метод, который сообщает нам, сколько места нужно выделить для выходных данных уровня, а затем метод, выполняющий вычисления.

Plus, вы можете добавить эту гибкость, не жертвуя производительностью вашей модели в целом.

Протокол включает в себя дополнительный метод, который позволяет вам предоставить нам реализацию шейдера MTL вашей модели — слоя, извините.

Если вы дадите нам это, то это можно будет закодировать в том же командном буфере, что и остальные вычисления Core ML.Таким образом, нет дополнительных накладных расходов из-за дополнительных кодировок или многократных обращений к графическому процессору и обратно.

Если вы этого не предоставите, мы просто оценим уровень ЦП без какой-либо другой работы с вашей стороны.

Итак, независимо от того, как быстро могут произойти улучшения в моделях нейронных сетей, у вас есть способ не отставать от Core ML.

Но есть ограничения.

Пользовательские слои работают только для моделей нейронных сетей, и они принимают только входные и выходные данные, которые являются ML MultiArrays.Это естественный способ взаимодействия с нейронными сетями.

Но область машинного обучения вряд ли ограничивается только продвижением в этой области.

На самом деле, когда я впервые узнал о распознавании изображений, почти никто не говорил о нейронных сетях как о решении этой проблемы.

И сегодня вы можете видеть, что это абсолютный уровень техники. И нетрудно представить приложения с поддержкой машинного обучения, в которых пользовательские слои просто не поместятся.

Например, приложение для машинного обучения может использовать нейронную сеть для встраивания изображения в некоторое пространство подобия, а затем искать похожие изображения с помощью метода ближайшего соседа или хеширования с учетом местоположения или даже какого-либо другого подхода.

Модель может комбинировать аудиоданные и данные о движении, чтобы немного подбодрить того, кто не всегда закрывает кольца.

Или даже совершенно новый тип модели, о котором мы еще даже не догадывались, который дает новые возможности для ваших пользователей.

Во всех этих случаях было бы замечательно, если бы у нас была простота и портативность Core ML без необходимости жертвовать гибкостью, чтобы не отставать от поля.

Итак, мы представляем нестандартные модели.

Пользовательская модель Core ML позволяет инкапсулировать реализацию части вычислений, которая отсутствует внутри Core ML.

Как и в случае с пользовательскими слоями, модель хранит имя класса реализации.

Класс выполняет роль общего механизма вывода для этого типа модели.

Затем параметры сохраняются в модели ML, как и раньше.

Это позволяет обновлять модель как актив в вашем приложении без необходимости вводить код.

И реализовать нестандартную модель тоже просто.

Выставляем протокол, MLCustomModel. Вы предоставляете методы для инициализации на основе данных, хранящихся в модели машинного обучения. И вы предоставляете метод для вычисления прогноза на входе.

Существует дополнительный метод для предоставления пакетной реализации, если в этом конкретном типе модели есть возможности для оптимизации. А если нет, мы вызовем единственное предсказание в цикле for.

А использование настроенной модели в вашем приложении — это во многом тот же рабочий процесс, что и любая другая модель Core ML.

В Xcode модель с настраиваемыми компонентами будет иметь раздел зависимостей, в котором перечислены имена необходимых реализаций вместе с кратким описанием.

Просто включите их в свое приложение, и вы готовы к работе.

API прогнозирования не изменяется как для одиночных, так и для пакетных прогнозов.

Таким образом, пользовательские слои и пользовательские модели позволяют использовать мощь и простоту Core ML, не жертвуя гибкостью, необходимой для того, чтобы идти в ногу с быстро развивающейся областью машинного обучения.

Для новых слоев нейронной сети настраиваемые слои позволяют использовать многие оптимизации, уже присутствующие в механизме вывода нейронной сети в Core ML.

Пользовательские модели более гибкие по типам и функциям, но они требуют дополнительной работы по внедрению с вашей стороны.

Обе формы настройки позволяют инкапсулировать параметры модели в модели машинного обучения, что делает модель переносимой и упрощает код.

И мы смогли коснуться лишь некоторых замечательных новых функций Core ML 2.

Загрузите бета-версию, попробуйте сами.

Core ML содержит множество замечательных новых функций, позволяющих уменьшить размер вашего приложения, повысить производительность и обеспечить гибкость и совместимость с последними разработками в области машинного обучения.

Мы показали вам, как квантование может уменьшить размер модели, как новый пакетный API может обеспечить более эффективную обработку и как пользовательские слои и пользовательские модели могут помочь вам внедрить передовое машинное обучение в ваше приложение.

В сочетании с нашим новым замечательным инструментом для обучения моделей в Create ML, есть больше, чем когда-либо, способов добавить функции с поддержкой ML в ваше приложение и поддержать новые впечатления для ваших пользователей.

После небольшого перерыва мы вернемся прямо сюда, чтобы более подробно изучить некоторые из этих функций. В частности, мы покажем вам, как использовать наше программное обеспечение Core ML Tools, чтобы начать сокращать размеры моделей и настраивать пользовательский интерфейс с помощью Core ML уже сегодня. Спасибо.

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *