שמירה על דיוק בהמרת מודל ML ל-TFLite עבור אנדרואיד

תארו לעצמכם שאימנתם גלאי עצמים על TensorFlow עם mAP של 0.85, המרתם ל-TFLite עם קוונטיזציה מלאה של INT8—ו-mAP במכשיר ירד ל-0.6. האשם: מערך הנתונים המייצג לא כיסה סצנות כהות. או קריסות בזמן ריצה על Android 9 בגלל פעולת Einsum חסרה. הנה איך להימנע מהמלכודות האלה ולשמר דיוק בעת העברה ל-Android.

TFLite הוא לא רק המרת משקלים. זה בחירת פורמט קוונטיזציה, אופטימיזציית גרף, בחירת סט פעולות תואם לגרסאות Android יעד, ואימות התאמה מספרית למקור. לכל שלב יש מלכודות ספציפיות. לצוות שלנו יש מעל 10 שנות ניסיון ייצור ופרסנו מודלי ML ביותר מ-40 פרויקטים של Android—אנחנו יודעים איך לעקוף בעיות טיפוסיות. רקורד מוכח זה מבטיח המרות מדויקות.

בעיות טיפוסיות בהמרת מודלי ML ל-TFLite

קוונטיזציה ללא מערך נתונים מייצג היא טעות נפוצה. אם מערך הנתונים אינו מייצג, גורמי קנה מידה זזים והמודל טועה על נתונים אמיתיים. אנו משתמשים במערך נתונים של 200–500 דוגמאות המכסה את כל מקרי הקצה.

אי-תאימות פעולות—כ-15% מהפעולות המודרניות של TF (Einsum, RaggedTensor, SparseSegmentSum) חסרות בפעולות המובנות של TFLite. תאימות פעולות TensorFlow Lite מראה ש-# FP16 — минимальная деградация, 2× меньше модель, ускорение на GPU delegate converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/") converter.optimizations = [tf.lite.Optimize.DEFAULT] converter.target_spec.supported_types = [tf.float16] tflite_fp16 = converter.convert() # Dynamic INT8 — веса int8, активации float32. Не нужен calibration dataset. converter2 = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/") converter2.optimizations = [tf.lite.Optimize.DEFAULT] tflite_dynamic_int8 = converter2.convert() # Full INT8 — и веса, и активации. Требует calibration dataset. Нужен для Hexagon DSP. def representative_dataset(): dataset = load_calibration_data() # 100-500 примеров for sample in dataset: yield [sample[np.newaxis, :].astype(np.float32)] converter3 = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/") converter3.optimizations = [tf.lite.Optimize.DEFAULT] converter3.representative_dataset = representative_dataset converter3.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8] converter3.inference_input_type = tf.uint8 converter3.inference_output_type = tf.uint8 tflite_full_int8 = converter3.convert() פותר זאת אך מוסיף כ-5 MB לגודל זמן הריצה ומפחית ביצועים. אנו כותבים פעולות כאלה מחדש כתואמות TFLite או מיישמים פעולות מותאמות אישית דרך C++.

תוצאות שונות בין דלגנים (delegates)—אותו מודל מקוונטז יכול להפיק מספרים שונים על CPU, GPU ו-NNAPI. אנו מבצעים בדיקות ביצועים על 5–10 מכשירים אמיתיים ובוחרים את הדלגן עם יחס המהירות/דיוק הטוב ביותר.

מקרה בוחן: המרת YOLOv5

לקוח ביקש לאחרונה להמיר YOLOv5 ל-Android ללא NMS בגרף. יעד: 30 FPS על מכשירי Snapdragon 855. הסרנו NMS מהמודל, יישמנו אותו ב-Kotlin עם סף 0.5 ו-IoU של 0.45, השתמשנו ב-Full INT8 עם כיול על 300 תמונות COCO. תוצאה: 35 FPS על דלגן GPU, mAP ירד ב-2% יחסית ל-FP32—פשרה מקובלת. ללא NMS מותאם אישית, זה היה 40 FPS אך עם חפצי ריבוי תיבות. זה חסך ללקוח 3,000$ לחודש בעלויות מחשוב ענן.

איך להמיר מודל ML ל-TFLite ל-Android?

מסלולי המרה

המסלול הישיר של TF נותן סטיות מינימליות. מסלול ONNX מציג אי-תאימות פוטנציאליות נוספות—השתמשו בו רק כשהמסלול הישיר אינו זמין. קוונטיזציה מלאה של INT8 מפחיתה את גודל המודל פי 4 יחסית ל-FP32, בעוד FP16 מספק הפחתת גודל פי 2 עם האצה של 5–10× על דלגן GPU. ראו מאגר GitHub של TensorFlow Lite לפרמטרי המרה.

קוונטיזציה

# FP16 — минимальная деградация, 2× меньше модель, ускорение на GPU
delegate converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_fp16 = converter.convert()

# Dynamic INT8 — веса int8, активации float32. Не нужен calibration dataset.
converter2 = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/")
converter2.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_dynamic_int8 = converter2.convert()

# Full INT8 — и веса, и активации. Требует calibration dataset. Нужен для Hexagon DSP.
def representative_dataset():
    dataset = load_calibration_data()  # 100-500 примеров
    for sample in dataset:
        yield [sample[np.newaxis, :].astype(np.float32)]

converter3 = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/")
converter3.optimizations = [tf.lite.Optimize.DEFAULT]
converter3.representative_dataset = representative_dataset
converter3.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter3.inference_input_type = tf.uint8
converter3.inference_output_type = tf.uint8
tflite_full_int8 = converter3.convert()

איזה דלגן TFLite לבחור?

בחירת הדלגן משפיעה גם על ביצועים וגם על דיוק. אנו בודקים את המודל על מספר דלגנים ובוחרים את האופטימלי. לדוגמה, דלגן GPU מהיר פי 5 מ-CPU עבור מודלי FP16, בעוד XNNPACK מהיר פי 2 אך תומך ביותר פעולות.

מה לעשות עם פעולות לא נתמכות?

לא כל פעולות TF/PyTorch קיימות בפעולות המובנות של TFLite. בדקו:

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/")
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS,
    tf.lite.OpsSet.SELECT_TF_OPS  # fallback на TF операции
]
tflite_model = converter.convert()

איך לאמת דיוק מודל TFLite?

import numpy as np
# TF
original
tf_output = tf_model(test_input).numpy()
# TFLite
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
interpreter.set_tensor(input_details[0]['index'], test_input)
interpreter.invoke()
tflite_output = interpreter.get_tensor(output_details[0]['index'])
print(f"Max abs diff: {np.max(np.abs(tf_output - tflite_output))}")
print(f"MSE: {np.mean((tf_output - tflite_output)**2)}")
# FP32: < 1e-5, FP16: < 1e-2, INT8: < 0.05

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

שיקולים מיוחדים לגלאי עצמים

YOLO, SSD, EfficientDet—כולם כוללים עיבוד לאחר של NMS (דיכוי לא-מקסימלי). ל-TFLite אין NMS מובנה (בניגוד ל-Core ML Detection Output). אפשרויות:

1. הסרת NMS מהמודל, יישום ב-Java/Kotlin לאחר ההסקה.
2. שימוש ב-TFLite Task Library—היא מספקת API מוכן של converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir/") converter.target_spec.supported_ops = [ tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS # fallback на TF операции ] tflite_model = converter.convert() עם NMS.

// TFLite Task Library: ObjectDetector (включает NMS)
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setScoreThreshold(0.5f)
    .setMaxResults(20)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(context, "detector.tflite", options)
val image = TensorImage.fromBitmap(inputBitmap)
val results: List<Detection> = detector.detect(image)
for (detection in results) {
    val box = detection.boundingBox
    val label = detection.categories.first().label
    val score = detection.categories.first().score
}

למה להוסיף מטא-דאטה של TFLite?

from tflite_support.metadata_writers import image_classifier
from tflite_support.metadata_writers import writer_utils

writer = image_classifier.MetadataWriter.create_for_inference(
    writer_utils.load_file("model.tflite"),
    input_norm_mean=[0.0],
    input_norm_std=[255.0],
    labels_file_paths=["labels.txt"])

tflite_with_metadata = writer.populate()
writer_utils.save_file(tflite_with_metadata, "model_with_metadata.tflite")

ללא מטא-דאטה, ה-TFLite Task Library עובדת גרוע—אין נורמליזציה אוטומטית, אין מיפוי פלט. עם מטא-דאטה, הכל מטופל אוטומטית.

מערך הנתונים לכיול עבור Full INT8 חייב לשקף את התפלגות הקלט האמיתית. לדוגמה, עבור מודל סיווג חתולים, השתמשו ב-300 תמונות חתולים בתנאים משתנים—רעש, חושך, סיבובים. זה מפחית שגיאת קוונטיזציה ב-10-20%.

מה כלול בעבודה?

• ניתוח המודל המקורי ובחירת מסלול ההמרה האופטימלי.
• המרה עם בחירת סוג קוונטיזציה (FP16, Dynamic INT8, Full INT8).
• אימות דיוק על מערך נתונים מייצג עם דוח.
• הוספת מטא-דאטה של מודל TFLite עבור ה-Task Library.
• בדיקות על פארק מכשירים (לפחות 5 מכשירים) דרך Benchmark Tool (CPU, GPU, NNAPI).
• אינטגרציה לאפליקציית Android (Kotlin/Java) עם טיפול בשגיאות.
• תיעוד על בנייה, שימוש ותחזוקת המודל.
• חודש תמיכה במהלך הפריסה.
• הבטחת שימור דיוק בתוך סובלנויות.

התהליך

1. אנליטיקה—הערכת המודל ומסלולי ההמרה.
2. עיצוב—בחירת קוונטיזציה, החלטה על פעולות מותאמות אישית.
3. יישום—המרה, כתיבת קוד מותאם אישית (NMS, עיבוד מקדים).
4. בדיקות—אימות דיוק, בדיקות ביצועים על מכשירים.
5. פריסה—אינטגרציה לאפליקציה, פרסום ל-Google Play.

הערכות זמן

המרה ישירה של מודל TF/Keras עם אימות—מ-3 עד 7 ימים. המרה דרך ONNX, פעולות מותאמות אישית, הוספת מטא-דאטה, בדיקות מלאות—מ-2 עד 4 שבועות. הלקוחות שלנו חוסכים עד 40% בעלויות מחשוב ענן לאחר מעבר ל-ML במכשיר, חיסכון ממוצע נע בין 3,000$ ל-15,000$ לחודש. עלות הפרויקט מחושבת בנפרד לפי המודל והדרישות שלכם. צרו קשר לבדיקת תאימות TFLite חינמית של המודל שלכם. בקשו ייעוץ לאופטימיזציה של המודל שלכם לצי המכשירים היעד שלכם.