Rileva oggetti nelle 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 rilevare gli oggetti nelle immagini.

Esistono due modi per integrare i modelli addestrati da AutoML Vision Edge: puoi aggregare il modello inserendolo nella cartella delle risorse dell'app oppure puoi scaricarlo dinamicamente da Firebase.

Prima di iniziare

1. Se vuoi scaricare un modello, assicurati di aggiungere Firebase al tuo progetto Android, se non l'hai già fatto. Questa operazione non è obbligatoria quando esegui il bundling del modello.

2. Aggiungi le dipendenze per la libreria TensorFlow Lite Task al file Gradle a livello di app del tuo modulo, che in genere è app/build.gradle:

   Per raggruppare un modello con la tua app:

   dependencies {
     // ...
     // Object detection with a bundled Auto ML model
     implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly-SNAPSHOT'
   }
   

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

   dependencies {
     // ...
     // Object detection with an Auto ML model deployed to Firebase
     implementation platform('com.google.firebase:firebase-bom:26.1.1')
     implementation 'com.google.firebase:firebase-ml-model-interpreter'
   
     implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly'
   }
   

1. Carica il modello

Configurare un'origine modello locale

Per raggruppare il modello con l'app:

1. Estrai il modello dall'archivio ZIP scaricato dalla console Google Cloud.
2. Includi il modello nel pacchetto dell'app:
   1. Se nel progetto non è presente una cartella di asset, creane una facendo clic con il tasto destro del mouse sulla cartella app/, quindi su Nuovo > Cartella > Cartella asset.
   2. Copia il file del modello tflite con i metadati incorporati nella cartella delle risorse.

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

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

   Il file del modello verrà incluso nel pacchetto dell'app e sarà disponibile come risorsa non elaborata.

Configurare un'origine modello ospitata su Firebase

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

// Specify the name you assigned when you deployed the model.
FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();

// Specify the name you assigned when you deployed the model.
val remoteModel =
    FirebaseCustomRemoteModel.Builder("your_model_name").build()

Quindi, 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à lo scarica in modo asincrono da Firebase:

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

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

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

Creare un rilevatore di oggetti dal modello

Dopo aver configurato le origini del modello, crea un oggetto ObjectDetector da una di esse.

Se hai solo un modello in bundle locale, crea un rilevatore di oggetti dal tuo file modello e configura la soglia del punteggio di confidenza che vuoi richiedere (vedi Valutare il modello):

// Initialization
ObjectDetectorOptions options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud console
                           // to determine an appropriate value.
    .build();
ObjectDetector objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options);

// Initialization
val options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud console
                           // to determine an appropriate value.
    .build()
val objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options)

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

Anche se devi confermarlo solo prima di eseguire il rilevamento degli oggetti, se hai sia un modello ospitato in remoto sia un modello in bundle locale, potrebbe essere sensato eseguire questo controllo durante l'inizializzazione del rilevamento degli oggetti: crea un rilevatore di oggetti dal modello remoto se è stato scaricato e dal modello locale in caso contrario.

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener<Boolean>() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
            }
        });

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener { success ->

        }

Se hai solo un modello ospitato in remoto, devi disattivare le funzionalità correlate al modello, ad esempio disattivare o nascondere parte dell'interfaccia utente, finché non confermi che il modello è stato scaricato. A tal fine, puoi associare un ascoltatore al metodo download() del gestore del modello.

Una volta che sai che il modello è stato scaricato, crea un rilevatore di oggetti dal file del modello:

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnCompleteListener(new OnCompleteListener<File>() {
            @Override
            public void onComplete(@NonNull Task<File> task) {
                File modelFile = task.getResult();
                if (modelFile != null) {
                    ObjectDetectorOptions options = ObjectDetectorOptions.builder()
                            .setScoreThreshold(0)
                            .build();
                    objectDetector = ObjectDetector.createFromFileAndOptions(
                            getApplicationContext(), modelFile.getPath(), options);
                }
            }
        });

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnSuccessListener { modelFile ->
            val options = ObjectDetectorOptions.builder()
                    .setScoreThreshold(0f)
                    .build()
            objectDetector = ObjectDetector.createFromFileAndOptions(
                    applicationContext, modelFile.path, options)
        }

2. Prepara l'immagine di input

Poi, per ogni immagine che vuoi etichettare, crea un oggetto TensorImage dall'immagine. Puoi creare un oggetto TensorImage da un Bitmap utilizzando il metodo fromBitmap:

TensorImage image = TensorImage.fromBitmap(bitmap);

val image = TensorImage.fromBitmap(bitmap)

Se i dati dell'immagine non sono in un Bitmap, puoi caricare un array di pixel come mostrato nella documentazione di TensorFlow Lite.

3. Esegui il rilevatore di oggetti

Per rilevare gli oggetti in un'immagine, passa l'oggetto TensorImage al metodo detect() di ObjectDetector.

List<Detection> results = objectDetector.detect(image);

val results = objectDetector.detect(image)

4. Ricevere informazioni sugli oggetti etichettati

Se l'operazione di rilevamento degli oggetti va a buon fine, restituisce un elenco di oggetti Detection. Ogni oggetto Detection rappresenta un elemento rilevato nell'immagine. Puoi ottenere il riquadro di delimitazione e le etichette di ogni oggetto.

Ad esempio:

for (Detection result : results) {
    RectF bounds = result.getBoundingBox();
    List<Category> labels = result.getCategories();
}

for (result in results) {
    val bounds = result.getBoundingBox()
    val labels = result.getCategories()
}

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 frame:

• Regola le chiamate all'etichettatore delle immagini. Se un nuovo frame video diventa disponibile mentre l'etichettatrice delle immagini è in esecuzione, inseriscilo. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.
• Se utilizzi l'output dell'etichettatore di immagini per sovrapporre la grafica all'immagine di input, ottieni prima il risultato, poi esegui il rendering dell'immagine e la sovrapposizione in un unico passaggio. In questo modo, esegui il rendering sulla superficie di visualizzazione solo una volta per ogni frame di input. Per un esempio, consulta le classi CameraSourcePreview e GraphicOverlay nell'app di esempio della guida di avvio rapido.

• Se utilizzi l'API Camera2, acquisisci le immagini in formato ImageFormat.YUV_420_888.

  Se utilizzi la precedente API Camera, acquisisci le immagini in formato ImageFormat.NV21.