Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Etichetta le immagini con un modello addestrato con AutoML su Android

Dopo aver addestrato il tuo modello utilizzando 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 della tua app o puoi scaricarlo dinamicamente da Firebase.

Opzioni di raggruppamento dei modelli
In bundle nell'app	Il modello fa parte dell'APK della tua app Il modello è disponibile immediatamente, anche quando il dispositivo Android è offline Nessun progetto Firebase richiesto
Ospitato con Firebase	Ospita il modello caricandolo su Firebase Machine Learning Riduce le dimensioni dell'APK Il modello viene scaricato on demand Invia aggiornamenti del modello senza ripubblicare l'app Test A/B semplici con Firebase Remote Config Richiede un progetto Firebase

Prova

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

Prima di iniziare

1. Nel file build.gradle a livello di progetto, assicurati di includere il repository Maven di Google nelle sezioni buildscript e allprojects.

2. Aggiungi le dipendenze per le librerie Android di ML Kit al file gradle a livello di app del modulo, che di solito è app/build.gradle: Per raggruppare 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 già fatto. Questa operazione non è necessaria quando raggruppi il modello.

1. Carica il modello

Configura un'origine del modello locale

Per raggruppare il modello con la tua app:

1. Estrai il modello e i relativi metadati dal file ZIP scaricato dalla console Firebase. Ti consigliamo di utilizzare i file così come li hai scaricati, senza modifiche (compresi i nomi dei file).

2. Includi il modello e i relativi file di metadati nel pacchetto applicativo:

a. Se nel progetto non è presente una cartella degli asset, creane una facendo clic con il tasto destro del mouse sulla cartella app/, quindi su Nuovo > Cartella > Cartella degli asset.

b. Crea una sottocartella all'interno della cartella degli asset per contenere 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 della tua 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 applicativo e sarà disponibile per ML Kit come asset non elaborato.

Nota: a partire dalla versione 4.1 del plug-in Android per Gradle, .tflite verrà aggiunto all'elenco noCompress per impostazione predefinita e quanto 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 un'origine del modello ospitata su Firebase

Per utilizzare il modello ospitato da remoto, crea un oggetto RemoteModel, specificando il nome che hai 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 cui vuoi consentire il download. Se il modello non è sul dispositivo o se è disponibile una versione più recente, l'attività scaricherà il modello da Firebase in modo asincrono:

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 dover 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 in bundle locale, crea un etichettatore dal tuo oggetto AutoMLImageLabelerLocalModel e configura la soglia del punteggio di affidabilità che vuoi richiedere (consulta Valuta 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 da 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 confermarlo solo prima di eseguire l'etichettatore, se hai sia un modello ospitato da remoto sia un modello in bundle locale, potrebbe avere senso eseguire questo controllo durante la creazione dell'istanza dell'etichettatore di immagini: crea un etichettatore dal modello remoto se è stato scaricato e dal modello locale in caso contrario.

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 da remoto, devi disattivare le funzionalità correlate al modello, ad esempio disattivare o nascondere parte della UI, finché non confermi che il modello è stato scaricato. Puoi farlo collegando un listener al metodo download() del gestore del modello:

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 che vuoi etichettare, crea un oggetto InputImage dall'immagine. L'etichettatore di immagini viene eseguito più velocemente quando utilizzi un Bitmap o, se utilizzi l'API camera2, un media.Image YUV_420_888, che sono consigliati quando possibile.

Puoi creare un oggetto InputImage da diverse origini, ognuna delle quali è 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, passa l'oggetto media.Image e la rotazione dell'immagine a InputImage.fromMediaImage().

Se utilizzi la libreria CameraX, le classi OnImageCapturedListener e ImageAnalysis.Analyzer calcolano il valore di rotazione per te.

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 libreria della fotocamera che ti 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;
}

Poi, 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 di un URI file

Per creare un oggetto InputImage da un URI file, passa il contesto dell'app e l'URI file a InputImage.fromFilePath(). Questo è utile quando utilizzi un intent ACTION_GET_CONTENT per chiedere all'utente di selezionare un'immagine dalla sua app di 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 un `ByteBuffer` o `ByteArray`

Per creare un oggetto InputImage da un ByteBuffer o un ByteArray, calcola prima il grado di rotazione dell'immagine come descritto in precedenza per l'input media.Image. Poi, crea l'oggetto InputImage con il buffer o l'array, insieme all'altezza, alla larghezza, al formato di codifica dei colori e al 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 ai gradi di rotazione.

3. Esegui l'etichettatore di 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 utilizzarla, ad esempio aggiungendo un OnCompleteListener a Task restituito dal metodo process. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.

4. Ricevi informazioni sugli oggetti etichettati

Se l'operazione di etichettatura delle immagini va a buon fine, un elenco di oggetti ImageLabel viene passato al listener di esito positivo. Ogni oggetto ImageLabel rappresenta un elemento etichettato nell'immagine. Puoi ottenere la descrizione testuale di ogni etichetta, il punteggio di affidabilità 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 le prestazioni in tempo reale

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

Se utilizzi l'API Camera o camera2, limita le chiamate all'etichettatore di immagini. Se diventa disponibile un nuovo frame video mentre l'etichettatore di immagini è in esecuzione, elimina il frame. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.
Se utilizzi l'API CameraX, assicurati che la strategia di backpressure sia impostata sul valore predefinito ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. In questo modo, viene inviata per l'analisi una sola immagine alla volta. Se vengono prodotte più 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à visualizzata l'immagine successiva più recente.
Se utilizzi l'output dell'etichettatore di immagini per sovrapporre elementi grafici all'immagine di input, ottieni prima il risultato da ML Kit, quindi esegui il rendering dell'immagine e dell'overlay in un unico passaggio. Il rendering sulla superficie di visualizzazione viene eseguito una sola 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 le immagini in formato ImageFormat.YUV_420_888. Se utilizzi l'API Camera precedente, acquisisci le immagini in formato ImageFormat.NV21.

Etichetta le immagini con un modello addestrato con AutoML su Android

Prova

Prima di iniziare

1. Carica il modello

Configura un'origine del modello locale

Kotlin

Java

Configura un'origine del modello ospitata su Firebase

Kotlin

Java

Kotlin

Java

Crea un etichettatore di immagini dal tuo modello

Kotlin

Java

Kotlin

Java

Kotlin

Java

2. Prepara l'immagine di input

Utilizzo di un media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

Utilizzo di un URI file

Kotlin

Java

Utilizzo di un ByteBuffer o ByteArray

Kotlin

Java

Utilizzo di un Bitmap

Kotlin

Java

3. Esegui l'etichettatore di immagini

Kotlin

Java

4. Ricevi informazioni sugli oggetti etichettati

Kotlin

Java

Suggerimenti per migliorare le prestazioni in tempo reale

Utilizzo di un `media.Image`

Utilizzo di un `ByteBuffer` o `ByteArray`

Utilizzo di un `Bitmap`