Google I/O הוא עטיפה! התעדכן בהפעלות של TensorFlow. צפה בהפעלות

נציג Tensorflow Lite Core ML

נציג ה- TensorFlow Lite Core ML מאפשר הפעלת דגמי TensorFlow Lite על מסגרת ה- Core ML , מה שמביא להסקת מודל מהירה יותר במכשירי iOS.

גרסאות ומכשירי iOS נתמכים:

  • iOS 12 ואילך. בגרסאות iOS הישנות יותר, נציג Core ML יחזור אוטומטית למעבד.
  • כברירת מחדל, נציג Core ML יופעל רק במכשירים עם A12 SoC ואילך (מכשירי iPhone X ואילך) לשימוש במנוע עצבי עבור היסק מהיר יותר. אם ברצונך להשתמש בנציג Core ML גם במכשירים הישנים, עיין בשיטות העבודה המומלצות

מודלים נתמכים

נציג ה- Core ML תומך כרגע בדגמי float (FP32 ו- FP16).

מנסה את נציג ה- Core ML על פי המודל שלך

נציג ה- Core ML כבר נכלל במהדורה לילית של TensorFlow lite CocoaPods. כדי להשתמש הנציג Core ML, לשנות שלך TensorFlow לייט תרמיל לכלול subspec CoreML ב שלך Podfile .

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

אוֹ

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

C (עד 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);
      

שיטות עבודה מומלצות

באמצעות נציג Core ML במכשירים ללא מנוע עצבי

כברירת מחדל, נציג Core ML ייווצר רק אם למכשיר יש מנוע עצבי, והוא יחזיר null אם הנציג לא נוצר. אם ברצונך להפעיל נציג Core ML בסביבות אחרות (לדוגמה, סימולטור), .all כאופציה בעת יצירת נציג ב- Swift. ב- C ++ (ו- Objective-C), תוכלו להעביר את TfLiteCoreMlDelegateAllDevices . הדוגמה הבאה מראה כיצד לעשות זאת:

מָהִיר

    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
      

שימוש באציל מתכת (GPU) כתגמול.

כאשר נציג ה- Core ML לא נוצר, לחלופין אתה עדיין יכול להשתמש בנציג מטאל כדי להשיג הטבות ביצועים. הדוגמה הבאה מראה כיצד לעשות זאת:

מָהִיר

    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
      

ההיגיון ליצירת הנציגים קורא את מזהה המכונה של המכשיר (למשל iPhone11,1) כדי לקבוע את זמינות המנוע העצבי שלו. ראה את הקוד לפרטים נוספים. לחלופין, אתה יכול ליישם קבוצה משלך של מכשירי דנליסט באמצעות ספריות אחרות כגון DeviceKit .

באמצעות גרסת Core ML ישנה יותר

למרות ש- iOS 13 תומך ב- Core ML 3, הדגם עשוי לעבוד טוב יותר כאשר הוא מומר במפרט Core ML 2. גרסת המרת היעד מוגדרת כברירת מחדל לגרסה האחרונה, אך ניתן לשנות זאת על ידי הגדרת coreMLVersion (ב- Swift, coreml_version ב- C API) באפשרות הנציג לגרסה ישנה יותר.

אופים נתמכים

האופציות הבאות נתמכות על ידי נציג ה- Core ML.

  • לְהוֹסִיף
    • ניתן לשדר רק צורות מסוימות. במערך tensor Core ML, ניתן לשדר את צורות הטנזור הבאות. [B, C, H, W] , [B, C, 1, 1] , [B, 1, H, W] , [B, 1, 1, 1] .
  • ממוצע בריכה 2D
  • קונקאט
    • יש לבצע שרשור לאורך ציר הערוץ.
  • Conv2D
    • משקולות והטיה צריכים להיות קבועים.
  • DepthwiseConv2D
    • משקולות והטיה צריכים להיות קבועים.
  • מחובר באופן מלא (aka צפוף או InnerProduct)
    • משקולות והטיה (אם קיימים) צריכים להיות קבועים.
    • תומך רק במקרה יחיד. ממדי הקלט צריכים להיות 1, למעט הממד האחרון.
  • הרדוויש
  • לוגיסטי (aka Sigmoid)
  • MaxPool2D
  • MirrorPad
    • נתמך רק קלט 4D עם מצב REFLECT . הריפוד צריך להיות קבוע, ומותר רק למידות H ו- W.
  • מול
    • ניתן לשדר רק צורות מסוימות. במערך טנזור Core ML, ניתן לשדר את צורות הטנזור הבאות. [B, C, H, W] , [B, C, 1, 1] , [B, 1, H, W] , [B, 1, 1, 1] .
  • Pad ו- PadV2
    • נתמך רק קלט 4D. הריפוד צריך להיות קבוע, ומותר רק למידות H ו- W.
  • רלו
  • ReluN1To1
  • Relu6
  • שִׁנוּי צוּרָה
    • נתמך רק כאשר גרסת ה- Core ML היעד היא 2, אינה נתמכת בעת הכוונת ה- Core ML 3.
  • שינוי גודל בילינארי
  • SoftMax
  • תן
  • TransposeConv
    • המשקולות צריכות להיות קבועות.

מָשׁוֹב

עבור בעיות, אנא צור גיליון GitHub עם כל הפרטים הדרושים להעתקה.

שאלות נפוצות

  • האם נציג ה- CoreML תומך בתגובה למעבד אם גרף מכיל אופים שאינם נתמכים?
    • כן
  • האם נציג CoreML עובד בסימולטור iOS?
    • כן. הספרייה כוללת מטרות x86 ו- x86_64 כדי שתוכל לרוץ על סימולטור, אך לא תראה שיפור ביצועים על פני המעבד.
  • האם נציגי TensorFlow Lite ו- CoreML תומכים ב- MacOS?
    • TensorFlow Lite נבדק רק ב- iOS אך לא ב- MacOS.
  • האם אופציות TF Lite מותאמות אישית נתמכות?
    • לא, נציג CoreML אינו תומך באופציות מותאמות אישית והן יחזרו למעבד.

ממשקי API