Délégué Core ML LiteRT

Le délégué LiteRT Core ML permet d'exécuter des modèles LiteRT sur Core ML framework, qui accélère l'inférence de modèle sur les appareils iOS.

Versions et appareils iOS compatibles:

  • iOS 12 et versions ultérieures. Dans les anciennes versions d'iOS, le délégué Core ML passer automatiquement au processeur.
  • Par défaut, le délégué Core ML ne sera activé que sur les appareils dotés d'un SoC A12 et versions ultérieures (iPhone X et versions ultérieures) à utiliser Neural Engine afin d'accélérer l'inférence. Si vous souhaitez également utiliser le délégué Core ML sur les anciens appareils, consultez bonnes pratiques

Modèles compatibles

Le délégué Core ML est actuellement compatible avec les modèles à virgule flottante (FP32 et FP16).

Essayer le délégué Core ML sur votre propre modèle

Le délégué Core ML est déjà inclus dans la version nocturne de LiteRT CocoaPods Pour utiliser le délégué Core ML, modifiez votre pod LiteRT afin d'inclure sous-spéc CoreML dans votre Podfile.

target 'YourProjectName'
  pod 'TensorFlowLiteSwift/CoreML', '~> 2.4.0'  # Or TensorFlowLiteObjC/CoreML

OU

# Particularily useful when you also want to include 'Metal' subspec.
target 'YourProjectName'
  pod 'TensorFlowLiteSwift', '~> 2.4.0', :subspecs => ['CoreML']

Swift

    let coreMLDelegate = CoreMLDelegate()
    var interpreter: Interpreter

    // Core ML delegate will only be created for devices with Neural Engine
    if coreMLDelegate != nil {
      interpreter = try Interpreter(modelPath: modelPath,
                                    delegates: [coreMLDelegate!])
    } else {
      interpreter = try Interpreter(modelPath: modelPath)
    }

Objective-C

    // Import module when using CocoaPods with module support
    @import TFLTensorFlowLite;

    // Or import following headers manually
    # import "tensorflow/lite/objc/apis/TFLCoreMLDelegate.h"
    # import "tensorflow/lite/objc/apis/TFLTensorFlowLite.h"

    // Initialize Core ML delegate
    TFLCoreMLDelegate* coreMLDelegate = [[TFLCoreMLDelegate alloc] init];

    // Initialize interpreter with model path and Core ML delegate
    TFLInterpreterOptions* options = [[TFLInterpreterOptions alloc] init];
    NSError* error = nil;
    TFLInterpreter* interpreter = [[TFLInterpreter alloc]
                                    initWithModelPath:modelPath
                                              options:options
                                            delegates:@[ coreMLDelegate ]
                                                error:&error];
    if (error != nil) { /* Error handling... */ }

    if (![interpreter allocateTensorsWithError:&error]) { /* Error handling... */ }
    if (error != nil) { /* Error handling... */ }

    // Run inference ...

C (jusqu'à la version 2.3.0)

    #include "tensorflow/lite/delegates/coreml/coreml_delegate.h"

    // Initialize interpreter with model
    TfLiteModel* model = TfLiteModelCreateFromFile(model_path);

    // Initialize interpreter with Core ML delegate
    TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();
    TfLiteDelegate* delegate = TfLiteCoreMlDelegateCreate(NULL);  // default config
    TfLiteInterpreterOptionsAddDelegate(options, delegate);
    TfLiteInterpreterOptionsDelete(options);

    TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);

    TfLiteInterpreterAllocateTensors(interpreter);

    // Run inference ...

    /* ... */

    // Dispose resources when it is no longer used.
    // Add following code to the section where you dispose of the delegate
    // (e.g. `dealloc` of class).

    TfLiteInterpreterDelete(interpreter);
    TfLiteCoreMlDelegateDelete(delegate);
    TfLiteModelDelete(model);

Bonnes pratiques

Utiliser le délégué Core ML sur des appareils sans moteur neuronal

Par défaut, le délégué Core ML n'est créé que si l'appareil dispose de Engine, et renvoie null si le délégué n'est pas créé. Si vous souhaitez exécuter le délégué Core ML sur d'autres environnements (simulateur, par exemple), puis transmettre .all comme option lors de la création d'un délégué dans Swift. Avec C++ (et Objective-C), vous pouvez transmettre TfLiteCoreMlDelegateAllDevices. L'exemple suivant montre comment procéder:

Swift

    var options = CoreMLDelegate.Options()
    options.enabledDevices = .all
    let coreMLDelegate = CoreMLDelegate(options: options)!
    let interpreter = try Interpreter(modelPath: modelPath,
                                      delegates: [coreMLDelegate])

Objective-C

    TFLCoreMLDelegateOptions* coreMLOptions = [[TFLCoreMLDelegateOptions alloc] init];
    coreMLOptions.enabledDevices = TFLCoreMLDelegateEnabledDevicesAll;
    TFLCoreMLDelegate* coreMLDelegate = [[TFLCoreMLDelegate alloc]
                                          initWithOptions:coreMLOptions];

    // Initialize interpreter with delegate

C

    TfLiteCoreMlDelegateOptions options;
    options.enabled_devices = TfLiteCoreMlDelegateAllDevices;
    TfLiteDelegate* delegate = TfLiteCoreMlDelegateCreate(&options);
    // Initialize interpreter with delegate

Utilisation d'un délégué de métal(GPU) en remplacement.

Si le délégué Core ML n'est pas créé, vous pouvez toujours utiliser Metal délégué (Délégué) pour obtenir d'amélioration des performances. L'exemple suivant montre comment procéder:

Swift

    var delegate = CoreMLDelegate()
    if delegate == nil {
      delegate = MetalDelegate()  // Add Metal delegate options if necessary.
    }

    let interpreter = try Interpreter(modelPath: modelPath,
                                      delegates: [delegate!])

Objective-C

    TFLDelegate* delegate = [[TFLCoreMLDelegate alloc] init];
    if (!delegate) {
      // Add Metal delegate options if necessary
      delegate = [[TFLMetalDelegate alloc] init];
    }
    // Initialize interpreter with delegate

C

    TfLiteCoreMlDelegateOptions options = {};
    delegate = TfLiteCoreMlDelegateCreate(&options);
    if (delegate == NULL) {
      // Add Metal delegate options if necessary
      delegate = TFLGpuDelegateCreate(NULL);
    }
    // Initialize interpreter with delegate

La logique de création du délégué lit l'identifiant machine de l'appareil (par exemple, iPhone11,1) à pour déterminer la disponibilité de Neural Engine. Consultez le code pour en savoir plus. Vous pouvez aussi implémenter votre propre liste de blocage appareils utilisant d'autres bibliothèques telles que DeviceKit.

Utiliser une ancienne version de Core ML

Bien qu'iOS 13 soit compatible avec Core ML 3, le modèle peut mieux fonctionner lorsqu'il est avec la spécification de modèle Core ML 2. La version de conversion cible est définie par défaut sur la dernière version, mais vous pouvez modifier cela en définissant coreMLVersion (en Swift, coreml_version dans l'API C) dans l'option de délégation pour l'ancienne version.

Opérations compatibles

Les opérations suivantes sont compatibles avec le délégué Core ML.

  • Ajouts
    • Seules certaines formes peuvent être diffusées. Dans la mise en page de Tensor Core ML, les formes de Tensor suivantes peuvent être diffusées. [B, C, H, W], [B, C, 1, 1], [B, 1, H, W] et [B, 1, 1, 1].
  • MoyennePool2D
  • Concat <ph type="x-smartling-placeholder">
      </ph>
    • La concaténation doit être effectuée le long de l'axe des canaux.
  • Conv.2D <ph type="x-smartling-placeholder">
      </ph>
    • Les pondérations et les biais doivent être constants.
  • DepthwiseConv2D <ph type="x-smartling-placeholder">
      </ph>
    • Les pondérations et les biais doivent être constants.
  • Entièrement connecté (Dense ou InnerProduct) <ph type="x-smartling-placeholder">
      </ph>
    • Les pondérations et les biais (le cas échéant) doivent être constants.
    • Compatible uniquement avec les demandes à lot unique. Les dimensions d'entrée doivent être de 1, sauf la dernière dimension.
  • Hardswish
  • Logistique (ou sigmoïde)
  • Pool max. 2D
  • MirrorPad <ph type="x-smartling-placeholder">
      </ph>
    • Seule l'entrée 4D en mode REFLECT est compatible. La marge intérieure doit être et n'est autorisée que pour les dimensions H et L.
  • UL <ph type="x-smartling-placeholder">
      </ph>
    • Seules certaines formes peuvent être diffusées. Dans la mise en page de Tensor Core ML, les formes de Tensor suivantes peuvent être diffusées. [B, C, H, W], [B, C, 1, 1], [B, 1, H, W] et [B, 1, 1, 1].
  • Pad et PadV2 <ph type="x-smartling-placeholder">
      </ph>
    • Seule l'entrée 4D est compatible. La marge intérieure doit être constante et n'être pour les dimensions H et L.
  • Relu
  • ReluN1To1
  • Relu6
  • Remodeler <ph type="x-smartling-placeholder">
      </ph>
    • Uniquement disponible lorsque la version cible de Core ML est 2, et non compatible lorsque ciblant Core ML 3.
  • ResizeBilinear
  • SoftMax
  • Tanh
  • TransposeConv <ph type="x-smartling-placeholder">
      </ph>
    • Les pondérations doivent être constantes.

Commentaires

En cas de problème, veuillez créer un GitHub en fournissant tous les détails nécessaires à sa reproduction.

Questions fréquentes

  • CoreML permet-il d'utiliser le processeur de remplacement si un graphique contient des opérations ?
    • Oui
  • Le délégué CoreML fonctionne-t-il sur le simulateur iOS ?
    • Oui. La bibliothèque inclut des cibles x86 et x86_64 afin de pouvoir s'exécuter sur un simulateur, mais vous n'observerez pas d'amélioration des performances par rapport au CPU.
  • Le délégué LiteRT et CoreML est-il compatible avec macOS ?
    • LiteRT n'est testé que sur iOS, mais pas sur macOS.
  • Les opérations LiteRT personnalisées sont-elles prises en charge ?
    • Non, le délégué Core ML n'est pas compatible avec les opérations personnalisées et elles seront remplacées par CPU

API