Délégué Tensorflow Lite Core ML

Le délégué TensorFlow Lite Core ML permet d'exécuter des modèles TensorFlow Lite sur le framework Core ML , ce qui entraîne une inférence de modèle plus rapide sur les appareils iOS.

Versions et appareils iOS pris en charge :

  • iOS 12 et versions ultérieures. Dans les anciennes versions d'iOS, le délégué Core ML reviendra automatiquement au processeur.
  • Par défaut, le délégué Core ML ne sera activé que sur les appareils dotés du SoC A12 et versions ultérieures (iPhone Xs et versions ultérieures) pour utiliser Neural Engine pour une inférence plus rapide. Si vous souhaitez également utiliser le délégué Core ML sur les appareils plus anciens, veuillez consulter les meilleures pratiques.

Modèles pris en charge

Le délégué Core ML prend actuellement en charge les modèles flottants (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 TensorFlow Lite CocoaPods. Pour utiliser le délégué Core ML, modifiez votre pod TensorFlow Lite pour inclure la sous-spécification 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']

Rapide

    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)
    }
  

Objectif 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'à 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);
      

Les meilleures pratiques

Utilisation du délégué Core ML sur des appareils sans Neural Engine

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

Rapide

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

Objectif 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 du délégué Metal (GPU) comme solution de secours.

Lorsque le délégué Core ML n'est pas créé, vous pouvez toujours utiliser le délégué Metal pour obtenir des avantages en termes de performances. L'exemple suivant montre comment procéder :

Rapide

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

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

Objectif 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 de délégué lit l'identifiant de la machine de l'appareil (par exemple iPhone11,1) pour déterminer la disponibilité de son moteur neuronal. Voir le code pour plus de détails. Vous pouvez également implémenter votre propre ensemble de périphériques de liste noire à l'aide d'autres bibliothèques telles que DeviceKit .

Utilisation d'une ancienne version de Core ML

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

Opérations prises en charge

Les opérations suivantes sont prises en charge par le délégué Core ML.

  • Ajouter
    • Seules certaines formes sont diffusables. Dans la disposition du tenseur Core ML, les formes de tenseurs suivantes sont diffusables. [B, C, H, W] , [B, C, 1, 1] , [B, 1, H, W] , [B, 1, 1, 1] .
  • PiscineMoyenne2D
  • Concaténer
    • La concaténation doit être effectuée le long de l'axe du canal.
  • Conv2D
    • Les pondérations et les biais doivent être constants.
  • DepthwiseConv2D
    • Les pondérations et les biais doivent être constants.
  • Entièrement connecté (alias Dense ou InnerProduct)
    • Les pondérations et les biais (le cas échéant) doivent être constants.
    • Prend uniquement en charge le cas d'un seul lot. Les dimensions d'entrée doivent être 1, à l'exception de la dernière dimension.
  • Swish dur
  • Logistique (alias Sigmoïde)
  • MaxPool2D
  • MiroirPad
    • Seule l'entrée 4D avec le mode REFLECT est prise en charge. Le remplissage doit être constant et n'est autorisé que pour les dimensions H et L.
  • Mul
    • Seules certaines formes sont diffusables. Dans la disposition du tenseur Core ML, les formes de tenseurs suivantes sont diffusables. [B, C, H, W] , [B, C, 1, 1] , [B, 1, H, W] , [B, 1, 1, 1] .
  • Pad et PadV2
    • Seule l'entrée 4D est prise en charge. Le remplissage doit être constant et n'est autorisé que pour les dimensions H et L.
  • Rélu
  • ReluN1To1
  • Relu6
  • Remodeler
    • Uniquement pris en charge lorsque la version cible de Core ML est 2, non prise en charge lors du ciblage de Core ML 3.
  • RedimensionnerBilinéaire
  • SoftMax
  • Tanh
  • TransposeConv
    • Les poids doivent être constants.

Retour

Pour les problèmes, veuillez créer un problème GitHub avec tous les détails nécessaires à reproduire.

FAQ

  • Le délégué CoreML prend-il en charge le repli sur le processeur si un graphique contient des opérations non prises en charge ?
    • Oui
  • Le délégué CoreML fonctionne-t-il sur iOS Simulator ?
    • Oui. La bibliothèque comprend des cibles x86 et x86_64 afin qu'elle puisse s'exécuter sur un simulateur, mais vous ne verrez pas d'amélioration des performances par rapport au processeur.
  • TensorFlow Lite et les délégués CoreML prennent-ils en charge MacOS ?
    • TensorFlow Lite n'est testé que sur iOS mais pas sur MacOS.
  • Les opérations TF Lite personnalisées sont-elles prises en charge ?
    • Non, le délégué CoreML ne prend pas en charge les opérations personnalisées et elles recourront au processeur.

Apis