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

זיהוי, מעקב וסיווג של אובייקטים באמצעות מודל סיווג בהתאמה אישית ב-Android

אתם יכולים להשתמש ב-ML Kit כדי לזהות אובייקטים בפריימים עוקבים של וידאו ולעקוב אחריהם.

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

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

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

מודל בחבילה	מודל מתארח
המודל הוא חלק מ-APK של האפליקציה, ולכן הוא גדל.	המודל אינו חלק מה-APK שלך. כדי לארח את המשחק, אתם צריכים להעלות אותו ל-Firebase Machine Learning.
הדגם זמין באופן מיידי, גם כשמכשיר Android במצב אופליין	המערכת מורידה את המודל על פי דרישה
אין צורך בפרויקט Firebase	נדרש פרויקט Firebase
כדי לעדכן את המודל, צריך לפרסם מחדש את האפליקציה	דחיפת עדכוני מודל מבלי לפרסם מחדש את האפליקציה
אין בדיקות A/B מובנות	בדיקות A/B פשוטות עם הגדרת תצורה מרחוק ב-Firebase

אני רוצה לנסות

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

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

בקובץ build.gradle ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטע buildscript וגם בקטע allprojects.

מוסיפים את יחסי התלות של ספריות ML Kit ל-Android לקובץ הדירוג ברמת האפליקציה של המודול, שהוא בדרך כלל app/build.gradle:

כדי לקבץ מודל עם האפליקציה:

dependencies {
  // ...
  // Object detection & tracking feature with custom bundled model
  implementation 'com.google.mlkit:object-detection-custom:17.0.1'
}

כדי להוריד באופן דינמי מודל מ-Firebase, צריך להוסיף את התלות linkFirebase:

dependencies {
  // ...
  // Object detection & tracking feature with model downloaded
  // from firebase
  implementation 'com.google.mlkit:object-detection-custom:17.0.1'
  implementation 'com.google.mlkit:linkfirebase:17.0.0'
}

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

1. טעינת המודל

הגדרת מקור של מודל מקומי

כדי לקבץ את המודל עם האפליקציה שלך:

מעתיקים את קובץ המודל (בדרך כלל מסתיים ב-.tflite או .lite) לתיקייה assets/ של האפליקציה. (יכול להיות שקודם תצטרכו ליצור את התיקייה על ידי לחיצה ימנית על התיקייה app/, ולאחר מכן לחיצה על New > Folder > Assets Folder).
לאחר מכן, צריך להוסיף את הקוד הבא לקובץ build.gradle של האפליקציה כדי לוודא ש-Gradle לא תדחס את קובץ המודל כשמפתחים את האפליקציה:
```
android {
    // ...
    aaptOptions {
        noCompress "tflite"
        // or noCompress "lite"
    }
}
```
קובץ המודל ייכלל בחבילת האפליקציה ויהיה זמין ל-ML Kit כנכס גולמי.

שימו לב: החל מגרסה 4.1 של הפלאגין Android Gradle, קובץ .tflite יתווסף לרשימת noCompress כברירת מחדל, ואין יותר צורך בהרשאה שלמעלה.
יוצרים אובייקט LocalModel, ומציינים את הנתיב לקובץ המודל:
Kotlin
```
val localModel = LocalModel.Builder()
        .setAssetFilePath("model.tflite")
        // or .setAbsoluteFilePath(absolute file path to model file)
        // or .setUri(URI to model file)
        .build()
```
Java
```
LocalModel localModel =
    new LocalModel.Builder()
        .setAssetFilePath("model.tflite")
        // or .setAbsoluteFilePath(absolute file path to model file)
        // or .setUri(URI to model file)
        .build();
```
הערה: לאפליקציות שמטרגטות ל-Android 11 (רמת API 30) אין יותר גישה לקבצים מאחסון חיצוני בגלל עדכוני האחסון ב-Android 11.
הערה: אם יש לך מודל שאומן באמצעות AutoML Vision Edge ב-Firebase (ולא Google Cloud), יכול להיות שהמודל שלמעלה לא יעבוד. פעלו לפי ההוראות במדריך להעברת נתונים.

הגדרת מקור מודל שמתארח ב-Firebase

כדי להשתמש במודל באירוח מרחוק, צריך ליצור אובייקט CustomRemoteModel על ידי FirebaseModelSource, ולציין את השם שהקציתם למודל כשפרסמתם אותו:

Kotlin

// Specify the name you assigned in the Firebase console.
val remoteModel =
    CustomRemoteModel
        .Builder(FirebaseModelSource.Builder("your_model_name").build())
        .build()

Java

// Specify the name you assigned in the Firebase console.
CustomRemoteModel remoteModel =
    new CustomRemoteModel
        .Builder(new FirebaseModelSource.Builder("your_model_name").build())
        .build();

לאחר מכן, מתחילים את המשימה של הורדת המודל, ומציינים את התנאים שבהם רוצים לאפשר הורדה. אם המודל לא נמצא במכשיר, או אם יש גרסה חדשה יותר של המודל, המשימה תוריד את המודל באופן אסינכרוני מ-Firebase:

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(@NonNull Task task) {
                // Success.
            }
        });

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

2. הגדרה של מזהה אובייקטים

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

הגדרות של מזהה אובייקטים
מצב זיהוי	`STREAM_MODE` (ברירת מחדל) \| `SINGLE_IMAGE_MODE` במצב `STREAM_MODE` (ברירת המחדל), מזהה האובייקטים פועל עם זמן אחזור קצר, אבל יכול להיות שיופקו תוצאות חלקיות (למשל, תיבות תוחם לא מוגדרות או תוויות של קטגוריות שלא צוינו) בהפעלות הראשונות של המזהה. בנוסף, ב-`STREAM_MODE` המזהה מקצה לאובייקטים מזהים לצורכי מעקב, שבהם אפשר להשתמש כדי לעקוב אחרי אובייקטים במסגרות. אפשר להשתמש במצב הזה כשרוצים לעקוב אחר אובייקטים, או כשיש חשיבות לזמן אחזור קצר, למשל כשמעבדים וידאו סטרימינג בזמן אמת. בשיטה `SINGLE_IMAGE_MODE`, מזהה האובייקטים מחזיר את התוצאה אחרי קביעת התיבה התוחמת של האובייקט. אם מפעילים גם סיווג, המערכת מחזירה את התוצאה אחרי שהתיבה התוחמת וגם תווית הקטגוריה יהיו זמינות. כתוצאה מכך, זמן האחזור של הזיהוי עשוי להיות ארוך יותר. כמו כן, ב-`SINGLE_IMAGE_MODE` לא מוקצים מזהים לצורכי מעקב. כדאי להשתמש במצב הזה אם זמן האחזור אינו קריטי ולא רוצים לטפל בתוצאות חלקיות.
זיהוי אובייקטים מרובים ומעקב אחריהם	`false` (ברירת מחדל) \| `true` האם לזהות ולעקוב אחרי עד חמישה אובייקטים או רק את האובייקט הבולט ביותר (ברירת מחדל).
סיווג אובייקטים	`false` (ברירת מחדל) \| `true` האם לסווג אובייקטים שזוהו באמצעות מודל המסווג המותאם אישית שסופק. כדי להשתמש במודל הסיווג בהתאמה אישית, צריך להגדיר את הערך הזה כ-`true`.
סף ביטחון בסיווג	ציון מהימנות מינימלי של תוויות שזוהו. אם המדיניות לא מוגדרת, המערכת תשתמש בכל סף סיווג שצוין במטא-נתונים של המודל. אם המודל לא מכיל מטא-נתונים או אם המטא-נתונים לא מציינים סף מסווג, ייעשה שימוש בסף ברירת מחדל של 0.0.
מספר מקסימלי של תוויות לאובייקט	מספר התוויות המקסימלי לכל אובייקט שהמזהה יחזיר. אם המדיניות לא מוגדרת, המערכת תשתמש בערך ברירת המחדל 10.

ה-API לזיהוי אובייקטים ולמעקב מותאם לשני תרחישי השימוש העיקריים הבאים:

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

כדי להגדיר את ה-API לתרחישים לדוגמה הבאים, באמצעות מודל בחבילה מקומית:

Kotlin

// Live detection and tracking
val customObjectDetectorOptions =
        CustomObjectDetectorOptions.Builder(localModel)
        .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE)
        .enableClassification()
        .setClassificationConfidenceThreshold(0.5f)
        .setMaxPerObjectLabelCount(3)
        .build()

// Multiple object detection in static images
val customObjectDetectorOptions =
        CustomObjectDetectorOptions.Builder(localModel)
        .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
        .enableMultipleObjects()
        .enableClassification()
        .setClassificationConfidenceThreshold(0.5f)
        .setMaxPerObjectLabelCount(3)
        .build()

val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)

Java

// Live detection and tracking
CustomObjectDetectorOptions customObjectDetectorOptions =
        new CustomObjectDetectorOptions.Builder(localModel)
                .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();

// Multiple object detection in static images
CustomObjectDetectorOptions customObjectDetectorOptions =
        new CustomObjectDetectorOptions.Builder(localModel)
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableMultipleObjects()
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();

ObjectDetector objectDetector =
    ObjectDetection.getClient(customObjectDetectorOptions);

אם יש לכם מודל באירוח מרוחק, תצטרכו לבדוק שהוא הורד לפני שמריצים אותו. אפשר לבדוק את הסטטוס של משימת הורדת המודל באמצעות ה-method isModelDownloaded() של מנהל המודלים.

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

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded ->
    val optionsBuilder =
        if (isDownloaded) {
            CustomObjectDetectorOptions.Builder(remoteModel)
        } else {
            CustomObjectDetectorOptions.Builder(localModel)
        }
    val customObjectDetectorOptions = optionsBuilder
            .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
            .enableClassification()
            .setClassificationConfidenceThreshold(0.5f)
            .setMaxPerObjectLabelCount(3)
            .build()
    val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener(new OnSuccessListener() {
        @Override
        public void onSuccess(Boolean isDownloaded) {
            CustomObjectDetectorOptions.Builder optionsBuilder;
            if (isDownloaded) {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(remoteModel);
            } else {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(localModel);
            }
            CustomObjectDetectorOptions customObjectDetectorOptions = optionsBuilder
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();
            ObjectDetector objectDetector =
                ObjectDetection.getClient(customObjectDetectorOptions);
        }
});

אם יש לכם רק מודל שמתארח מרחוק, צריך להשבית את הפונקציונליות שקשורה למודל – למשל הצגת באפור או הסתרה של חלק מממשק המשתמש – עד שמוודאים שהמודל הורד. לשם כך, אפשר לצרף מאזין ל-method download() של מנהל המודלים:

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

3. הכנת התמונה לקלט

יוצרים אובייקט InputImage מהתמונה. מזהה האובייקטים פועל ישירות מ-Bitmap, מ-NV21 ByteBuffer או מ-YUV_420_888 media.Image. מומלץ ליצור InputImage מהמקורות האלה אם יש לכם גישה ישירה לאחד מהם. אם תיצרו InputImage ממקורות אחרים, אנחנו נטפל בהמרה באופן פנימי עבורכם, ויכול להיות שהיא תהיה פחות יעילה.

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

באמצעות `media.Image`

כדי ליצור אובייקט InputImage מאובייקט media.Image, למשל כשמצלמים תמונה ממצלמת של מכשיר, צריך להעביר את האובייקט media.Image ואת סיבוב התמונה אל InputImage.fromMediaImage().

אם אתם משתמשים בספריית CameraX, המחלקות OnImageCapturedListener ו-ImageAnalysis.Analyzer תחשבות את ערך הסיבוב בשבילכם.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

אם אין לך ספריית מצלמה שמספקת את מידת הסיבוב של התמונה, אפשר לחשב אותה לפי מידת הסיבוב של המכשיר ולפי הכיוון של חיישן המצלמה במכשיר:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}MLKitVisionImage.kt

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

לאחר מכן, מעבירים את האובייקט media.Image ואת ערך מעלה הסיבוב לערך InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

שימוש ב-URI של קובץ

כדי ליצור אובייקט InputImage מ-URI של קובץ, יש להעביר את ההקשר של האפליקציה ואת ה-URI של הקובץ אל InputImage.fromFilePath(). המדיניות הזו שימושית כשמשתמשים ב-Intent של ACTION_GET_CONTENT כדי לבקש מהמשתמש לבחור תמונה מאפליקציית הגלריה.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}MLKitVisionImage.kt

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

נעשה שימוש ב-`ByteBuffer` או ב-`ByteArray`

כדי ליצור אובייקט InputImage מ-ByteBuffer או מ-ByteArray, קודם צריך לחשב את המעלות של סיבוב התמונה כפי שתואר קודם עבור קלט media.Image. לאחר מכן, יוצרים את האובייקט InputImage עם המאגר או המערך, יחד עם הגובה, הרוחב, פורמט קידוד הצבע ומידת הסיבוב של התמונה:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java

באמצעות `Bitmap`

כדי ליצור אובייקט InputImage מאובייקט Bitmap, צריך בהצהרה הבאה:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);MLKitVisionImage.java

התמונה מיוצגת על ידי אובייקט Bitmap יחד עם מעלות סיבוב.

4. הפעלת 'גלאי אובייקטים'

Kotlin

objectDetector
    .process(image)
    .addOnFailureListener(e -> {...})
    .addOnSuccessListener(results -> {
        for (detectedObject in results) {
          // ...
        }
    });

Java

objectDetector
    .process(image)
    .addOnFailureListener(e -> {...})
    .addOnSuccessListener(results -> {
        for (DetectedObject detectedObject : results) {
          // ...
        }
    });

הערה: אם משתמשים ב-API של CameraX, צריך לסגור את ה-ImageProxy בסיום השימוש, למשל על ידי הוספת OnCompleteListener ל-Task שמוחזר מ-method process. כדי לראות דוגמה, אפשר לעיין בשיעור VisionProcessorBase באפליקציה לדוגמה למתחילים.

5. קבלת מידע על אובייקטים מתויגים

אם הקריאה ל-process() תסתיים בהצלחה, רשימת ה-DetectedObject תועבר ל-event listener.

כל DetectedObject מכיל את המאפיינים הבאים:

תיבת תיחום Rect שמציין את מיקום האובייקט בתמונה.

מזהה לצורכי מעקב מספר שלם המזהה את האובייקט בתמונות שונות. ערך null ב-SINGLE_IMAGE_mode.

Labels (תוויות)

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

Kotlin

// The list of detected objects contains one item if multiple
// object detection wasn't enabled.
for (detectedObject in results) {
    val boundingBox = detectedObject.boundingBox
    val trackingId = detectedObject.trackingId
    for (label in detectedObject.labels) {
      val text = label.text
      val index = label.index
      val confidence = label.confidence
    }
}

Java

// The list of detected objects contains one item if multiple
// object detection wasn't enabled.
for (DetectedObject detectedObject : results) {
  Rect boundingBox = detectedObject.getBoundingBox();
  Integer trackingId = detectedObject.getTrackingId();
  for (Label label : detectedObject.getLabels()) {
    String text = label.getText();
    int index = label.getIndex();
    float confidence = label.getConfidence();
  }
}

הבטחת חוויית משתמש מעולה

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

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

בנוסף, עיינו באפליקציית התצוגה של ML Kit Material Design ובאוסף תבניות לתכונות שמבוססות על למידת מכונה ב-Material Design.

Improving performance

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

כשאתם משתמשים במצב סטרימינג באפליקציה בזמן אמת, לא כדאי להשתמש בזיהוי אובייקטים מרובים, מכיוון שרוב המכשירים לא יכולים ליצור קצבי פריימים מתאימים.
אם משתמשים ב-API של Camera או camera2, אפשר לווסת את הקריאות למזהים. אם מתפנה פריים חדש בזמן שהמזהה פועל, משחררים את הפריים הזה. כדי לראות דוגמה, אפשר לעיין בשיעור VisionProcessorBase באפליקציה לדוגמה למתחילים.
אם אתם משתמשים ב-CameraX API, עליכם לוודא ששיטת הלחיצה החוזרת מוגדרת לערך ברירת המחדל שלה ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. האפשרות הזו מבטיחה שרק תמונה אחת תישלח לניתוח בכל פעם. אם מופקות תמונות נוספות בזמן שהמנתח עמוס, הן יושמטו באופן אוטומטי ולא ימתינו בתור למשלוח. לאחר סגירת התמונה שנכללת בניתוח על ידי קריאה ל-ImageProxy.close(), תישלח התמונה האחרונה הבאה.
אם משתמשים בפלט של המזהה כדי ליצור שכבת-על של גרפיקה בתמונת הקלט, קודם צריך לקבל את התוצאה מ-ML Kit ואז לעבד את התמונה ואת שכבת-העל בשלב אחד. הפעולה הזו מעבדת את התצוגה על פני המסך פעם אחת בלבד לכל מסגרת קלט. כדי לראות דוגמה, אפשר לעיין בכיתות CameraSourcePreview ו- GraphicOverlay באפליקציה לדוגמה של 'מדריך למתחילים'.
אם משתמשים ב- Camera2 API, צריך לצלם תמונות בפורמט ImageFormat.YUV_420_888. אם משתמשים בגרסה הקודמת של Camera API, צריך לצלם תמונות בפורמט ImageFormat.NV21.

זיהוי, מעקב וסיווג של אובייקטים באמצעות מודל סיווג בהתאמה אישית ב-Android

אני רוצה לנסות

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

1. טעינת המודל

הגדרת מקור של מודל מקומי

Kotlin

Java

הגדרת מקור מודל שמתארח ב-Firebase

Kotlin

Java

Kotlin

Java

2. הגדרה של מזהה אובייקטים

Kotlin

Java

Kotlin

Java

Kotlin

Java

3. הכנת התמונה לקלט

באמצעות media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

שימוש ב-URI של קובץ

Kotlin

Java

נעשה שימוש ב-ByteBuffer או ב-ByteArray

Kotlin

Java

באמצעות Bitmap

Kotlin

Java

4. הפעלת 'גלאי אובייקטים'

Kotlin

Java

5. קבלת מידע על אובייקטים מתויגים

Kotlin

Java

הבטחת חוויית משתמש מעולה

Improving performance

באמצעות `media.Image`

נעשה שימוש ב-`ByteBuffer` או ב-`ByteArray`

באמצעות `Bitmap`