Rileva oggetti nelle immagini con un modello addestrato su 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 scaricarlo dinamicamente da Firebase.

Opzioni di raggruppamento dei modelli
In bundle nella tua app
  • Il modello fa parte dell'APK della tua app
  • Il modello è immediatamente disponibile, 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 su richiesta
  • Invia aggiornamenti del modello senza ripubblicare la tua app
  • Test A/B semplici con Firebase Remote Config
  • Richiede un progetto Firebase

Prima di iniziare

  1. Se desideri scaricare un modello , assicurati di aggiungere Firebase al tuo progetto Android , se non l'hai già fatto. Ciò non è necessario quando si raggruppa il modello.

  2. Aggiungi le dipendenze per la libreria TensorFlow Lite Task al file gradle a livello di app del tuo modulo, che di solito è 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. Caricare il modello

Configurare un'origine del modello locale

Per raggruppare il modello con la tua app:

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

  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 dell'app e sarà disponibile come risorsa non elaborata.

Configura un'origine del modello ospitato 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:

Giava

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

Avvia quindi l'attività di download del modello, specificando le condizioni alle quali desideri consentire il download. Se il modello non è presente sul dispositivo o se è disponibile una versione più recente del modello, l'attività scaricherà in modo asincrono il modello da Firebase:

Giava

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 uno di essi.

Se disponi solo di un modello raggruppato localmente, crea semplicemente un rilevatore di oggetti dal file del modello e configura la soglia del punteggio di confidenza che desideri richiedere (vedi Valuta il tuo modello ):

Giava

// 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 disponi di un modello ospitato in remoto, dovrai verificare che sia stato scaricato prima di eseguirlo. È possibile verificare lo stato dell'attività di download del modello utilizzando il metodo isModelDownloaded() del gestore modelli.

Anche se devi solo confermarlo prima di eseguire il rilevatore di oggetti, se disponi sia di un modello ospitato in remoto che di un modello raggruppato localmente, potrebbe avere senso eseguire questo controllo quando istanzia il rilevatore di oggetti: crea un rilevatore di oggetti dal rilevatore di oggetti model se è stato scaricato e dal modello locale altrimenti.

Giava

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, dovresti disabilitare le funzionalità relative al modello, ad esempio disattivare o nascondere parte della tua interfaccia utente, finché non confermi che il modello è stato scaricato. Puoi farlo collegando un ascoltatore al metodo download() del gestore del modello.

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

Giava

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. Preparare l'immagine di input

Quindi, per ogni immagine che desideri etichettare, crea un oggetto TensorImage dalla tua immagine. Puoi creare un oggetto TensorImage da una Bitmap utilizzando il metodo fromBitmap :

Giava

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

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

3. Eseguire il rilevatore di oggetti

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

Giava

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 oggetti Detection . Ogni oggetto Detection rappresenta qualcosa che è stato rilevato nell'immagine. Puoi ottenere il riquadro di delimitazione di ogni oggetto e le sue etichette.

Per esempio:

Giava

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 le prestazioni in tempo reale

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

  • Limita le chiamate all'etichettatore di immagini. Se un nuovo fotogramma video diventa disponibile mentre l'etichettatrice di immagini è in esecuzione, rilascia il fotogramma. Per un esempio, vedi la classe VisionProcessorBase nell'app di esempio di avvio rapido.
  • Se stai utilizzando l'output dell'etichettatore di immagini per sovrapporre la grafica all'immagine di input, ottieni prima il risultato, quindi esegui il rendering dell'immagine e della sovrapposizione in un unico passaggio. In questo modo, viene eseguito il rendering sulla superficie di visualizzazione solo una volta per ciascun fotogramma di input. Per un esempio, consulta le classi CameraSourcePreview e GraphicOverlay nell'app di esempio di avvio rapido.

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

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