Avvio rapido per Android

Questo tutorial mostra come creare un'app Android utilizzando TensorFlow Lite per analizzare un feed live della telecamera e identificare oggetti utilizzando un modello di apprendimento automatico, utilizzando una quantità minima di codice. Se stai aggiornando un progetto esistente, puoi utilizzare il codice di esempio come riferimento e passare alle istruzioni per modificare il tuo progetto .

Rilevamento di oggetti con apprendimento automatico

Demo animata di rilevamento oggetti Il modello di apprendimento automatico in questo tutorial esegue il rilevamento degli oggetti. Un modello di rilevamento degli oggetti prende i dati dell'immagine in un formato specifico, li analizza e tenta di classificare gli elementi nell'immagine come uno di un insieme di classi note che è stato addestrato a riconoscere. La velocità con cui un modello può identificare un oggetto noto (chiamato previsione o inferenza oggetto) viene solitamente misurata in millisecondi. In pratica, la velocità di inferenza varia in base all'hardware che ospita il modello, alla dimensione dei dati elaborati e alla dimensione del modello di machine learning.

Esempio di installazione ed esecuzione

Per la prima parte di questo tutorial, scarica l'esempio da GitHub ed eseguilo utilizzando Android Studio . Le sezioni seguenti di questo tutorial esplorano le sezioni pertinenti dell'esempio di codice, in modo da poterle applicare alle tue app Android. Sono necessarie le seguenti versioni di questi strumenti installati:

  • Android Studio 4.2.2 o versioni successive
  • Android SDK versione 31 o successiva

Ottieni il codice di esempio

Crea una copia locale del codice di esempio. Utilizzerai questo codice per creare un progetto in Android Studio ed eseguire l'applicazione di esempio.

Per clonare e impostare il codice di esempio:

  1. Clona il repository git
    git clone https://github.com/android/camera-samples.git
    
  2. Configura la tua istanza git per utilizzare il checkout sparse, in modo da avere solo i file per l'app di esempio di rilevamento degli oggetti:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

Importa ed esegui il progetto

Crea un progetto dal codice di esempio scaricato, compila il progetto e quindi eseguilo.

Per importare e creare il progetto di codice di esempio:

  1. Avvia Android Studio .
  2. Dalla pagina di benvenuto di Android Studio, scegli Importa progetto o seleziona File > Nuovo > Importa progetto .
  3. Passare alla directory del codice di esempio contenente il file build.gradle ( .../android/camera-samples/CameraXAdvanced/build.gradle ) e selezionare quella directory.

Se selezioni la directory corretta, Android Studio crea un nuovo progetto e lo crea. Questo processo può richiedere alcuni minuti, a seconda della velocità del tuo computer e se hai utilizzato Android Studio per altri progetti. Al termine della build, Android Studio visualizza un messaggio BUILD SUCCESSFUL nel pannello di stato Build Output .

Facoltativo: per correggere gli errori di compilazione aggiornando la versione del plug-in Android:

  1. Apri il file build.gradle nella directory del progetto.
  2. Modifica la versione degli strumenti Android come segue:

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. Sincronizza il progetto selezionando: File > Sincronizza progetto con file Gradle .

Per eseguire il progetto:

  1. Da Android Studio, esegui il progetto selezionando Esegui > Esegui... e CameraActivity .
  2. Seleziona un dispositivo Android collegato con una fotocamera per testare l'app.

Le sezioni successive mostrano le modifiche che devi apportare al tuo progetto esistente per aggiungere questa funzionalità alla tua app, utilizzando questa app di esempio come punto di riferimento.

Aggiungi le dipendenze del progetto

Nella propria applicazione, è necessario aggiungere dipendenze di progetto specifiche per eseguire i modelli di machine learning TensorFlow Lite e accedere a funzioni di utilità che convertono dati come immagini, in un formato dati tensore che può essere elaborato dal modello in uso.

L'app di esempio utilizza diverse librerie TensorFlow Lite per consentire l'esecuzione del modello di apprendimento automatico per il rilevamento degli oggetti:

  • Libreria principale TensorFlow Lite : fornisce le classi di input dei dati richieste, l'esecuzione del modello di apprendimento automatico e i risultati di output dall'elaborazione del modello.
  • Libreria di supporto TensorFlow Lite : questa libreria fornisce una classe helper per tradurre le immagini dalla fotocamera in un oggetto dati TensorImage che può essere elaborato dal modello di apprendimento automatico.
  • Libreria GPU TensorFlow Lite : questa libreria fornisce supporto per accelerare l'esecuzione del modello utilizzando i processori GPU sul dispositivo, se disponibili.

Le seguenti istruzioni spiegano come aggiungere il progetto richiesto e le dipendenze del modulo al proprio progetto di app Android.

Per aggiungere le dipendenze del modulo:

  1. Nel modulo che utilizza TensorFlow Lite, aggiorna il file build.gradle del modulo per includere le seguenti dipendenze. Nel codice di esempio, questo file si trova qui: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( code reference )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. In Android Studio, sincronizza le dipendenze del progetto selezionando: File > Sincronizza progetto con file Gradle .

Inizializzare l'interprete del modello ML

Nella tua app Android, devi inizializzare l'interprete del modello di apprendimento automatico TensorFlow Lite con i parametri prima di eseguire le previsioni con il modello. Questi parametri di inizializzazione dipendono dal modello in uso e possono includere impostazioni come soglie di precisione minima per previsioni ed etichette per classi di oggetti identificate.

Un modello TensorFlow Lite include un file .tflite contenente il codice del modello e spesso include un file di etichette contenente i nomi delle classi previste dal modello. Nel caso del rilevamento di oggetti, le classi sono oggetti come una persona, un cane, un gatto o un'auto. I modelli sono generalmente archiviati nella directory src/main/assets del modulo primario, come nell'esempio di codice:

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Per comodità e leggibilità del codice, l'esempio dichiara un oggetto compagno che definisce le impostazioni per il modello.

Per inizializzare il modello nell'app:

  1. Crea un oggetto compagno per definire le impostazioni per il modello: ( codice di riferimento )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Utilizzare le impostazioni di questo oggetto per costruire un oggetto TensorFlow Lite Interpreter che contenga il modello: ( codice di riferimento )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

Configura acceleratore hardware

Quando si inizializza un modello TensorFlow Lite nell'applicazione, è possibile utilizzare le funzioni di accelerazione hardware per accelerare i calcoli di previsione del modello. L'esempio di codice precedente utilizza il delegato NNAPI per gestire l'accelerazione hardware dell'esecuzione del modello:

Interpreter.Options().addDelegate(nnApiDelegate)

I delegati TensorFlow Lite sono moduli software che accelerano l'esecuzione di modelli di machine learning utilizzando hardware di elaborazione specializzato su un dispositivo mobile, come GPU, TPU o DSP. L'utilizzo di delegati per l'esecuzione dei modelli TensorFlow Lite è consigliato, ma non obbligatorio.

Per ulteriori informazioni sull'utilizzo dei delegati con TensorFlow Lite, vedere Delegati di TensorFlow Lite .

Fornire dati al modello

Nella tua app Android, il tuo codice fornisce i dati al modello per l'interpretazione trasformando i dati esistenti come le immagini in un formato di dati Tensor che può essere elaborato dal tuo modello. I dati in un Tensor devono avere dimensioni o forma specifiche che corrispondano al formato dei dati utilizzati per addestrare il modello.

Per determinare la forma del tensore richiesta per un modello:

  • Usa l'oggetto Interpreter inizializzato per determinare la forma del tensore utilizzato dal tuo modello, come mostrato nel frammento di codice seguente: ( codice di riferimento )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

Il modello di rilevamento degli oggetti utilizzato nel codice di esempio prevede immagini quadrate con una dimensione di 300 x 300 pixel.

Prima di poter fornire immagini dalla fotocamera, l'app deve acquisire l'immagine, renderla conforme alle dimensioni previste, regolarne la rotazione e normalizzare i dati dell'immagine. Quando si elaborano immagini con un modello TensorFlow Lite, è possibile utilizzare la classe ImageProcessor della libreria di supporto TensorFlow Lite per gestire questa pre-elaborazione dei dati, come mostrato di seguito.

Per trasformare i dati dell'immagine per un modello:

  1. Usa Support Library ImageProcessor per creare un oggetto per trasformare i dati dell'immagine in un formato che il tuo modello può utilizzare per eseguire previsioni: ( codice di riferimento )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Copia i dati dell'immagine dal sistema della fotocamera Android e preparalo per l'analisi con il tuo oggetto ImageProcessor : ( codice di riferimento )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Esegui previsioni

Nella tua app Android, dopo aver creato un oggetto TensorImage con i dati dell'immagine nel formato corretto, puoi eseguire il modello su tali dati per produrre una previsione o un'inferenza . Il codice di esempio per questa esercitazione utilizza una classe ObjectDetectionHelper che incapsula questo codice in un metodo predict() .

Per eseguire una previsione su un set di dati immagine:

  1. Esegui la previsione passando i dati dell'immagine alla tua funzione di previsione: ( codice di riferimento )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Chiama il metodo run sull'istanza dell'oggetto tflite con i dati dell'immagine per generare previsioni: ( codice di riferimento )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

L'oggetto TensorFlow Lite Interpreter riceve questi dati, li esegue sul modello e produce un elenco di previsioni. Per l'elaborazione continua dei dati da parte del modello, utilizzare il metodo runForMultipleInputsOutputs() in modo che gli oggetti Interprete non vengano creati e quindi rimossi dal sistema per ogni esecuzione di previsione.

Gestire l'output del modello

Nell'app Android, dopo aver eseguito i dati dell'immagine sul modello di rilevamento degli oggetti, viene prodotto un elenco di previsioni che il codice dell'app deve gestire eseguendo una logica aziendale aggiuntiva, visualizzando i risultati per l'utente o eseguendo altre azioni.

L'output di un determinato modello TensorFlow Lite varia in base al numero di previsioni che produce (una o più) e alle informazioni descrittive per ciascuna previsione. Nel caso di un modello di rilevamento degli oggetti, le previsioni in genere includono i dati per un riquadro di delimitazione che indica dove viene rilevato un oggetto nell'immagine. Nel codice di esempio, i dati restituiti sono formattati come un elenco di oggetti ObjectPrediction , come mostrato di seguito: ( codice di riferimento )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Schermata di rilevamento degli oggetti Per il modello utilizzato in questo esempio, ogni previsione include una posizione del riquadro di delimitazione per l'oggetto, un'etichetta per l'oggetto e un punteggio di previsione compreso tra 0 e 1 come Float che rappresenta la confidenza della previsione, con 1 che rappresenta la valutazione di confidenza più alta . In generale, le previsioni con un punteggio inferiore al 50% (0,5) sono considerate non conclusive. Tuttavia, il modo in cui gestisci i risultati di previsione di basso valore dipende da te e dalle esigenze della tua applicazione.

Una volta che il modello ha restituito un risultato di previsione, l'applicazione può agire in base a tale previsione presentando il risultato all'utente o eseguendo una logica aggiuntiva. Nel caso del codice di esempio, l'applicazione disegna un rettangolo di selezione attorno all'oggetto identificato e visualizza il nome della classe sullo schermo. Esaminare la funzione CameraActivity.reportPrediction() nel codice di esempio per i dettagli.

Prossimi passi

  • Esplora i vari usi di TensorFlow Lite negli esempi .
  • Scopri di più sull'utilizzo dei modelli di machine learning con TensorFlow Lite nella sezione Modelli .
  • Scopri di più sull'implementazione dell'apprendimento automatico nella tua applicazione mobile nella Guida per gli sviluppatori di TensorFlow Lite .