Classificazione del testo con Android

Questo tutorial mostra come creare un'applicazione Android utilizzando TensorFlow Lite per classificare il testo in linguaggio naturale. Questa applicazione è progettata per un dispositivo Android fisico ma può anche essere eseguita su un emulatore di dispositivo.

L' applicazione di esempio utilizza TensorFlow Lite per classificare il testo come positivo o negativo, utilizzando la libreria Task per il linguaggio naturale (NL) per consentire l'esecuzione dei modelli di machine learning per la classificazione del testo.

Se stai aggiornando un progetto esistente, puoi utilizzare l'applicazione di esempio come riferimento o modello. Per istruzioni su come aggiungere la classificazione del testo a un'applicazione esistente, fare riferimento a Aggiornamento e modifica dell'applicazione .

Panoramica sulla classificazione del testo

La classificazione del testo è l'attività di machine learning che consiste nell'assegnare una serie di categorie predefinite al testo con risposta aperta. Un modello di classificazione del testo viene addestrato su un corpus di testo in linguaggio naturale, in cui parole o frasi vengono classificate manualmente.

Il modello addestrato riceve il testo come input e tenta di classificare il testo in base all'insieme di classi conosciute che è stato addestrato a classificare. Ad esempio, i modelli in questo esempio accettano uno snippet di testo e determinano se il sentimento del testo è positivo o negativo. Per ogni frammento di testo, il modello di classificazione del testo restituisce un punteggio che indica la sicurezza con cui il testo viene classificato correttamente come positivo o negativo.

Per ulteriori informazioni su come vengono generati i modelli in questo tutorial, fare riferimento al tutorial Classificazione del testo con TensorFlow Lite Model Maker .

Modelli e set di dati

Questo tutorial utilizza modelli addestrati utilizzando il set di dati SST-2 (Stanford Sentiment Treebank). SST-2 contiene 67.349 recensioni di film per la formazione e 872 recensioni di film per i test, ciascuna recensione classificata come positiva o negativa. I modelli utilizzati in questa app sono stati addestrati utilizzando lo strumento TensorFlow Lite Model Maker .

L'applicazione di esempio utilizza i seguenti modelli pre-addestrati:

  • Vettore di parole medio ( NLClassifier ): NLClassifier della Task Library classifica il testo di input in diverse categorie e può gestire la maggior parte dei modelli di classificazione del testo.

  • MobileBERT ( BertNLClassifier ): BertNLClassifier della Task Library è simile a NLClassifier ma è personalizzato per i casi che richiedono tokenizzazioni Wordpiece e Sentencepiece fuori grafico.

Configura ed esegui l'app di esempio

Per configurare l'applicazione di classificazione del testo, scarica l'app di esempio da GitHub ed eseguila utilizzando Android Studio .

Requisiti di sistema

  • Android Studio versione 2021.1.1 (Bumblebee) o successiva.
  • Android SDK versione 31 o successiva
  • Dispositivo Android con una versione minima del sistema operativo SDK 21 (Android 7.0 - Nougat) con modalità sviluppatore abilitata o un emulatore Android.

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 configurare il codice di esempio:

  1. Clona il repository git
    git clone https://github.com/tensorflow/examples.git
  2. Facoltativamente, configura la tua istanza git per utilizzare il checkout sparse, in modo da avere solo i file per l'app di esempio di classificazione del testo:
    cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/text_classification/android

Importare ed eseguire il progetto

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

Per importare e creare il progetto di codice di esempio:

  1. Avvia Android Studio .
  2. Da Android Studio, seleziona File > Nuovo > Importa progetto .
  3. Passare alla directory del codice di esempio contenente il file build.gradle ( .../examples/lite/examples/text_classification/android/build.gradle ) e selezionare quella directory.
  4. Se Android Studio richiede una sincronizzazione Gradle, scegli OK.
  5. Assicurati che il tuo dispositivo Android sia collegato al computer e che la modalità sviluppatore sia abilitata. Fare clic sulla freccia verde Run .

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. Una volta completata la build, Android Studio visualizza un messaggio BUILD SUCCESSFUL nel pannello di stato dell'output della build .

Per eseguire il progetto:

  1. Da Android Studio, esegui il progetto selezionando Esegui > Esegui… .
  2. Seleziona un dispositivo Android collegato (o un emulatore) per testare l'app.

Utilizzando l'applicazione

App di esempio per la classificazione del testo in Android

Dopo aver eseguito il progetto in Android Studio, l'applicazione si aprirà automaticamente sul dispositivo connesso o sull'emulatore del dispositivo.

Per utilizzare il classificatore di testo:

  1. Inserisci uno snippet di testo nella casella di testo.
  2. Dal menu a discesa Delegate , scegli CPU o NNAPI .
  3. Specifica un modello scegliendo AverageWordVec o MobileBERT .
  4. Scegli Classifica .

L'applicazione restituisce un punteggio positivo e un punteggio negativo . La somma di questi due punteggi sarà 1 e misurerà la probabilità che il sentimento del testo di input sia positivo o negativo. Un numero più alto indica un livello di fiducia più elevato.

Ora disponi di un'applicazione di classificazione del testo funzionante. Utilizza le seguenti sezioni per comprendere meglio come funziona l'applicazione di esempio e come implementare le funzionalità di classificazione del testo nelle tue applicazioni di produzione:

Come funziona l'app di esempio

L'applicazione utilizza la libreria Task per il pacchetto Natural Language (NL) per implementare i modelli di classificazione del testo. I due modelli, Average Word Vector e MobileBERT, sono stati addestrati utilizzando TensorFlow Lite Model Maker . Per impostazione predefinita, l'applicazione viene eseguita sulla CPU, con l'opzione di accelerazione hardware tramite il delegato NNAPI.

I seguenti file e directory contengono il codice cruciale per questa applicazione di classificazione del testo:

Modifica la tua richiesta

Le sezioni seguenti spiegano i passaggi chiave per modificare la tua app Android per eseguire il modello mostrato nell'app di esempio. Queste istruzioni utilizzano l'app di esempio come punto di riferimento. Le modifiche specifiche necessarie per la tua app possono variare rispetto all'app di esempio.

Apri o crea un progetto Android

È necessario un progetto di sviluppo Android in Android Studio da seguire insieme al resto di queste istruzioni. Seguire le istruzioni seguenti per aprire un progetto esistente o crearne uno nuovo.

Per aprire un progetto di sviluppo Android esistente:

  • In Android Studio, seleziona File > Apri e seleziona un progetto esistente.

Per creare un progetto di sviluppo Android di base:

Per ulteriori informazioni sull'utilizzo di Android Studio, fare riferimento alla documentazione di Android Studio .

Aggiungi dipendenze del progetto

Nella tua applicazione, devi aggiungere dipendenze di progetto specifiche per eseguire modelli di machine learning TensorFlow Lite e accedere a funzioni di utilità che convertono dati come stringhe in un formato dati tensore che può essere elaborato dal modello che stai utilizzando.

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

Per aggiungere dipendenze del modulo:

  1. Nel modulo che utilizza TensorFlow Lite, aggiorna il file build.gradle del modulo per includere le seguenti dipendenze.

    Nell'applicazione di esempio, le dipendenze si trovano in app/build.gradle :

    dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.0'
}

    Il progetto deve includere la libreria delle attività Text ( tensorflow-lite-task-text ).

    Se desideri modificare questa app per l'esecuzione su un'unità di elaborazione grafica (GPU), la libreria GPU ( tensorflow-lite-gpu-delegate-plugin ) fornisce l'infrastruttura per eseguire l'app su GPU e Delegate ( tensorflow-lite-gpu ) fornisce l'elenco di compatibilità. L'esecuzione di questa app sulla GPU non rientra nell'ambito di questo tutorial.

  2. In Android Studio, sincronizza le dipendenze del progetto selezionando: File > Sincronizza progetto con file Gradle .

Inizializza i modelli ML

Nella tua app Android, devi inizializzare il modello di machine learning TensorFlow Lite con i parametri prima di eseguire previsioni con il modello.

Un modello TensorFlow Lite viene archiviato come file *.tflite . Il file del modello contiene la logica della previsione e in genere include metadati su come interpretare i risultati della previsione, ad esempio i nomi delle classi di previsione. In genere, i file del modello vengono archiviati nella directory src/main/assets del progetto di sviluppo, come nell'esempio di codice:

  • <project>/src/main/assets/mobilebert.tflite
  • <project>/src/main/assets/wordvec.tflite

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

Per inizializzare il modello nella tua app:

  1. Creare un oggetto associato per definire le impostazioni per il modello. Nell'applicazione di esempio, questo oggetto si trova in TextClassificationHelper.kt :

    companion object {
  const val DELEGATE_CPU = 0
  const val DELEGATE_NNAPI = 1
  const val WORD_VEC = "wordvec.tflite"
  const val MOBILEBERT = "mobilebert.tflite"
}

  2. Crea le impostazioni per il modello costruendo un oggetto classificatore e costruisci un oggetto TensorFlow Lite utilizzando BertNLClassifier o NLClassifier .

    Nell'applicazione di esempio, questo si trova nella funzione initClassifier all'interno di TextClassificationHelper.kt :

    fun initClassifier() {
  ...
  if( currentModel == MOBILEBERT ) {
    ...
    bertClassifier = BertNLClassifier.createFromFileAndOptions(
      context,
      MOBILEBERT,
      options)
  } else if (currentModel == WORD_VEC) {
      ...
      nlClassifier = NLClassifier.createFromFileAndOptions(
        context,
        WORD_VEC,
        options)
  }
}

Abilita l'accelerazione hardware (facoltativo)

Quando inizializzi un modello TensorFlow Lite nella tua app, dovresti prendere in considerazione l'utilizzo delle funzionalità di accelerazione hardware per accelerare i calcoli di previsione del modello. 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 unità di elaborazione grafica (GPU) o unità di elaborazione tensore (TPU).

Per abilitare l'accelerazione hardware nella tua app:

  1. Creare una variabile per definire il delegato che verrà utilizzato dall'applicazione. Nell'applicazione di esempio, questa variabile si trova all'inizio di TextClassificationHelper.kt :

    var currentDelegate: Int = 0

  2. Creare un selettore di delegati. Nell'applicazione di esempio, il selettore del delegato si trova nella funzione initClassifier all'interno di TextClassificationHelper.kt :

    val baseOptionsBuilder = BaseOptions.builder()
when (currentDelegate) {
   DELEGATE_CPU -> {
       // Default
   }
   DELEGATE_NNAPI -> {
       baseOptionsBuilder.useNnapi()
   }
}

L'utilizzo dei delegati per l'esecuzione dei modelli TensorFlow Lite è consigliato, ma non obbligatorio. Per ulteriori informazioni sull'utilizzo dei delegati con TensorFlow Lite, consulta Delegati TensorFlow Lite .

Preparare i dati per il modello

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

Questa app di classificazione del testo accetta una stringa come input e i modelli vengono addestrati esclusivamente su un corpus in lingua inglese. I caratteri speciali e le parole non inglesi vengono ignorati durante l'inferenza.

Per fornire dati di testo al modello:

  1. Assicurarsi che la funzione initClassifier contenga il codice per il delegato e i modelli, come spiegato nelle sezioni Inizializzare i modelli ML e Abilitare l'accelerazione hardware .

  2. Utilizzare il blocco init per chiamare la funzione initClassifier . Nell'applicazione di esempio, init si trova in TextClassificationHelper.kt :

    init {
  initClassifier()
}

Esegui previsioni

Nella tua app Android, dopo aver inizializzato un oggetto BertNLClassifier o NLClassifier , puoi iniziare a inserire il testo di input affinché il modello possa classificarsi come "positivo" o "negativo".

Per eseguire le previsioni:

  1. Crea una funzione classify , che utilizza il classificatore selezionato ( currentModel ) e misura il tempo impiegato per classificare il testo di input ( inferenceTime ). Nell'applicazione di esempio, la funzione classify si trova in TextClassificationHelper.kt :

    fun classify(text: String) {
  executor = ScheduledThreadPoolExecutor(1)

  executor.execute {
    val results: List<Category>
    // inferenceTime is the amount of time, in milliseconds, that it takes to
    // classify the input text.
    var inferenceTime = SystemClock.uptimeMillis()

    // Use the appropriate classifier based on the selected model
    if(currentModel == MOBILEBERT) {
      results = bertClassifier.classify(text)
    } else {
      results = nlClassifier.classify(text)
    }

    inferenceTime = SystemClock.uptimeMillis() - inferenceTime

    listener.onResult(results, inferenceTime)
  }
}

  2. Passa i risultati da classify all'oggetto listener.

    fun classify(text: String) {
  ...
  listener.onResult(results, inferenceTime)
}

Gestire l'output del modello

Dopo aver inserito una riga di testo, il modello produce un punteggio di previsione, espresso come Float, compreso tra 0 e 1 per le categorie "positivo" e "negativo".

Per ottenere i risultati della previsione dal modello:

  1. Crea una funzione onResult affinché l'oggetto listener gestisca l'output. Nell'applicazione di esempio, l'oggetto listener si trova in MainActivity.kt

    private val listener = object : TextClassificationHelper.TextResultsListener {
  override fun onResult(results: List<Category>, inferenceTime: Long) {
    runOnUiThread {
      activityMainBinding.bottomSheetLayout.inferenceTimeVal.text =
        String.format("%d ms", inferenceTime)

      adapter.resultsList = results.sortedByDescending {
        it.score
      }

      adapter.notifyDataSetChanged()
    }
  }
  ...
}

  2. Aggiungi una funzione onError all'oggetto listener per gestire gli errori:

      private val listener = object : TextClassificationHelper.TextResultsListener {
    ...
    override fun onError(error: String) {
      Toast.makeText(this@MainActivity, error, Toast.LENGTH_SHORT).show()
    }
  }

Una volta che il modello ha restituito una serie di risultati di previsione, l'applicazione può agire su tali previsioni presentando il risultato all'utente o eseguendo logica aggiuntiva. L'applicazione di esempio elenca i punteggi di previsione nell'interfaccia utente.

Prossimi passi