בחירת אופרטורים של TensorFlow

מאחר שספריית המפעילים המובנית של LiteRT תומכת רק במספר מוגבל של יש מספר אופרטורים של TensorFlow, לא כל מודל ניתן להמרה. לפרטים, התייחסות לתאימות מפעילים.

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

במסמך הזה מוסבר איך להמיר להריץ מודל LiteRT שמכיל פעולות TensorFlow פלטפורמה לבחירתך. נסביר גם על ביצועים וגודל מדדים ומגבלות ידועות.

המרת מודל

הדוגמה הבאה מראה איך ליצור מודל LiteRT באמצעות פעולות TensorFlow

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

הרצת ההסקה

כשמשתמשים במודל LiteRT שעבר המרה עם תמיכה ב- בפעולות TensorFlow, הלקוח חייב להשתמש גם בסביבת זמן ריצה של LiteRT כוללת את הספרייה הנדרשת של פעולות TensorFlow.

המלצות שמיושמות באופן אוטומטי (AAR) ב-Android

כדי להקטין את הגודל הבינארי, יש ליצור קובצי AAR מותאמים אישית לפי ההנחיות המפורטות בקטע הבא. אם הגודל הבינארי אינו חשש משמעותי, אנחנו ממליצים להשתמש ב-AAR המוכנה מראש עם פעולות TensorFlow מתארח ב- MavenCentral.

אפשר לציין זאת ביחסי התלות של build.gradle על ידי הוספתה לצד ה-AAR הסטנדרטי של LiteRT AAR:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

כדי להשתמש בתמונות מצב מדי לילה, צריך להוסיף תמונת מצב של Sonatype מאגר הנתונים.

לאחר הוספת התלות, נציג מורשה לטיפול את פעולות TensorFlow של הגרף צריכות להיות מתקינים באופן אוטומטי עבור גרפים המחייבים אותם.

הערה: התלות בתפעול של TensorFlow גדולה יחסית, כך שסביר להניח ברצונך לסנן ממשקי ABI x86 מיותרים בקובץ .gradle על ידי הגדרה את abiFilters.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

פיתוח AAR של Android

כדי להקטין את הגודל הבינארי או מקרים מתקדמים אחרים, אפשר גם ליצור את את הספרייה באופן ידני. משתמשים בגרסת LiteRT פעילה סביבת האחסון, בונים את ה-AAR של Android באמצעות פעולות TensorFlow נבחרות ככה:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

הפעולה הזו תיצור את קובץ ה-AAR bazel-bin/tmp/tensorflow-lite.aar עבור פעולות מובנות ומותאמות אישית של LiteRT; וליצור את קובץ ה-AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar לפעולות של TensorFlow. אם אין סביבת build פעילה, אפשר גם ליצור קבצים למעלה עם Docer.

משם תוכלו לייבא את קובצי ה-AAR ישירות לפרויקט, או לפרסם את קובצי ה-AAR המותאמים אישית למאגר Maven המקומי:

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

לסיום, בbuild.gradle של האפליקציה, צריך לוודא שmavenLocal() של התלות הזאת ולהחליף את התלות הרגילה של LiteRT בזו יש תמיכה בפעולות נבחרות של TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

שימוש ב-CocoaPods

LiteRT מספק ל-arm64 תפעול TF נבחרים מראש בלילה, שאפשר להסתמך עליהם לצד TensorFlowLiteSwift או TensorFlowLiteObjC CocoaPods.

הערה: אם אתם צריכים להשתמש בפעולות TF נבחרות בסימולטור של x86_64, אתם יכולים ליצור בחירת מסגרת התפעול בעצמכם. למידע נוסף, כדאי לעיין במאמר שימוש ב-Bazel + Xcode. לקבלת פרטים נוספים.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

אחרי הרצת pod install, צריך לספק סימון מקשר נוסף עבור לטעון באופן מאול את מסגרת תפעול TF שנבחרה לפרויקט שלך. בפרויקט Xcode שלכם, עבור אל Build Settings -> Other Linker Flags, ולהוסיף:

לגרסאות >= 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

לגרסאות < 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

לאחר מכן אפשר יהיה להריץ את כל המודלים שהומרו באמצעות SELECT_TF_OPS ב- באפליקציה ל-iOS. לדוגמה, ניתן לשנות את סיווג התמונות ב-iOS אפליקציה כדי לבדוק את התכונה הנבחרת של תפעול TF.

• מחליפים את קובץ המודל בקובץ שהומר באמצעות SELECT_TF_OPS.
• מוסיפים תלות של TensorFlowLiteSelectTfOps ל-Podfile לפי ההוראות.
• מוסיפים את סימון הקישור הנוסף כפי שמתואר למעלה.
• מריצים את האפליקציה לדוגמה ובודקים אם המודל פועל כמו שצריך.

שימוש ב-Bazel + Xcode

את LiteRT עם פעולות TensorFlow נבחרות ל-iOS אפשר ליצור באמצעות Bazel. קודם כול, פועלים לפי ההוראות לגרסת ה-build של iOS כדי להגדיר סביבת עבודה של Bazel וקובץ .bazelrc בצורה תקינה.

אחרי שמגדירים את סביבת העבודה עם תמיכה ב-iOS מופעלת, אפשר להשתמש את הפקודה הבאה כדי ליצור את ה-framework הנבחר של תוספים לתפעול TF, שניתן להוסיף בנוסף ל-TensorFlowLiteC.framework הרגיל. חשוב לשים לב שפעולות TF נבחרות framework לא ניתן לבנות עבור ארכיטקטורה של i386, לכן צריך להגדיר לספק את הרשימה של ארכיטקטורות היעד מלבד i386.

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

הפעולה הזו תיצור את ה-framework במסגרת bazel-bin/tensorflow/lite/ios/ כדי להוסיף את ה-framework החדש הזה לפרויקט Xcode שלכם, צריך לפעול לפי השלבים הבאים: שלבים דומים שמתוארים בקטע פרויקט Xcode בקטע ההגדרות מדריך build ל-iOS.

אחרי שמוסיפים את ה-framework לפרויקט האפליקציה, מופיע סימון מקשר נוסף צריך לציין בפרויקט האפליקציה כדי לאלץ את הטעינה של פעולות TF שנבחרו . בפרויקט Xcode, עוברים אל Build Settings -> Other Linker Flags, ולהוסיף:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C/C++‎

אם משתמשים ב-Bazel או ב-CMake כדי ליצור את LiteRT בתרגום שיחה פעילה, אפשר להפעיל משתמש עם הרשאה לשימוש ב-Flex על ידי קישור של LiteRT Flex להעניק גישה לספרייה משותפת. אפשר לפתח אותו באמצעות Bazel בתור הפקודה הבאה.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

הפקודה הזו יוצרת את הספרייה המשותפת הבאה ב- bazel-bin/tensorflow/lite/delegates/flex

חשוב לדעת שה-TfLiteDelegate הדרוש יותקן באופן אוטומטי במקרים הבאים ליצור את המתרגם בזמן ריצה, כל עוד הספרייה המשותפת מקושרת. הוא אין צורך להתקין באופן מפורש את המכונה של מקבל הגישה, כפי שבדרך כלל שנדרשים עם סוגים אחרים של הרשאות גישה.

הערה: התכונה הזו זמינה מגרסה 2.7.

Python

LiteRT עם פעולות TensorFlow נבחרות יותקן באופן אוטומטי עם חבילת PensorFlow pip. אפשר לבחור גם להתקין רק את תמונה-בתוך-תמונה של 'תרגום ב-LiteRT' חבילה.

מדדים

ביצועים

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

הטבלה הבאה מתארת את הזמן הממוצע שלוקח להפעלת ההסקה MobileNet במכשיר Pixel 2. הזמנים הרשומים הם 100 הפעלות בממוצע. האלה יעדים נוצרו ל-Android באמצעות הדגלים: --config=android_arm64 -c opt.

גודל בינארי

בטבלה הבאה מתואר הגודל הבינארי של LiteRT בכל גרסת build. היעדים האלו נוצרו ל-Android באמצעות --config=android_arm -c opt.

(1) הספריות האלה בנויות באופן סלקטיבי עבור i3d-kinetics-400 מודל עם 8 פעולות מובנות של TFLite ו-3 פעולות Tensorflow. פרטים נוספים זמינים הקטנת הגודל הבינארי של LiteRT.

מגבלות ידועות

• סוגים לא נתמכים: יכול להיות שפעולות מסוימות של TensorFlow לא תומכות בקבוצה המלאה של סוגי הקלט/פלט שבדרך כלל זמינים ב-TensorFlow.

עדכונים

• גרסה 2.6
  • תמיכה באופרטורים המבוססים על מאפייני GraphDef ובמשאב HashTable האתחולים השתפרו.
• גרסה 2.5
  • אפשר לבצע אופטימיזציה שנקראת אימון פוסט קוונטיזציה
• גרסה 2.4
  • השתפרה התאימות לנציגים עם האצת חומרה