Delegat do Tensorflow Lite Core ML

Delegat TensorFlow Lite Core ML umożliwia uruchamianie modeli TensorFlow Lite w platformie Core ML, co przyspiesza wnioskowanie na podstawie modeli na urządzeniach z iOS.

Obsługiwane wersje systemu iOS i urządzenia:

  • iOS 12 i nowsze wersje. W starszych wersjach iOS delegat Core ML automatycznie przełącza się na procesor.
  • Domyślnie delegat Core ML będzie włączony tylko na urządzeniach z Układem SOC A12 i nowszymi (iPhone X i nowsze), aby umożliwić szybsze wnioskowanie z Neural Engine. Jeśli chcesz korzystać z przedstawiciela Core ML również na starszych urządzeniach, zapoznaj się ze sprawdzonymi metodami

Obsługiwane modele

Delegat do podstawowego ML obsługuje obecnie modele zmiennoprzecinkowe (FP32 i FP16).

Wypróbowywanie przedstawiciela Core ML we własnym modelu

Delegat Core ML jest już uwzględniony w conocnej wersji platformy TensorFlow Lite CocoaPods. Aby korzystać z delegata Core ML, zmień pod TensorFlow Lite, aby uwzględnić podspecyfikację CoreML w Podfile.

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

LUB

# 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 (do 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);

Sprawdzone metody

Używanie delegata Core ML na urządzeniach bez Neural Engine

Domyślnie delegat Core ML jest tworzony tylko wtedy, gdy na urządzeniu działa mechanizm neuronowy. Jeśli delegat nie został utworzony, zwraca wartość null. Jeśli chcesz uruchomić delegowanie Core ML w innych środowiskach (na przykład w symulatorze), podczas tworzenia delegata w Swift przekaż opcję .all jako opcję. W przypadku C++ (i Objective-C) możesz ustawić limit TfLiteCoreMlDelegateAllDevices. Poniższy przykład pokazuje, jak to zrobić:

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

Użycie delegata do Metal(GPU) jako opcji zastępczej.

Jeśli delegat do Core ML nie jest utworzony, możesz nadal korzystać z przekazywania dostępu do metalu, aby uzyskiwać korzyści w zakresie wydajności. Poniższy przykład pokazuje, jak to zrobić:

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

Logika tworzenia delegata odczytuje identyfikator maszyny (np. iPhone11,1), aby określić dostępność silnika neuronowego. Więcej informacji znajdziesz w kodzie. Możesz też wdrożyć własny zestaw urządzeń z listy odrzuconych, korzystając z innych bibliotek, np. DeviceKit.

Używanie starszej wersji Core ML

Chociaż iOS 13 obsługuje Core ML 3, model może działać lepiej po konwersji po konwersji zgodnie ze specyfikacją modelu Core ML 2. Docelowa wersja konwersji jest domyślnie ustawiona na najnowszą wersję, ale możesz to zmienić, ustawiając coreMLVersion (w Swift oraz coreml_version w interfejsie C API) w opcji przekazywania dostępu do starszej wersji.

Obsługiwane operacje

Poniższe operacje są obsługiwane przez przedstawiciela Core ML.

  • Dodawanie:
    • Można przesyłać tylko niektóre kształty. W układzie tensorów Core ML nadawane są następujące kształty tensorów. [B, C, H, W], [B, C, 1, 1], [B, 1, H, W], [B, 1, 1, 1].
  • ŚredniaPula2D
  • Concat
    • Łączenie powinno odbywać się wzdłuż osi kanału.
  • Konw2D
    • Wagi i odchylenie powinny być stałe.
  • DepthwiseConv2D
    • Wagi i odchylenie powinny być stałe.
  • Fully Connected (czyli Dense lub InnerProduct)
    • Wagi i odchylenie (jeśli występują) powinny być stałe.
    • Obsługuje tylko pojedyncze zgłoszenie. Wejściowy wymiar powinien wynosić 1 z wyjątkiem ostatniego wymiaru.
  • Hardswish
  • Logistyka (Sigmoid)
  • Maks.Pool2D
  • MirrorPad
    • W trybie REFLECT obsługiwane jest tylko wejście 4D. Dopełnienie powinno być stałe i jest dozwolone tylko w przypadku wymiarów wysokości oraz szerokości.
    • Można przesyłać tylko niektóre kształty. W układzie tensorów Core ML nadawane są następujące kształty tensorów. [B, C, H, W], [B, C, 1, 1], [B, 1, H, W], [B, 1, 1, 1].
  • Pad i PadV2
    • Obsługiwane są tylko wejście 4D. Dopełnienie powinno mieć charakter stały i jest dozwolone tylko w przypadku wymiarów H i W.
  • Relu
  • ReluN1To1
  • Relu6
  • Zmień kształt
    • Obsługiwana tylko wtedy, gdy docelowa jest wersja Core ML 2, a w przypadku kierowania na Core ML 3 nie jest to obsługiwane.
  • ResizeBilinear
  • SoftMax
  • Tanh
  • TransposeConv
    • Wagi powinny być stałe.

Prześlij opinię

W przypadku problemów utwórz zgłoszenie w GitHub, podając wszystkie informacje niezbędne do ich odtworzenia.

Najczęstsze pytania

  • Czy CoreML deleguje obsługę kreacji zastępczych do CPU, jeśli wykres zawiera nieobsługiwane operacje?
    • Tak
  • Czy delegowanie CoreML działa w symulatorze iOS?
    • Tak. Biblioteka zawiera cele x86 i x86_64, dzięki czemu można ją uruchamiać w symulatorze, ale nie zauważysz zwiększenia wydajności w przypadku użycia procesora.
  • Czy delegacje TensorFlow Lite i CoreML obsługują macOS?
    • Procesor TensorFlow Lite jest testowany tylko na iOS, ale nie w macOS.
  • Czy niestandardowe operacje TF Lite są obsługiwane?
    • Nie. Delegat CoreML nie obsługuje operacji niestandardowych i w zastępstwie będzie używany procesor.

Interfejsy API