Etichetta le immagini con un modello addestrato con AutoML su Android

L'API specifica per AutoML Vision Edge non è più disponibile. Utilizza invece l'API Custom Image Labeling, che ora supporta questi modelli in modo nativo. Se attualmente utilizzi questa API, segui le nostre istruzioni per la migrazione.

Dopo aver addestrato il tuo modello con AutoML Vision Edge, puoi utilizzarlo nella tua app per etichettare le immagini. Esistono due modi per integrare i modelli addestrati da AutoML Vision Edge: puoi raggruppare il modello inserendolo nella cartella degli asset dell'app oppure scaricarlo dinamicamente da Firebase.

Opzioni di raggruppamento dei modelli
Raggruppati nella tua app	Il modello fa parte dell'APK della tua app Il modello è disponibile immediatamente, anche quando il dispositivo Android è offline Non serve un progetto Firebase
Ospitato con Firebase	Ospita il modello caricandolo su Firebase Machine Learning Riduce le dimensioni dell'APK Il modello viene scaricato on demand Esegui il push degli aggiornamenti del modello senza ripubblicare l'app Facile test A/B con Firebase Remote Config Richiede un progetto Firebase

Prova

• Prova l'app di esempio per vedere un utilizzo di esempio di questa API.

Prima di iniziare

1. Nel file build.gradle a livello di progetto, assicurati di includere il Repository Maven di Google in entrambe le sezioni buildscript e allprojects.

2. Aggiungi le dipendenze per le librerie ML Kit Android al file gradle a livello di app del tuo modulo, che in genere è app/build.gradle: Per il raggruppamento di un modello con la tua app:

    dependencies {
      // ...
      // Image labeling feature with bundled automl model
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
    }
    

Per scaricare dinamicamente un modello da Firebase, aggiungi la dipendenza linkFirebase:

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
      implementation 'com.google.mlkit:linkfirebase:16.0.1'
    }
    

3. Se vuoi scaricare un modello, assicurati di aggiungere Firebase al tuo progetto Android se non l'hai ancora fatto. Questa operazione non è necessaria quando raggruppi il modello.

1. Carica il modello

Configura l'origine di un modello locale

Per raggruppare il modello con la tua app:

1. Estrai il modello e i relativi metadati dall'archivio ZIP che hai scaricato dalla console Firebase. Ti consigliamo di utilizzare i file mentre li hai scaricati, senza modifiche (inclusi i nomi dei file).

2. Includi il modello e i relativi file di metadati nel pacchetto dell'app:

a. Se non disponi di una cartella di asset nel progetto, creane una facendo clic con il tasto destro del mouse sulla cartella app/, quindi fai clic su Nuovo > Cartella > Cartella Asset.

b. Crea una sottocartella nella cartella degli asset che contenga i file del modello.

c. Copia i file model.tflite, dict.txt e manifest.json nella sottocartella (tutti e tre i file devono trovarsi nella stessa cartella).

3. Aggiungi quanto segue al file build.gradle dell'app per assicurarti che Gradle non comprima il file del modello durante la creazione dell'app:

    android {
        // ...
        aaptOptions {
            noCompress "tflite"
        }
    }
    

Il file del modello verrà incluso nel pacchetto dell'app e disponibile per ML Kit come asset non elaborato.

Nota: a partire dalla versione 4.1 del plug-in Android per Gradle, il file .tflite verrà aggiunto all'elenco noCompress per impostazione predefinita e quanto riportato sopra non è più necessario.

4. Crea l'oggetto LocalModel, specificando il percorso del file manifest del modello:

Kotlin

val localModel = AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build()

Java

AutoMLImageLabelerLocalModel localModel =
    new AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build();

Configura l'origine di un modello ospitato da Firebase

Per utilizzare il modello ospitato in remoto, crea un oggetto RemoteModel, specificando il nome assegnato al modello quando lo hai pubblicato:

Kotlin

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

Java

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

Poi avvia l'attività di download del modello, specificando le condizioni in base alle quali vuoi consentire il download. Se il modello non è presente sul dispositivo o se è disponibile una versione più recente del modello, l'attività scaricherà il modello in modo asincrono da 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.
            }
        });

Molte app avviano l'attività di download nel codice di inizializzazione, ma puoi farlo in qualsiasi momento prima di utilizzare il modello.

Crea un etichettatore di immagini dal tuo modello

Dopo aver configurato le origini del modello, crea un oggetto ImageLabeler da una di queste.

Se hai solo un modello pacchettizzato localmente, crea un etichettatore dall'oggetto AutoMLImageLabelerLocalModel e configura la soglia del punteggio di confidenza che vuoi richiedere (consulta Valutare il modello):

Kotlin

val autoMLImageLabelerOptions = AutoMLImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0)  // Evaluate your model in the Firebase console
                                // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

Java

AutoMLImageLabelerOptions autoMLImageLabelerOptions =
        new AutoMLImageLabelerOptions.Builder(localModel)
                .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                               // to determine an appropriate value.
                .build();
ImageLabeler labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

Se hai un modello ospitato in remoto, devi verificare che sia stato scaricato prima di eseguirlo. Puoi controllare lo stato dell'attività di download del modello utilizzando il metodo isModelDownloaded() del gestore dei modelli.

Anche se devi confermare questa azione solo prima di eseguire l'etichettatore, se hai sia un modello ospitato in remoto sia un modello in bundle localmente, potrebbe essere utile eseguire questo controllo quando crei un'istanza dell'etichettatore immagine: crea un etichettatore dal modello remoto se è stato scaricato, altrimenti dal modello locale.

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded -> 
    val optionsBuilder =
        if (isDownloaded) {
            AutoMLImageLabelerOptions.Builder(remoteModel)
        } else {
            AutoMLImageLabelerOptions.Builder(localModel)
        }
    // Evaluate your model in the Firebase console to determine an appropriate threshold.
    val options = optionsBuilder.setConfidenceThreshold(0.0f).build()
    val labeler = ImageLabeling.getClient(options)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                AutoMLImageLabelerOptions.Builder optionsBuilder;
                if (isDownloaded) {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(remoteModel);
                } else {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(localModel);
                }
                AutoMLImageLabelerOptions options = optionsBuilder
                        .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                                       // to determine an appropriate threshold.
                        .build();

                ImageLabeler labeler = ImageLabeling.getClient(options);
            }
        });

Se hai solo un modello ospitato in remoto, devi disabilitare le funzionalità correlate al modello, ad esempio rendere in grigio o nascondere parte dell'interfaccia utente fino a quando non confermi che il modello è stato scaricato. Puoi farlo collegando un listener al metodo download() del gestore dei modelli:

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.
            }
        });

2. Prepara l'immagine di input

Quindi, per ogni immagine da etichettare, crea un oggetto InputImage dall'immagine. L'etichettatore di immagini funziona più velocemente quando utilizzi un Bitmap o, se usi l'API camera2, un media.Image YUV_420_888, cosa consigliata quando possibile.

Puoi creare un oggetto InputImage da origini diverse, ognuna spiegata di seguito.

Utilizzo di un media.Image

Per creare un oggetto InputImage da un oggetto media.Image, ad esempio quando acquisisci un'immagine dalla fotocamera di un dispositivo, trasmetti l'oggetto media.Image e la rotazione dell'immagine a InputImage.fromMediaImage().

Se usi la libreria FotocameraX, le classi OnImageCapturedListener e ImageAnalysis.Analyzer calcolano automaticamente il valore di rotazione.

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
          // ...
        }
    }
}

Se non utilizzi una raccolta della fotocamera che fornisce il grado di rotazione dell'immagine, puoi calcolarlo dal grado di rotazione del dispositivo e dall'orientamento del sensore della fotocamera nel dispositivo:

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;
}

Quindi, passa l'oggetto media.Image e il valore del grado di rotazione a InputImage.fromMediaImage():

Kotlin

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

Java

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

Utilizzo dell'URI di un file

Per creare un oggetto InputImage da un URI del file, passa il contesto dell'app e l'URI del file a InputImage.fromFilePath(). Questo è utile quando utilizzi un intent ACTION_GET_CONTENT per richiedere all'utente di selezionare un'immagine dall'app Galleria.

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();
}

Utilizzo di ByteBuffer o ByteArray

Per creare un oggetto InputImage da un oggetto ByteBuffer o ByteArray, calcola prima il grado di rotazione dell'immagine come descritto in precedenza per l'input media.Image. Quindi, crea l'oggetto InputImage con il buffer o l'array, insieme ad altezza, larghezza, formato di codifica del colore e grado di rotazione dell'immagine:

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

Utilizzo di un Bitmap

Per creare un oggetto InputImage da un oggetto Bitmap, effettua la seguente dichiarazione:

Kotlin

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

Java

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

L'immagine è rappresentata da un oggetto Bitmap insieme con i gradi di rotazione.

3. Esegui l'etichettatore per le immagini

Per etichettare gli oggetti in un'immagine, passa l'oggetto image al metodo process() di ImageLabeler.

Kotlin

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
ImageLabelingActivity.kt

Java

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });
ImageLabelingActivity.java

Nota: se utilizzi l'API CameraX, assicurati di chiudere ImageProxy quando hai finito di utilizzarlo, ad es. aggiungendo OnCompleteListener all'API Task restituita dal metodo process. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.

4. recupera informazioni sugli oggetti etichettati

Se l'operazione di etichettatura delle immagini ha esito positivo, un elenco di oggetti ImageLabel viene passato al listener di successi. Ogni oggetto ImageLabel rappresenta un elemento etichettato nell'immagine. Puoi ottenere la descrizione del testo di ogni etichetta, il punteggio di confidenza della corrispondenza e l'indice della corrispondenza. Ad esempio:

Kotlin

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}
ImageLabelingActivity.kt

Java

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}
ImageLabelingActivity.java

Suggerimenti per migliorare il rendimento in tempo reale

Se vuoi etichettare le immagini in un'applicazione in tempo reale, segui queste linee guida per ottenere le migliori frequenze fotogrammi:

• Se utilizzi l'API Camera o camera2, limita le chiamate all'etichettatore delle immagini. Se diventa disponibile un nuovo fotogramma video mentre è in esecuzione l'etichettatore immagine, rilascialo. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.
• Se utilizzi l'API CameraX, assicurati che la strategia di contropressione sia impostata sul valore predefinito ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Questo garantisce che verrà inviata una sola immagine alla volta per l'analisi. Se vengono prodotte altre immagini quando l'analizzatore è occupato, queste verranno eliminate automaticamente e non verranno messe in coda per la consegna. Una volta chiusa l'immagine analizzata chiamando ImageProxy.close(), verrà pubblicata l'immagine più recente.
• Se utilizzi l'output dell'etichettatore immagine per sovrapporre gli elementi grafici all'immagine di input, recupera prima il risultato da ML Kit, quindi esegui il rendering dell'immagine e dell'overlay in un unico passaggio. Il rendering viene eseguito sulla superficie del display solo una volta per ogni frame di input. Per un esempio, consulta le classi CameraSourcePreview e GraphicOverlay nell'app di esempio della guida rapida.
• Se utilizzi l'API Camera2, acquisisci immagini in formato ImageFormat.YUV_420_888. Se utilizzi la versione precedente dell'API Camera, acquisisci immagini in formato ImageFormat.NV21.