Klasyfikacja tekstu w systemie Android

W tym samouczku pokazano, jak zbudować aplikację na Androida przy użyciu TensorFlow Lite do klasyfikowania tekstu w języku naturalnym. Ta aplikacja jest przeznaczona na fizyczne urządzenie z systemem Android, ale można ją również uruchomić na emulatorze urządzenia.

Przykładowa aplikacja wykorzystuje TensorFlow Lite do klasyfikowania tekstu jako pozytywnego lub negatywnego, korzystając z biblioteki zadań dla języka naturalnego (NL), aby umożliwić wykonanie modeli uczenia maszynowego klasyfikacji tekstu.

Jeśli aktualizujesz istniejący projekt, możesz użyć przykładowej aplikacji jako odniesienia lub szablonu. Aby uzyskać instrukcje dotyczące dodawania klasyfikacji tekstu do istniejącej aplikacji, zobacz Aktualizowanie i modyfikowanie aplikacji .

Przegląd klasyfikacji tekstu

Klasyfikacja tekstu to zadanie uczenia maszynowego polegające na przypisywaniu zestawu predefiniowanych kategorii do tekstu otwartego. Model klasyfikacji tekstu jest szkolony na korpusie tekstu w języku naturalnym, w którym słowa lub frazy są klasyfikowane ręcznie.

Wyszkolony model otrzymuje tekst jako dane wejściowe i próbuje kategoryzować tekst zgodnie z zestawem znanych klas, które miał klasyfikować. Na przykład modele w tym przykładzie akceptują fragment tekstu i określają, czy tonacja tekstu jest pozytywna, czy negatywna. Dla każdego fragmentu tekstu model klasyfikacji tekstu generuje wynik wskazujący pewność, że tekst został poprawnie sklasyfikowany jako pozytywny lub negatywny.

Aby uzyskać więcej informacji na temat sposobu generowania modeli w tym samouczku, zapoznaj się z samouczkiem Klasyfikacja tekstu za pomocą TensorFlow Lite Model Maker .

Modele i zbiór danych

W tym samouczku zastosowano modele przeszkolone przy użyciu zestawu danych SST-2 (Stanford Sentiment Treebank). SST-2 zawiera 67 349 recenzji filmów do celów szkoleniowych i 872 recenzji filmów do testów, przy czym każda recenzja jest klasyfikowana jako pozytywna lub negatywna. Modele używane w tej aplikacji zostały przeszkolone przy użyciu narzędzia TensorFlow Lite Model Maker .

Przykładowa aplikacja korzysta z następujących wstępnie wytrenowanych modeli:

  • Średni wektor słów ( NLClassifier ) — moduł NLClassifier biblioteki zadań klasyfikuje tekst wejściowy na różne kategorie i obsługuje większość modeli klasyfikacji tekstu.

  • MobileBERT ( BertNLClassifier ) — BertNLClassifier biblioteki zadań jest podobny do NLClassifier, ale jest dostosowany do przypadków, które wymagają tokenizacji Wordpiece i Zdanie poza wykresem.

Skonfiguruj i uruchom przykładową aplikację

Aby skonfigurować aplikację do klasyfikacji tekstu, pobierz przykładową aplikację z GitHub i uruchom ją za pomocą Android Studio .

Wymagania systemowe

  • Android Studio w wersji 2021.1.1 (Bumblebee) lub nowszej.
  • Android SDK w wersji 31 ​​lub nowszej
  • Urządzenie z systemem Android z minimalną wersją systemu operacyjnego SDK 21 (Android 7.0 - Nougat) z włączonym trybem programisty lub emulatorem Androida.

Pobierz przykładowy kod

Utwórz lokalną kopię przykładowego kodu. Użyjesz tego kodu, aby utworzyć projekt w Android Studio i uruchomić przykładową aplikację.

Aby sklonować i skonfigurować przykładowy kod:

  1. Sklonuj repozytorium git
    git clone https://github.com/tensorflow/examples.git
  2. Opcjonalnie skonfiguruj instancję git tak, aby korzystała z rzadkiego pobierania, aby mieć tylko pliki dla przykładowej aplikacji klasyfikacji tekstu:
    cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/text_classification/android

Zaimportuj i uruchom projekt

Utwórz projekt na podstawie pobranego przykładowego kodu, skompiluj projekt, a następnie uruchom go.

Aby zaimportować i zbudować przykładowy projekt kodu:

  1. Uruchom Android Studio .
  2. W Android Studio wybierz opcję Plik > Nowy > Importuj projekt .
  3. Przejdź do przykładowego katalogu kodu zawierającego plik build.gradle ( .../examples/lite/examples/text_classification/android/build.gradle ) i wybierz ten katalog.
  4. Jeśli Android Studio zażąda synchronizacji stopniowej, wybierz OK.
  5. Upewnij się, że Twoje urządzenie z Androidem jest podłączone do komputera i włączony jest tryb programisty. Kliknij zieloną strzałkę Run .

Jeśli wybierzesz właściwy katalog, Android Studio utworzy nowy projekt i go zbuduje. Ten proces może zająć kilka minut, w zależności od szybkości komputera i tego, czy korzystałeś z Android Studio w innych projektach. Po zakończeniu kompilacji Android Studio wyświetla komunikat BUILD SUCCESSFUL w panelu stanu wyników kompilacji .

Aby uruchomić projekt:

  1. W Android Studio uruchom projekt, wybierając opcję Uruchom > Uruchom… .
  2. Wybierz podłączone urządzenie z Androidem (lub emulator), aby przetestować aplikację.

Korzystanie z aplikacji

Przykładowa aplikacja do klasyfikacji tekstu na Androida

Po uruchomieniu projektu w Android Studio aplikacja automatycznie otworzy się na podłączonym urządzeniu lub emulatorze urządzenia.

Aby użyć klasyfikatora tekstu:

  1. Wpisz fragment tekstu w polu tekstowym.
  2. Z listy rozwijanej Delegat wybierz opcję CPU lub NNAPI .
  3. Określ model, wybierając opcję AverageWordVec lub MobileBERT .
  4. Wybierz opcję Klasyfikuj .

Aplikacja generuje wynik pozytywny i wynik negatywny . Te dwa wyniki sumują się do 1 i mierzą prawdopodobieństwo, że nastrój tekstu wejściowego będzie pozytywny lub negatywny. Wyższa liczba oznacza wyższy poziom pewności.

Masz teraz działającą aplikację do klasyfikacji tekstu. Skorzystaj z poniższych sekcji, aby lepiej zrozumieć, jak działa przykładowa aplikacja i jak zaimplementować funkcje klasyfikacji tekstu w aplikacjach produkcyjnych:

Jak działa przykładowa aplikacja

Aplikacja korzysta z pakietu Biblioteka zadań dla języka naturalnego (NL) do implementacji modeli klasyfikacji tekstu. Obydwa modele, Average Word Vector i MobileBERT, zostały przeszkolone przy użyciu narzędzia TensorFlow Lite Model Maker . Aplikacja domyślnie działa na procesorze, z możliwością akceleracji sprzętowej przy użyciu delegata NNAPI.

Poniższe pliki i katalogi zawierają kluczowy kod dla tej aplikacji do klasyfikacji tekstu:

Zmodyfikuj swoją aplikację

W poniższych sekcjach wyjaśniono najważniejsze kroki umożliwiające zmodyfikowanie własnej aplikacji dla systemu Android w celu uruchomienia modelu pokazanego w przykładowej aplikacji. W niniejszych instrukcjach punktem odniesienia jest przykładowa aplikacja. Konkretne zmiany potrzebne w Twojej aplikacji mogą różnić się od przykładowej aplikacji.

Otwórz lub utwórz projekt na Androida

Aby wykonać pozostałe instrukcje, potrzebujesz projektu programistycznego dla systemu Android w Android Studio. Postępuj zgodnie z poniższymi instrukcjami, aby otworzyć istniejący projekt lub utworzyć nowy.

Aby otworzyć istniejący projekt programistyczny na Androida:

  • W Android Studio wybierz opcję Plik > Otwórz i wybierz istniejący projekt.

Aby utworzyć podstawowy projekt programistyczny dla systemu Android:

Więcej informacji na temat korzystania z Android Studio znajdziesz w dokumentacji Android Studio .

Dodaj zależności projektu

We własnej aplikacji musisz dodać określone zależności projektu, aby uruchomić modele uczenia maszynowego TensorFlow Lite i uzyskać dostęp do funkcji narzędziowych, które konwertują dane, takie jak ciągi znaków, do formatu danych tensorowych, który może być przetwarzany przez używany model.

Poniższe instrukcje wyjaśniają, jak dodać wymagane zależności projektu i modułu do własnego projektu aplikacji dla systemu Android.

Aby dodać zależności modułów:

  1. W module korzystającym z TensorFlow Lite zaktualizuj plik build.gradle modułu, aby uwzględnić następujące zależności.

    W przykładowej aplikacji zależności znajdują się w app/build.gradle :

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

    Projekt musi zawierać bibliotekę zadań Text ( tensorflow-lite-task-text ).

    Jeśli chcesz zmodyfikować tę aplikację tak, aby działała na procesorze graficznym (GPU), biblioteka GPU ( tensorflow-lite-gpu-delegate-plugin ) zapewnia infrastrukturę do uruchamiania aplikacji na GPU, a Delegate ( tensorflow-lite-gpu ) zawiera listę kompatybilności. Uruchamianie tej aplikacji na GPU wykracza poza zakres tego samouczka.

  2. W Android Studio zsynchronizuj zależności projektu, wybierając: Plik > Synchronizuj projekt z plikami Gradle .

Zainicjuj modele ML

W aplikacji na Androida musisz zainicjować model uczenia maszynowego TensorFlow Lite z parametrami, zanim uruchomisz prognozy z modelem.

Model TensorFlow Lite jest przechowywany jako plik *.tflite . Plik modelu zawiera logikę przewidywania i zazwyczaj zawiera metadane dotyczące sposobu interpretacji wyników przewidywań, takie jak nazwy klas przewidywań. Zazwyczaj pliki modeli są przechowywane w katalogu src/main/assets projektu deweloperskiego, jak w przykładzie kodu:

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

Dla wygody i czytelności kodu w przykładzie zadeklarowano obiekt towarzyszący, który definiuje ustawienia modelu.

Aby zainicjować model w aplikacji:

  1. Utwórz obiekt towarzyszący, aby zdefiniować ustawienia modelu. W przykładowej aplikacji obiekt ten znajduje się w 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. Utwórz ustawienia modelu, budując obiekt klasyfikatora i skonstruuj obiekt TensorFlow Lite przy użyciu BertNLClassifier lub NLClassifier .

    W przykładowej aplikacji znajduje się to w funkcji initClassifier w 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)
  }
}

Włącz akcelerację sprzętową (opcjonalnie)

Inicjując model TensorFlow Lite w aplikacji, należy rozważyć użycie funkcji akceleracji sprzętowej, aby przyspieszyć obliczenia predykcyjne modelu. Delegaci TensorFlow Lite to moduły oprogramowania, które przyspieszają wykonywanie modeli uczenia maszynowego przy użyciu specjalistycznego sprzętu przetwarzającego na urządzeniu mobilnym, takiego jak jednostka przetwarzania grafiki (GPU) lub jednostka przetwarzania tensor (TPU).

Aby włączyć akcelerację sprzętową w aplikacji:

  1. Utwórz zmienną, aby zdefiniować delegata, którego będzie używać aplikacja. W przykładowej aplikacji zmienna ta znajduje się na początku TextClassificationHelper.kt :

    var currentDelegate: Int = 0

  2. Utwórz selektor delegata. W przykładowej aplikacji selektor delegata znajduje się w funkcji initClassifier w TextClassificationHelper.kt :

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

Zalecane jest używanie delegatów do uruchamiania modeli TensorFlow Lite, ale nie jest to wymagane. Aby uzyskać więcej informacji na temat używania delegatów z TensorFlow Lite, zobacz Delegaty TensorFlow Lite .

Przygotuj dane do modelu

W aplikacji na Androida kod dostarcza dane do modelu w celu interpretacji, przekształcając istniejące dane, takie jak nieprzetworzony tekst, w format danych Tensor , który może być przetwarzany przez model. Dane w Tensorze przekazywane do modelu muszą mieć określone wymiary lub kształt pasujący do formatu danych używanych do uczenia modelu.

Ta aplikacja do klasyfikacji tekstu akceptuje ciąg znaków jako dane wejściowe, a modele są szkolone wyłącznie na korpusie w języku angielskim. Znaki specjalne i słowa w języku innym niż angielski są ignorowane podczas wnioskowania.

Aby dostarczyć dane tekstowe do modelu:

  1. Upewnij się, że funkcja initClassifier zawiera kod delegata i modeli, jak wyjaśniono w sekcjach Inicjowanie modeli ML i Włączanie przyspieszania sprzętowego .

  2. Użyj bloku init , aby wywołać funkcję initClassifier . W przykładowej aplikacji init znajduje się w TextClassificationHelper.kt :

    init {
  initClassifier()
}

Uruchom prognozy

Po zainicjowaniu obiektu BertNLClassifier lub NLClassifier w aplikacji na Androida możesz rozpocząć wprowadzanie tekstu wejściowego do modelu, aby został on sklasyfikowany jako „pozytywny” lub „negatywny”.

Aby uruchomić prognozy:

  1. Utwórz funkcję classify , która użyje wybranego klasyfikatora ( currentModel ) i zmierzy czas potrzebny na sklasyfikowanie tekstu wejściowego ( inferenceTime ). W przykładowej aplikacji funkcja classify znajduje się w 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. Przekaż wyniki z classify do obiektu słuchacza.

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

Obsługuj dane wyjściowe modelu

Po wprowadzeniu wiersza tekstu model generuje wynik przewidywania wyrażony jako wartość zmiennoprzecinkowa w zakresie od 0 do 1 dla kategorii „pozytywnych” i „negatywnych”.

Aby uzyskać wyniki prognoz z modelu:

  1. Utwórz funkcję onResult dla obiektu słuchacza, która będzie obsługiwać dane wyjściowe. W przykładowej aplikacji obiekt słuchacza znajduje się w pliku 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. Dodaj funkcję onError do obiektu słuchacza, aby obsługiwać błędy:

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

Gdy model zwróci zestaw wyników przewidywań, aplikacja może zastosować się do tych przewidywań, prezentując wyniki użytkownikowi lub wykonując dodatkową logikę. Przykładowa aplikacja wyświetla wyniki przewidywań w interfejsie użytkownika.

Następne kroki