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

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

Opzioni di raggruppamento dei modelli
Inclusi nell'app
  • Il modello fa parte dell'APK della tua app
  • Il modello è disponibile immediatamente, anche quando il dispositivo Android è offline
  • Non è necessario 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
  • Test A/B semplici con Firebase Remote Config
  • Richiede un progetto 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 è necessaria quando raggruppi il modello.

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

    Per raggruppare un modello con l'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 degli asset, creane una facendo clic con il tasto destro del mouse sulla cartella app/, quindi facendo clic su Nuovo > Cartella > Cartella degli asset.
    2. Copia il file del modello tflite con i metadati incorporati nella cartella assets.

  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 sarà disponibile come asset non elaborato.

Configura un'origine modello ospitata da Firebase

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

Java

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

Kotlin

// Specify the name you assigned when you deployed the model.
val remoteModel =
    FirebaseCustomRemoteModel.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 è sul dispositivo o se è disponibile una versione più recente, l'attività scaricherà in modo asincrono il modello da Firebase:

Java

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

Kotlin

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.

Crea un rilevatore di oggetti dal tuo modello

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

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

Java

// 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);

Kotlin

// 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, devi verificare che sia stato scaricato prima di eseguirlo. Puoi controllare lo stato del download del modello utilizzando il metodo isModelDownloaded() di Model Manager.

Anche se devi confermare questa operazione solo prima di eseguire il rilevatore di oggetti, se hai sia un modello ospitato in remoto sia un modello incluso localmente, potrebbe essere utile eseguire questo controllo quando istanzi il rilevatore di oggetti: crea un rilevatore di oggetti dal modello remoto se è stato scaricato e dal modello locale in caso contrario.

Java

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

Kotlin

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

        }

Se hai solo un modello ospitato in remoto, devi disattivare la funzionalità correlata al modello, ad esempio disattivare o nascondere parte della tua UI, finché non confermi che il modello è stato scaricato. Puoi farlo collegando un listener al metodo download() del gestore dei modelli.

Una volta scaricato il modello, crea un rilevatore di oggetti dal file del modello:

Java

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

Kotlin

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:

Java

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

Se i dati delle immagini 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.

Java

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

Kotlin

val results = objectDetector.detect(image)

4. Ricevere informazioni sugli oggetti etichettati

Se l'operazione di rilevamento degli oggetti ha esito positivo, viene restituito un elenco di oggetti Detection. Ogni oggetto Detection rappresenta qualcosa che è stato rilevato nell'immagine. Puoi ottenere il riquadro di delimitazione di ogni oggetto e le relative etichette.

Ad esempio:

Java

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

Kotlin

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 i migliori framerate:

  • Limita le chiamate al programma di etichettatura delle immagini. Se diventa disponibile un nuovo frame video mentre è in esecuzione l'etichettatore di immagini, rilascia il frame. Per un esempio, consulta la classe VisionProcessorBase nell'app di esempio della guida rapida.
  • Se utilizzi l'output dell'etichettatore di immagini per sovrapporre elementi grafici all'immagine di input, ottieni prima il risultato, quindi esegui il rendering dell'immagine e la sovrapposizione in un unico passaggio. In questo modo, 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 di avvio rapido.

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

    Se utilizzi la versione precedente dell'API Camera, acquisisci immagini in formato ImageFormat.NV21.