צור ממשקי מודל באמצעות מטא נתונים

באמצעות מטא-נתונים של LiteRT, מפתחים יכולים ליצור קוד wrapper כדי להפעיל שילוב ב-Android. לרוב המפתחים, הכי קל להשתמש בממשק הגרפי של Android Studio ML Model Binding. אם אתם צריכים התאמה אישית נוספת או שאתם משתמשים בכלי שורת פקודה, תוכלו להשתמש גם ב-LiteRT Codegen.

שימוש ב-Android Studio ML Model Binding

במודלים של LiteRT שמשופרים באמצעות מטא-נתונים, מפתחים יכולים להשתמש ב-Android Studio ML Model Binding כדי להגדיר באופן אוטומטי את ההגדרות של הפרויקט וליצור מחלקות wrapper על סמך המטא-נתונים של המודל. קוד העטיפה מבטל את הצורך באינטראקציה ישירה עם ByteBuffer. במקום זאת, מפתחים יכולים ליצור אינטראקציה עם מודל LiteRT באמצעות אובייקטים מוקלדים כמו Bitmap ו-Rect.

ייבוא מודל LiteRT ב-Android Studio

  1. לוחצים לחיצה ימנית על המודול שרוצים להשתמש במודל TFLite או לוחצים על File, ואז על New > Other > LiteRT Model

  2. בוחרים את המיקום של קובץ ה-TFLite. שימו לב: כלי הפיתוח יגדירו בשבילכם את התלות של המודול באמצעות ML Model binding, וכל התלויות יוכנסו אוטומטית לקובץ build.gradle של מודול Android.

    אופציונלי: מסמנים את התיבה השנייה כדי לייבא TensorFlow GPU אם רוצים להשתמש בהאצת GPU.

  3. לוחצים על Finish.

  4. המסך הבא יופיע אחרי שהייבוא יסתיים בהצלחה. כדי להתחיל להשתמש במודל, בוחרים באפשרות Kotlin או Java, מעתיקים ומדביקים את הקוד בקטע Sample Code. כדי לחזור למסך הזה, לוחצים לחיצה כפולה על המודל של TFLite בספרייה ml ב-Android Studio.

האצת הסקת מסקנות של מודלים

הכלי ML Model Binding מאפשר למפתחים להאיץ את הקוד שלהם באמצעות שימוש בנציגים ובמספר השרשורים.

שלב 1. בודקים את קובץ המודול build.gradle כדי לוודא שהוא מכיל את התלות הבאה:

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

שלב 2. זיהוי אם ה-GPU שפועל במכשיר תואם לנציג TensorFlow GPU, ואם לא, הפעלת המודל באמצעות כמה שרשורים של CPU:

Kotlin

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code

Java

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code

יצירת ממשקי מודלים באמצעות מחולל הקוד LiteRT

למודל LiteRT עם מטא-נתונים, מפתחים יכולים להשתמש בגנרטור של קוד wrapper ל-Android של LiteRT כדי ליצור קוד wrapper ספציפי לפלטפורמה. קוד העטיפה מבטל את הצורך באינטראקציה ישירה עם ByteBuffer. במקום זאת, מפתחים יכולים לקיים אינטראקציה עם מודל TensorFlow Lite באמצעות אובייקטים מוקלדים כמו Bitmap ו-Rect.

התועלת של מחולל הקוד תלויה בשלמות של רשומת המטא-נתונים של מודל LiteRT. כדי לראות איך כלי יצירת הקוד מנתח כל שדה, אפשר לעיין בקטע <Codegen usage> שמתחת לשדות הרלוונטיים ב-metadata_schema.fbs.

יצירת קוד wrapper

תצטרכו להתקין את כלי הפיתוח הבאים בטרמינל:

pip install tflite-support

אחרי ההשלמה, אפשר להשתמש בגנרטור הקודים באמצעות התחביר הבא:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

הקוד שיתקבל ימוקם בספריית היעד. אם אתם משתמשים ב-Google Colab או בסביבה מרוחקת אחרת, יכול להיות שיהיה לכם קל יותר לכווץ את התוצאה לארכיון ZIP ולהוריד אותה לפרויקט Android Studio:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

שימוש בקוד שנוצר

שלב 1: מייבאים את הקוד שנוצר

אם צריך, פורסים את הקוד שנוצר למבנה של ספרייה. הנתיב הבסיסי של הקוד שנוצר הוא SRC_ROOT.

פותחים את פרויקט Android Studio שבו רוצים להשתמש במודל LiteRT ומייבאים את המודול שנוצר באמצעות: File -> New -> Import Module -> select SRC_ROOT

בדוגמה שלמעלה, הספרייה והמודול שיובא ייקראו classify_wrapper.

שלב 2: מעדכנים את קובץ build.gradle של האפליקציה

במודול האפליקציה שבו ייעשה שימוש במודול הספרייה שנוצר:

בקטע android, מוסיפים את השורות הבאות:

aaptOptions {
   noCompress "tflite"
}

בקטע dependencies, מוסיפים את השורות הבאות:

implementation project(":classify_wrapper")

שלב 3: שימוש במודל

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

האצת הסקת מסקנות של מודלים

הקוד שנוצר מאפשר למפתחים להאיץ את הקוד שלהם באמצעות נציגים ומספר השרשורים. אפשר להגדיר את הפרמטרים האלה כשמאתחלים את אובייקט המודל, כי הוא מקבל שלושה פרמטרים:

  • ‫Context: הקשר מפעילות או משירות של Android
  • (אופציונלי) Device: TFLite acceleration delegate. לדוגמה: GPUDelegate
  • (אופציונלי) numThreads: מספר התהליכונים שמשמשים להרצת המודל – ברירת המחדל היא אחד.

לדוגמה, כדי להשתמש ב-GPU delegate ובעד שלושה שרשורים, אפשר לאתחל את המודל כך:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
    // Error reading the model
}

פתרון בעיות

אם מופיעה השגיאה 'java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed', צריך להוסיף את השורות הבאות בקטע android של מודול האפליקציה שישתמש במודול הספרייה:

aaptOptions {
   noCompress "tflite"
}