בעל גישה ל-Tensorflow Lite Core ML

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

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

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

דגמים נתמכים

נכון לעכשיו, מקבל הגישה ללמידת מכונה תומך במודלים צפים (FP32 ו-FP16).

התנסות עם נציג ללמידת מכונה (Core ML) במודל שלך

מקבל הגישה ללמידת מכונה (Core ML) כבר כלול בגרסה הלילית של TensorFlow lite של CocoaPods. כדי להשתמש בהאצלה של למידת מכונה, צריך לשנות את ה-Pod TensorFlow lite כך שיכלול את תת-הספק 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 ...
  

    #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++ (ובאובייקט-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, אפשר גם להשתמש ב-Metal delegate כדי ליהנות מיתרונות הביצועים. הדוגמה הבאה מראה איך לעשות זאת:

    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.

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

משוב

אם נתקלים בבעיות, מומלץ ליצור בעיה ב-GitHub עם כל הפרטים הדרושים לשחזור.

שאלות נפוצות

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

ממשקי API

• ממשק API של Swift להאצלת ML Core ML
• ממשק API בעל גישה של C API ל-Core ML