דף זה תורגם על ידי Cloud Translation API.

יצירה ופריסה של מודל לזיהוי אובייקטים בהתאמה אישית באמצעות TensorFlow Lite (Android)

1. לפני שמתחילים

במעבדה זו, תלמדו איך לאמן מודל לזיהוי אובייקטים מותאם אישית בעזרת קבוצה של תמונות אימונים באמצעות TFLite model Maker. לאחר מכן תוכלו לפרוס את המודל באפליקציה ל-Android באמצעות ספריית המשימות של TFLite. מה עליך לעשות?

בונים אפליקציה ל-Android שמזהה מצרכים בתמונות של ארוחות.
שילוב של מודל זיהוי אובייקטים שהוכן מראש של TFLite ויכולת לראות מה המגבלה במודל.
מאמנים מודל מותאם אישית לזיהוי אובייקטים כדי לזהות את הרכיבים או הרכיבים של ארוחה באמצעות מערך נתונים מותאם אישית בשם salad ו-TFLite model Maker.
פריסת המודל המותאם אישית באפליקציה ל-Android באמצעות ספריית המשימות של TFLite.

בסופו של דבר, תיצור משהו הדומה לתמונה הבאה:

דרישות מוקדמות

Codelab זה מיועד למפתחים מנוסים בתחום הנייד שרוצים להתנסות בלמידה חישובית. כדאי שתכירו את:

פיתוח מכשירי Android באמצעות Kotlin ו-Android Studio
תחביר בסיסי של Python

מה תלמדו

איך לאמן מודל לזיהוי אובייקטים מותאמים אישית באמצעות 'יוצר מודלים של TFLite'
איך לפרוס מודל לזיהוי אובייקטים של TFLite באמצעות ספריית המשימות של TFLite.

מה תצטרך להכין

גרסה עדכנית של Android Studio (גרסה 4.2 ומעלה)
אמולטור Android Studio או מכשיר Android פיזי
הקוד לדוגמה
ידע בסיסי על פיתוח Android בקוטלין

2. זיהוי אובייקטים

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

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

TensorFlow Lite

TensorFlow Lite היא ספרייה של למידה חישובית המתבססת על פלטפורמות שונות. הפלטפורמה הזו מותאמת להרצת מודלים של למידה חישובית במכשירים קצה, כולל מכשירים ניידים עם Android ו-iOS.

TensorFlow Lite הוא למעשה המנוע המרכזי המשמש ללמידה חישובית. הסביבה העסקית של TensorFlow Lite כוללת שני רכיבים שמקלים על האימון ופריסה של מודלים של למידה חישובית במכשירים ניידים:

Model Maker היא ספריית Python שמקלה על האימון של דגמי TensorFlow Lite באמצעות הנתונים שלכם, באמצעות מספר שורות קוד בלבד ללא צורך במומחיות בלמידה חישובית.
ספריית המשימות היא ספרייה בפלטפורמות שונות. כך קל לפרוס תבניות של TensorFlow Lite באפליקציות לנייד.

שיעור Lab זה מתמקד ב-TFLite. קונספטים ובלוקים של קוד שאינם רלוונטיים ל-TFLite ולזיהוי אובייקטים לא מוסברים והם ניתנים להעתקה והדבקה בלבד.

3. להגדרה

להורדת הקוד

כדי להוריד את כל הקוד של Lablab זה, צריך ללחוץ על הקישור הבא:

פותחים את הקובץ הדחוס. פעולה זו תשחרר תיקיית בסיס (odml-pathways-main) עם כל המשאבים הדרושים לך. עבור קוד Lab זה תצטרכו את המקורות רק בספריית המשנה object-detection/codelab2/android.

ספריית המשנה android במאגר object-detection/codelab2/android מכילה שתי ספריות:

התחלה — קוד בסיס שעליו תבססו על מעבדת קוד זו.
סופי – הושלם הקוד לאפליקציה לדוגמה שהושלמה.

ייבוא אפליקציית ההתחלה

נתחיל בייבוא של האפליקציה למתחילים ל-Android Studio.

פותחים את Android Studio ובוחרים באפשרות ייבוא פרויקט (גראדל, Eclipse ADT וכו')
יש לפתוח את התיקייה starter מקוד המקור שהורדת קודם.

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

בוחרים באפשרות סנכרון פרויקט עם קובצי Gradle () מסרגל הכלים ב-Android Studio. מייבאים את starter/app/build.gradle

הפעלת האפליקציה למתחילים

עכשיו, לאחר שייבאתם את הפרויקט אל Android Studio, אתם מוכנים להפעיל את האפליקציה בפעם הראשונה.

מחברים את מכשיר ה-Android באמצעות USB למחשב או מפעילים אמולטור של Android Studio,ולוחצים על הרצה ( ) בסרגל הכלים של Android Studio.

4. הסבר על האפליקציה למתחילים

כדי שה-Codelab הזה יהיה פשוט ויתמקד בביטים של הלמידה החישובית, האפליקציה למתחילים כוללת קוד מבושל שמבצע כמה פעולות עבורכם:

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

תהיה לך אינטראקציה בעיקר עם השיטות האלה בשלד האפליקציה:

fun runObjectDetection(bitmap: Bitmap) השיטה הזו נקראת כשבוחרים תמונה מוגדרת מראש או מצלמים תמונה. bitmap היא תמונת הקלט לזיהוי אובייקטים. בהמשך מעבדת הקוד הזו, תוסיפו את הקוד לזיהוי אובייקטים לשיטה הזו.
data class DetectionResult(val boundingBoxes: Rect, val text: String) זהו סיווג נתונים שמייצג תוצאת זיהוי אובייקט להצגה חזותית. boundingBoxes הוא המלבן שבו נמצא האובייקט, ו-text היא מחרוזת תוצאת הזיהוי שתוצג יחד עם התיבה התוחמת של האובייקט.
fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<DetectionResult>): Bitmap השיטה הזו מושכת את תוצאות זיהוי האובייקטים ב-detectionResults בקלט bitmap ומחזירה את העותק המעודכן שלה.

הנה דוגמה לפלט של שיטת התשתיות drawDetectionResult.

5. הוספה של זיהוי אובייקט במכשיר

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

הורדת מודל לזיהוי אובייקטים של TFLite שהוכן מראש

יש מספר דגמים של מזהה אובייקטים ב-TensorFlow Hub שבהם אפשר להשתמש. עבור קוד Lab זה, תורידו את מודל זיהוי האובייקטים EfficientDet-Lite, שהורכב על מערך הנתונים של COCO 2017, המותאם ל-TFLite ומתוכנן להשגת ביצועים ב-CPU לנייד, ב-GPU וב-EdgeTPU.

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

הוספת המודל לאפליקציה למתחילים

מעתיקים את המודל שהורדת עכשיו לתיקייה assets של האפליקציה למתחילים. ניתן למצוא את התיקייה בחלונית הניווט פרויקט ב-Android Studio.

שם הקובץ model.tflite.

עדכון יחסי תלות של ספריית משימות ב-Gradle

יש לעבור לקובץ app/build.gradle ולהוסיף את השורה הזו להגדרה dependencies:

implementation 'org.tensorflow:tensorflow-lite-task-vision:0.3.1'

סנכרון הפרויקט עם קובצי ציונים

כדי לוודא שכל התשתיות זמינות לאפליקציה שלכם, בשלב זה יש לסנכרן את הפרויקט עם קובצי ציונים. בוחרים באפשרות סנכרון פרויקט עם קובצי Gradle () מסרגל הכלים ב-Android Studio.

(אם הלחצן הזה מושבת, יש להקפיד לייבא רק את הסימן Starter/app/build.gradle, ולא את כל המאגר).

הגדרה והפעלה של זיהוי אובייקטים במכשיר

יש רק 3 שלבים פשוטים עם 3 ממשקי API לטעינה והפעלה של מודל לזיהוי אובייקטים:

הכנת תמונה / שידור: TensorImage
יצירה של אובייקט מזהה: ObjectDetector
חיבור בין שני האובייקטים שלמעלה: detect(image)

יש להשיג אותם במסגרת הפונקציה runObjectDetection(bitmap: Bitmap)בקובץ MainActivity.kt.

/**
* TFLite Object Detection Function
*/
private fun runObjectDetection(bitmap: Bitmap) {
    //TODO: Add object detection code here
}

הפונקציה ריקה כרגע. עוברים אל השלבים הבאים כדי להטמיע את מזהה אובייקט ה-TFLite. בדרך, מערכת Android Studio תבקש מכם להוסיף את נתוני הייבוא הדרושים:

org.tensorflow.lite.support.image.TensorImage
org.tensorflow.lite.task.vision.detector.ObjectDetector

יצירה של אובייקט תמונה

התמונות שבהן תשתמשו ב-codelab זה יגיעו מהמצלמה של המכשיר או מתמונות מוגדרות מראש שתבחרו בממשק המשתמש של האפליקציה. תמונת הקלט מפוענחת בפורמט Bitmap ומועברת בשיטה runObjectDetection.

מערכת TFLite מספקת API פשוט ליצירת TensorImage מתוך Bitmap. צריך להוסיף את הקוד שבהמשך לחלק העליון של runObjectDetection(bitmap:Bitmap):

// Step 1: create TFLite's TensorImage object
val image = TensorImage.fromBitmap(bitmap)

יצירת מופע של מזהה

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

תוצאה מקסימלית (המספר המקסימלי של אובייקטים שהמודל צריך לזהות)
סף לדירוג (באיזו מידה ביטחון של מזהה אובייקט להחזיר אובייקט שזוהה)
הוספת תווית לרשימת ההיתרים/דחייה (אישור/דחייה של האובייקטים ברשימה מוגדרת מראש)

מפעילים את המופע של מזהה האובייקט על ידי ציון שם הקובץ של מודל TFLite ואפשרויות התצורה:

// Step 2: Initialize the detector object
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "model.tflite", // must be same as the filename in assets folder
    options
)

תמונות בפיד אל המזהה

יש להוסיף את הקוד הבא אל fun runObjectDetection(bitmap:Bitmap). פעולה זו תזין את התמונות למזהה.

// Step 3: feed given image to the model and print the detection result
val results = detector.detect(image)

בסיום התהליך, המזהה מחזיר רשימה של Detection, המכילה כל מידע על אובייקט שהמודל מצא בתמונה. כל אובייקט מתואר עם:

boundingBox: המלבן שמצהיר על נוכחות של אובייקט והמיקום שלו בתוך התמונה
categories: מהו סוג האובייקט ומידת הוודאות של המודל ביחס לתוצאת הזיהוי. המודל מחזיר קטגוריות מרובות, והקטגוריה הבטוחה ביותר היא הראשונה.
label: השם של קטגוריית האובייקט.
classificationConfidence:מספר ממשי (float) בין 0.0 ל-1.0, כאשר 1.0 מייצג 100%

הדפסה של תוצאות הזיהוי

יש להוסיף את הקוד הבא אל fun runObjectDetection(bitmap:Bitmap). הפעולה הזו קוראת לשיטה להדפיס את תוצאות זיהוי האובייקטים אל Logcat.

// Step 4: Parse the detection result and show it
debugPrint(results)

לאחר מכן יש להוסיף את השיטה debugPrint()הזאת לכיתה MainActivity:

private fun debugPrint(results : List<Detection>) {
    for ((i, obj) in results.withIndex()) {
        val box = obj.boundingBox

        Log.d(TAG, "Detected object: ${i} ")
        Log.d(TAG, "  boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")

        for ((j, category) in obj.categories.withIndex()) {
            Log.d(TAG, "    Label $j: ${category.label}")
            val confidence: Int = category.score.times(100).toInt()
            Log.d(TAG, "    Confidence: ${confidence}%")
        }
    }
}

עכשיו הכלי לזיהוי אובייקטים מוכן! הידור והפעלה של האפליקציה על ידי לחיצה על הרצה ( ) בסרגל הכלים של Android Studio. אחרי שהאפליקציה מופיעה במכשיר, מקישים על אחת מהתמונות שהוגדרו מראש כדי להפעיל את מזהה האובייקט. לאחר מכן יש להביט בחלון Logcat *(* *)* בתוך ה-IDE, ולראות משהו דומה לזה:

D/TFLite-ODT: Detected object: 0 
D/TFLite-ODT:   boundingBox: (0.0, 15.0) - (2223.0,1645.0)
D/TFLite-ODT:     Label 0: dining table
D/TFLite-ODT:     Confidence: 77%
D/TFLite-ODT: Detected object: 1 
D/TFLite-ODT:   boundingBox: (702.0, 3.0) - (1234.0,797.0)
D/TFLite-ODT:     Label 0: cup
D/TFLite-ODT:     Confidence: 69%

משמעות הדבר היא שהמזהה ראה 2 אובייקטים. הפרמטר הראשון הוא:

אובייקט נמצא בתוך מלבן של (0, 15) – (2223, 1645)
התווית היא טבלת אוכל
המודל בטוח שהראשונה היא טבלת אוכל (77%)

טכנית זה כל מה שצריך כדי שספריית המשימות של TFLite תפעל: הכול מוכן באותו רגע! מזל טוב!

עם זאת, בצד ממשק המשתמש, אתם עדיין נמצאים בנקודת ההתחלה. עכשיו, אחרי שאתם מעבדים את התוצאות שזוהו, אתם צריכים להשתמש בתוצאות שזוהו בממשק המשתמש.

6. יש לשרטט את תוצאת הזיהוי בתמונת הקלט

בצעדים הקודמים, הדפסת את תוצאת הזיהוי ב-logcat: פשוטה ומהירה. בשלב זה, תשתמשו בשיטת השימוש שכבר הוטמעה באפליקציה למתחילים, כדי:

ציור תיבה תוחמת בתמונה
יש לציין שם קטגוריה ואחוז מהימנות בתיבה התוחמת

יש להחליף את הקריאה מסוג debugPrint(results) בקטע הקוד הבא:

val resultToDisplay = results.map {
    // Get the top-1 category and craft the display text
    val category = it.categories.first()
    val text = "${category.label}, ${category.score.times(100).toInt()}%"

    // Create a data object to display the detection result
    DetectionResult(it.boundingBox, text)
}
// Draw the detection result on the bitmap and show it.
val imgWithResult = drawDetectionResult(bitmap, resultToDisplay)
runOnUiThread {
    inputImageView.setImageBitmap(imgWithResult)
}

עכשיו לוחצים על הפעלה () בסרגל הכלים של Android Studio.
אחרי שהאפליקציה נטענת, מקישים על אחת מהתמונות המוגדרות מראש כדי לראות את תוצאת הזיהוי.

רוצה לנסות עם תמונה משלך? מקישים על הלחצן צילום תמונה ומצלמים תמונות של אובייקטים בסביבה.

7. אימון של מודל זיהוי אובייקט בהתאמה אישית

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

לפניכם מערך נתונים שמכיל תמונות ותוויות שניתן להשתמש בהן כדי לתרגל אימון של מודל מותאם אישית משלכם. היא נוצרה באמצעות תמונות מ-Open Photos Dataset V4.

Colaboratory

בשלב הבא, עוברים ל-Google Colab כדי לאמן את המודל המותאם אישית.

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

מחברות של Colab משתמשות בקוד בשרתים של Google בענן, כלומר, אתם יכולים למנף את העוצמה של החומרה של Google, כולל מעבדי GPU ו-TPU, ללא קשר לעוצמה של המחשב. כל מה שצריך זה דפדפן.

אם אין לכם גישה ל-Colab, אתם יכולים להשתמש בסביבה אחרת ולגשת לקוד דרך הקישור הזה של GitHub.

האימון של המודל המותאם אישית יימשך כ-30 דקות.

אם אתם עסוקים מאוד, תוכלו להוריד דגם שנערך מראש על מערך הנתונים שסופק לכם ולהמשיך לשלב הבא.

8. שילוב של מודל TFLite מותאם אישית באפליקציה ל-Android

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

מעתיקים את מודל ה-TFLite של הסלט לתיקייה assets. תן שם למודל החדש salad.tflite.

פותחים את הקובץ MainActivity.kt ומוצאים את קוד האתחול של ObjectDetector.
החלפת מודל EfficientDet-Lite (model.tflite) במודל הסלט (salad.tflite)

val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "salad.tflite", // must be same as the filename in assets folder
    options
)

לוחצים על הרצה ( ) בסרגל הכלים של Android Studio כדי להפעיל מחדש את האפליקציה עם הדגם החדש. והנה, האפליקציה יכולה עכשיו לזהות גבינות, סלט ומאפים.

9. מעולה!

השתמשת ב-TFLite כדי לאמן מודל מותאם אישית ולהוסיף לאפליקציה יכולות של זיהוי אובייקטים. זה כל מה שצריך לעשות כדי להתחיל לעבוד!

באילו נושאים מדובר?

איך למצוא מודלים לזיהוי אובייקטים של TFLite שהוכשרו מראש ב-TensorFlow Hub
איך לשלב מודלים של זיהוי התנגדויות באפליקציה ל-Android באמצעות ספריית המשימות של TFLite
איך לאמן את מודל הזיהוי של אובייקט בהתאמה אישית עם הכלי ליצירת TFLite

השלבים הבאים

שימוש ב-Firebase לשיפור הפריסה של מודל TFLite
איסוף נתוני הכשרה כדי לאמן את המודל שלך
החלת זיהוי אובייקט באפליקציה שלך ל-Android

מידע נוסף

למידה חישובית במכשיר בעזרת טכנולוגיות Google