Etichetta le immagini con un modello addestrato ad AutoML su Android

Dopo aver allena il proprio modello utilizzando AutoML Vision Bordo , è possibile utilizzarlo nella vostra app per etichettare le immagini.

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

Opzioni di raggruppamento del modello
In bundle nella tua app
  • Il modello fa parte dell'APK della tua app
  • Il modello è subito disponibile, anche quando il dispositivo Android è offline
  • Non c'è bisogno di un progetto Firebase
Ospitato con Firebase
  • Host il modello caricandolo di Firebase Machine Learning
  • Riduce le dimensioni dell'APK
  • Il modello si scarica su richiesta
  • Invia gli aggiornamenti del modello senza ripubblicare la tua app
  • Easy A / B test con Firebase Remote Config
  • Richiede un progetto Firebase

Prima di iniziare

  1. Aggiungere le dipendenze per le librerie ML Kit per Android a livello di file app Gradle del modulo, che di solito è app/build.gradle :

    Per associare un modello alla tua app:

    dependencies {
      // ...
      // Image labeling feature with bundled automl model
      implementation 'com.google.mlkit:image-labeling-custom:16.3.1'
    }
    

    Per scaricare in modo dinamico un modello da Firebase, aggiungere il linkFirebase dipendenze:

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-custom:16.3.1'
      implementation 'com.google.mlkit:linkfirebase:16.1.0'
    }
    
  2. Se volete scaricare un modello, assicurati di aggiungere Firebase al progetto Android , se non l'avete già fatto. Questo non è necessario quando si raggruppa il modello.

1. Carica il modello

Configura una sorgente del modello locale

Per raggruppare il modello con la tua app:

  1. Estrai il modello e i relativi metadati dall'archivio zip che hai scaricato dalla console Firebase. Ti consigliamo di utilizzare i file così come li hai scaricati, senza modifiche (compresi i nomi dei file).

  2. Includi il tuo modello e i relativi file di metadati nel pacchetto dell'app:

    1. Se non si dispone di un patrimonio cartella nel progetto, crearne uno facendo clic destro l' app/ Nuovo> Cartella> Risorse Cartella, quindi facendo clic su.
    2. Crea una sottocartella nella cartella delle risorse per contenere i file del modello.
    3. Copiare i file model.tflite , dict.txt , e manifest.json alla sottocartella (tutte e tre le file deve essere nella stessa cartella).
  3. Aggiungere la seguente per la vostra applicazione build.gradle file per assicurarsi Gradle non comprime il file del modello quando si costruisce l'applicazione:

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

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

  4. Creare LocalModel oggetto, specificando il percorso del file modello di manifesto:

    Giava

    AutoMLImageLabelerLocalModel localModel =
        new AutoMLImageLabelerLocalModel.Builder()
            .setAssetFilePath("manifest.json")
            // or .setAbsoluteFilePath(absolute file path to manifest file)
            .build();
    

    Kotlin

    val localModel = LocalModel.Builder()
        .setAssetManifestFilePath("manifest.json")
        // or .setAbsoluteManifestFilePath(absolute file path to manifest file)
        .build()
    

Configurare un'origine del modello ospitata da Firebase

Per utilizzare il modello remoto-hosted, creare un CustomRemoteModel oggetto, specificando il nome assegnato al modello quando pubblicò:

Giava

// Specify the name you assigned in the Firebase console.
FirebaseModelSource firebaseModelSource =
    new FirebaseModelSource.Builder("your_model_name").build();
CustomRemoteModel remoteModel =
    new CustomRemoteModel.Builder(firebaseModelSource).build();

Kotlin

// Specify the name you assigned in the Firebase console.
val firebaseModelSource = FirebaseModelSource.Builder("your_model_name")
    .build()
val remoteModel = CustomRemoteModel.Builder(firebaseModelSource).build()

Quindi, avviare l'attività di download del modello, specificando le condizioni in base alle quali si desidera consentire il download. Se il modello non è 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'etichettatrice di immagini dal tuo modello

Dopo aver configurato le fonti modello, creare un ImageLabeler oggetto da uno di loro.

Se avete solo un modello a livello locale in bundle, basta creare un'etichettatrice dal tuo CustomImageLabelerOptions oggetto e configurare la soglia di punteggio di confidenza si desidera richiedere (vedi Valutare il vostro modello ):

Giava

CustomImageLabelerOptions customImageLabelerOptions = new CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.0f)  // Evaluate your model in the Cloud console
                                   // to determine an appropriate value.
    .build();
ImageLabeler labeler = ImageLabeling.getClient(customImageLabelerOptions);

Kotlin

val customImageLabelerOptions = CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.0f)  // Evaluate your model in the Cloud console
                                   // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(customImageLabelerOptions)

Se disponi di un modello ospitato in remoto, dovrai verificare che sia stato scaricato prima di eseguirlo. È possibile controllare lo stato del compito modello di scaricare utilizzando il modello del gestore isModelDownloaded() metodo.

Anche se devi solo confermare questo prima di eseguire l'etichettatrice, se hai sia un modello ospitato in remoto che un modello in bundle localmente, potrebbe avere senso eseguire questo controllo quando si crea un'istanza dell'etichettatrice di immagini: creare un'etichettatrice dal modello remoto se è stato scaricato, altrimenti dal modello locale.

Giava

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener<Boolean>() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                CustomImageLabelerOptions.Builder optionsBuilder;
                if (isDownloaded) {
                    optionsBuilder = new CustomImageLabelerOptions.Builder(remoteModel);
                } else {
                    optionsBuilder = new CustomImageLabelerOptions.Builder(localModel);
                }
                CustomImageLabelerOptions options = optionsBuilder
                        .setConfidenceThreshold(0.0f)  // Evaluate your model in the Cloud console
                                                       // to determine an appropriate threshold.
                        .build();

                ImageLabeler labeler = ImageLabeling.getClient(options);
            }
        });

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded ->
        val optionsBuilder =
            if (isDownloaded) {
                CustomImageLabelerOptions.Builder(remoteModel)
            } else {
                CustomImageLabelerOptions.Builder(localModel)
            }
        // Evaluate your model in the Cloud console to determine an appropriate threshold.
        val options = optionsBuilder.setConfidenceThreshold(0.0f).build()
        val labeler = ImageLabeling.getClient(options)
}

Se disponi solo di un modello ospitato in remoto, devi disabilitare la funzionalità relativa al modello, ad esempio disattivare o nascondere parte dell'interfaccia utente, finché non confermi che il modello è stato scaricato. È possibile farlo collegando un ascoltatore al modello del gestore download() Metodo:

Giava

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

2. Preparare l'immagine di input

Poi, per ogni immagine che si desidera assegnare un nome, creare un InputImage oggetto dalla vostra immagine. L'etichettatrice immagine corre più veloce quando si utilizza un Bitmap o, se si utilizza l'API camera2, un YUV_420_888 media.Image , che sono raccomandati quando possibile.

È possibile creare un InputImage da fonti diverse, ciascuna è la seguente.

Utilizzando un media.Image

Per creare un InputImage oggetto da un media.Image oggetto, come ad esempio quando si cattura un'immagine da fotocamera di un dispositivo, passare il media.Image oggetto e la rotazione dell'immagine a InputImage.fromMediaImage() .

Se si utilizza la CameraX biblioteca, le OnImageCapturedListener e ImageAnalysis.Analyzer classi calcolare il valore di rotazione per voi.

Giava

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        if (imageProxy == null || imageProxy.getImage() == null) {
            return;
        }
        Image mediaImage = imageProxy.getImage();
        InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees);
        // Pass image to an ML Kit Vision API
        // ...
    }
}

Kotlin+KTX

private class YourImageAnalyzer : ImageAnalysis.Analyzer {
    override fun analyze(imageProxy: ImageProxy?) {
        val mediaImage = imageProxy?.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Se non utilizzi una libreria della fotocamera che fornisce il grado di rotazione dell'immagine, puoi calcolarlo dal grado di rotazione del dispositivo e dall'orientamento del sensore della fotocamera nel dispositivo:

Giava

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 90);
    ORIENTATIONS.append(Surface.ROTATION_90, 0);
    ORIENTATIONS.append(Surface.ROTATION_180, 270);
    ORIENTATIONS.append(Surface.ROTATION_270, 180);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, Context context)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}

Kotlin+KTX

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, context: Context): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}

Quindi, passare l' media.Image oggetto e il valore in gradi di rotazione a InputImage.fromMediaImage() :

Giava

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Kotlin+KTX

val image = InputImage.fromMediaImage(mediaImage, rotation)

Utilizzo di un file URI

Per creare un InputImage oggetto da un file URI, passare il contesto applicazione e file URI per InputImage.fromFilePath() . Questo è utile quando si utilizza un ACTION_GET_CONTENT intento di richiedere all'utente di selezionare un'immagine da loro galleria app.

Giava

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

Kotlin+KTX

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}

Utilizzando un ByteBuffer o ByteArray

Per creare un InputImage oggetto da una ByteBuffer o un ByteArray , prima calcolare il grado di rotazione dell'immagine come precedentemente descritto per media.Image ingresso. Quindi, creare l' InputImage oggetto con il tampone o matrice, insieme con l'altezza dell'immagine, larghezza, formato di codifica del colore, e il grado di rotazione:

Giava

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

Kotlin+KTX

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

Utilizzando un Bitmap

Per creare un InputImage oggetto da un Bitmap oggetti, fare la seguente dichiarazione:

Giava

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);

Kotlin+KTX

val image = InputImage.fromBitmap(bitmap, 0)

L'immagine è rappresentata da un Bitmap insieme oggetto con gradi di rotazione.

3. Esegui l'etichettatrice di immagini

Per etichetta oggetti in un'immagine, passare l' image dell'oggetto al ImageLabeler s' process() metodo.

Giava

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });

Kotlin

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }

4. Ottieni informazioni sugli oggetti etichettati

Se l'operazione di etichettatura immagine riesce, un elenco di ImageLabel oggetti viene passato a chi ascolta il successo. Ogni ImageLabel oggetto rappresenta qualcosa che è stato etichettato nell'immagine. Puoi ottenere la descrizione testuale di ogni etichetta, il punteggio di confidenza della corrispondenza e l'indice della corrispondenza. Per esempio:

Giava

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}

Kotlin

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}

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:
  • Throttle chiama l'etichettatrice di immagini. Se un nuovo fotogramma video diventa disponibile mentre l'etichettatrice di immagini è in esecuzione, rilascia il fotogramma. Vedere la VisionProcessorBase di classe nel campione app QuickStart per un esempio.
  • Se si utilizza l'output dell'etichettatrice di immagini per sovrapporre la grafica all'immagine di input, ottenere prima il risultato, quindi eseguire il rendering dell'immagine e sovrapporre in un unico passaggio. In questo modo, esegui il rendering sulla superficie di visualizzazione solo una volta per ogni fotogramma di input. Vedi le CameraSourcePreview e GraphicOverlay classi nella applicazione di esempio QuickStart per un esempio.
  • Se si utilizza l'API Camera2, catturare immagini in ImageFormat.YUV_420_888 formato.

    Se si utilizza l'API fotocamera più vecchio, catturare immagini in ImageFormat.NV21 formato.