Rileva oggetti nelle immagini con un modello addestrato con AutoML su Android

Dopo aver addestrato il tuo modello utilizzando AutoML Vision Edge, puoi usarlo nella tua app per rilevare oggetti nelle immagini.

Esistono due modi per integrare i modelli addestrati da AutoML Vision Edge: raggruppa il modello inserendolo nella cartella degli asset dell'app. da Firebase in modo dinamico.

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 è necessario un progetto Firebase
Ospitato con Firebase
  • Ospita il modello caricandolo 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 è obbligatoria quando esegui il bundling del modello.

  2. Aggiungi le dipendenze per la libreria di attività TensorFlow Lite agli oggetti file gradle a livello di app, 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 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 nelle risorse il file del modello tflite con i metadati incorporati .

  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 sarà incluso nel pacchetto dell'app e sarà disponibile come asset non elaborato.

Configura l'origine di un modello ospitata da Firebase

Per utilizzare il modello ospitato in remoto, crea un oggetto RemoteModel, specificando il nome assegnato al modello al momento della pubblicazione:

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

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 utilizzare il modello.

Crea un rilevatore di oggetti dal modello

Dopo aver configurato le origini del modello, crea un oggetto ObjectDetector da uno alcune.

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

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 il tuo modello è ospitato in remoto, dovrai verificare che sia stato scaricato prima di eseguirlo. Puoi controllare lo stato del download del modello utilizzando il metodo isModelDownloaded() del gestore del modello.

Anche se devi solo confermarlo prima di eseguire il rilevatore di oggetti, sia un modello ospitato in remoto sia uno in bundle locale, di eseguire questo controllo durante la creazione di un'istanza del rilevatore di oggetti: rilevatore di oggetti dal modello remoto, se è stato scaricato, e dall'app modello di machine learning.

Java

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

Kotlin

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

        }

Se disponi solo di un modello ospitato in remoto, devi disattivare le relative funzionalità, ad esempio rendere non selezionabile o nascondere parte dell'interfaccia utente, fino a quando confermi che il modello è stato scaricato. Puoi farlo collegando un listener al metodo download() del gestore del modello.

Quando sai che il modello è stato scaricato, crea un rilevatore di oggetti 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

Quindi, per ogni immagine da etichettare, crea un oggetto TensorImage dal tuo dell'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 immagine non si trovano in un Bitmap, puoi caricare un array di pixel come mostrato in consulta la documentazione su TensorFlow.

3. Esegui il rilevatore di oggetti

Per rilevare oggetti in un'immagine, passa l'oggetto TensorImage all' Metodo detect() di ObjectDetector.

Java

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

Kotlin

val results = objectDetector.detect(image)

4. Ottieni informazioni sugli oggetti etichettati

Se l'operazione di rilevamento degli oggetti ha esito positivo, restituisce un elenco di Detection di oggetti strutturati. Ogni oggetto Detection rappresenta qualcosa che è stato rilevato nell' dell'immagine. Puoi ottenere il riquadro di delimitazione di ciascun 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 questi passaggi: linee guida per ottenere le migliori frequenze fotogrammi:

  • Limita le chiamate all'etichettatore delle immagini. Se un nuovo frame video diventa disponibile mentre l'etichettatrice delle immagini è in esecuzione, inseriscilo. Consulta VisionProcessorBase nell'app di esempio della guida rapida per un esempio.
  • Se stai utilizzando l'output dello strumento di etichettatura delle immagini per sovrapporre gli elementi grafici l'immagine di input, ottenere prima il risultato, quindi eseguire il rendering dell'immagine e la sovrapposizione in un solo passaggio. In questo modo, puoi visualizzare i contenuti solo una volta per ogni frame di input. Consulta CameraSourcePreview e GraphicOverlay nell'app di esempio della guida rapida per esempio.

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

    Se usi l'API Camera precedente, acquisisci le immagini in Formato ImageFormat.NV21.