Délégué Core ML pour TensorFlow Lite

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

Versions d'iOS et appareils compatibles:

• iOS 12 et versions ultérieures. Dans les anciennes versions d'iOS, le délégué Core ML revient automatiquement au processeur.
• Par défaut, le délégué Core ML n'est activé que sur les appareils dotés du SoC A12 ou version ultérieure (iPhone Xs et versions ultérieures) afin d'utiliser Neural Engine et d'accélérer l'inférence. Si vous souhaitez utiliser également le délégué Core ML sur les anciens appareils, veuillez consulter les bonnes pratiques.

Modèles compatibles

Le délégué Core ML est actuellement compatible avec 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 CocoaPods de TensorFlow Lite. Pour utiliser le délégué Core ML, modifiez votre pod TensorFlow Lite afin d'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']

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

    // 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 ...
  

    #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 du moteur neuronal et renvoie la valeur null dans le cas contraire. Si vous souhaitez exécuter le délégué Core ML dans d'autres environnements (par exemple, un simulateur), transmettez .all en tant qu'option lors de la création du délégué dans Swift. En C++ (et Objective-C), vous pouvez transmettre TfLiteCoreMlDelegateAllDevices. L'exemple suivant montre comment procéder:

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

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

    // Initialize interpreter with delegate
  

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

Utiliser le délégué Metal(GPU) en tant que solution de secours

Lorsque le délégué Core ML n'est pas créé, vous pouvez également utiliser le délégué métallisé pour obtenir des performances accrues. L'exemple suivant montre comment procéder:

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

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

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

    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'ID machine de l'appareil (par exemple, iPhone11,1) pour déterminer la disponibilité du moteur de neurones. Pour en savoir plus, consultez le code. Vous pouvez également implémenter votre propre ensemble d'appareils sur liste de blocage à l'aide d'autres bibliothèques telles que DeviceKit.

Utiliser l'ancienne version de Core ML

Bien qu'iOS 13 soit compatible avec Core ML 3, le modèle peut mieux fonctionner lorsqu'il est converti 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 sur une ancienne version.

Opérations compatibles

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

• Ajouter
  • Seules certaines formes peuvent être diffusées. Dans la mise en page du 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].
• MoyennePool2J
• Concat
  • La concaténation doit être effectuée le long de l'axe de la chaîne.
• Conv2D
  • Les pondérations et les biais doivent être constants.
• DepthwiseConv2D
  • Les pondérations et les biais doivent être constants.
• Connecté (également appelé "Dense" ou "InnerProduct")
  • Les pondérations et les biais (le cas échéant) doivent être constants.
  • Compatible uniquement avec les cas de lot unique. Les dimensions d'entrée doivent être égales à 1, à l'exception de la dernière.
• Harddswish
• Logistique (ou sigmoïde)
• MaxPool2D
• MirrorPad
  • Seule la saisie 4D en mode REFLECT est acceptée. La marge intérieure doit être constante et n'est autorisée que pour les dimensions H et W.
• MUL
  • Seules certaines formes peuvent être diffusées. Dans la mise en page du 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
  • Seule la saisie 4D est acceptée. La marge intérieure doit être constante et n'est autorisée que pour les dimensions H et W.
• ReLU
• ReluN1To1
• Relu6
• Remodeler
  • Disponible uniquement lorsque la version cible de Core ML est 2, et non compatible avec Core ML 3.
• ResizeBilinear
• SoftMax
• Tanh
• TransposeConv
  • Les pondérations doivent être constantes.

Commentaires

En cas de problème, veuillez créer un problème sur GitHub en indiquant tous les détails nécessaires à reproduire.

Questions fréquentes

• Core ML délègue-t-il la compatibilité du retour au processeur si un graphique contient des opérations non compatibles ?
  • 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 ne verrez pas d'amélioration des performances sur le processeur.
• Le délégué TensorFlow Lite et CoreML est-il compatible avec macOS ?
  • TensorFlow Lite n'est testé que sur iOS, mais pas sur macOS.
• Les opérations TF Lite personnalisées sont-elles compatibles ?
  • Non, le délégué CoreML n'est pas compatible avec les opérations personnalisées et utilise le processeur de secours.

API

• API Swift déléguée Core ML
• API C de délégué Core ML