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 raggruppare il modello inserendolo nella cartella degli asset dell'app o 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 di attività TensorFlow Lite 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

Configura un'origine del 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 degli asset.

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 asset non elaborato.

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 dell'attività di download del modello utilizzando il metodo isModelDownloaded() del gestore modelli.

Anche se devi confermare questa operazione solo prima di eseguire il rilevatore di oggetti, se hai sia un modello ospitato in remoto che un modello in bundle locale, potrebbe avere senso eseguire questo controllo quando si crea un'istanza del rilevatore di oggetti: creare un rilevatore di oggetti dal modello remoto, se è stato scaricato, e altrimenti dal modello locale.

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

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

        }

Se disponi solo di un modello ospitato in remoto, devi disabilitare la funzionalità relativa al modello, ad esempio rendere in grigio o nascondere parte della UI, fino a quando non confermi che il modello è stato scaricato. Per farlo, puoi collegare un listener al metodo download() del gestore modelli.

Quando hai verificato 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 immagine non si trovano in un Bitmap, puoi caricare un array di pixel come mostrato nei documenti 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 ha esito positivo, 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 diventa disponibile un nuovo frame video mentre è in esecuzione l'etichettatore delle immagini, rilascialo. 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.