Klasifikasi teks dengan Android

Tutorial ini menunjukkan cara membuat aplikasi Android menggunakan TensorFlow Lite untuk mengklasifikasikan teks bahasa alami. Aplikasi ini dirancang untuk perangkat Android fisik tetapi juga dapat dijalankan pada emulator perangkat.

Contoh aplikasi menggunakan TensorFlow Lite untuk mengklasifikasikan teks sebagai positif atau negatif, menggunakan pustaka Tugas untuk bahasa alami (NL) untuk mengaktifkan eksekusi model pembelajaran mesin klasifikasi teks.

Jika Anda memperbarui proyek yang sudah ada, Anda dapat menggunakan contoh aplikasi sebagai referensi atau templat. Untuk petunjuk tentang cara menambahkan klasifikasi teks ke aplikasi yang sudah ada, lihat Memperbarui dan memodifikasi aplikasi Anda .

Ikhtisar klasifikasi teks

Klasifikasi teks adalah tugas pembelajaran mesin yang menetapkan serangkaian kategori yang telah ditentukan sebelumnya ke teks terbuka. Model klasifikasi teks dilatih pada korpus teks bahasa alami, tempat kata atau frasa diklasifikasikan secara manual.

Model yang dilatih menerima teks sebagai masukan dan mencoba mengkategorikan teks berdasarkan kumpulan kelas yang diketahui yang dilatih untuk mengklasifikasikannya. Misalnya, model dalam contoh ini menerima cuplikan teks dan menentukan apakah sentimen teks tersebut positif atau negatif. Untuk setiap cuplikan teks, model klasifikasi teks mengeluarkan skor yang menunjukkan keyakinan teks tersebut diklasifikasikan dengan benar sebagai positif atau negatif.

Untuk informasi selengkapnya tentang cara pembuatan model dalam tutorial ini, lihat tutorial Klasifikasi teks dengan TensorFlow Lite Model Maker .

Model dan kumpulan data

Tutorial ini menggunakan model yang dilatih menggunakan dataset SST-2 (Stanford Sentiment Treebank). SST-2 berisi 67.349 review film untuk pelatihan dan 872 review film untuk pengujian, dengan setiap review dikategorikan positif atau negatif. Model yang digunakan dalam aplikasi ini dilatih menggunakan alat TensorFlow Lite Model Maker .

Contoh aplikasi menggunakan model terlatih berikut:

  • Vektor Kata Rata-Rata ( NLClassifier ) - NLClassifier Perpustakaan Tugas mengklasifikasikan teks masukan ke dalam kategori berbeda, dan dapat menangani sebagian besar model klasifikasi teks.

  • MobileBERT ( BertNLClassifier ) - BertNLClassifier di Perpustakaan Tugas mirip dengan NLClassifier tetapi disesuaikan untuk kasus-kasus yang memerlukan tokenisasi Wordpiece dan Sentencepiece di luar grafik.

Siapkan dan jalankan aplikasi contoh

Untuk menyiapkan aplikasi klasifikasi teks, unduh aplikasi contoh dari GitHub dan jalankan menggunakan Android Studio .

Persyaratan sistem

  • Android Studio versi 2021.1.1 (Bumblebee) atau lebih tinggi.
  • Android SDK versi 31 atau lebih tinggi
  • Perangkat Android dengan versi OS minimum SDK 21 (Android 7.0 - Nougat) dengan mode pengembang diaktifkan, atau Android Emulator.

Dapatkan kode contoh

Buat salinan lokal dari kode contoh. Anda akan menggunakan kode ini untuk membuat proyek di Android Studio dan menjalankan aplikasi contoh.

Untuk mengkloning dan mengatur kode contoh:

  1. Kloning repositori git
    git clone https://github.com/tensorflow/examples.git
  2. Secara opsional, konfigurasikan instance git Anda untuk menggunakan checkout jarang, sehingga Anda hanya memiliki file untuk aplikasi contoh klasifikasi teks:
    cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/text_classification/android

Impor dan jalankan proyek

Buat proyek dari kode contoh yang diunduh, bangun proyek, lalu jalankan.

Untuk mengimpor dan membuat proyek kode contoh:

  1. Mulai Android Studio .
  2. Dari Android Studio, pilih File > New > Import Project .
  3. Navigasikan ke direktori kode contoh yang berisi file build.gradle ( .../examples/lite/examples/text_classification/android/build.gradle ) dan pilih direktori tersebut.
  4. Jika Android Studio meminta Sinkronisasi Gradle, pilih OK.
  5. Pastikan perangkat Android Anda terhubung ke komputer dan mode pengembang diaktifkan. Klik panah Run yang berwarna hijau.

Jika Anda memilih direktori yang benar, Android Studio akan membuat proyek baru dan membangunnya. Proses ini dapat memakan waktu beberapa menit, bergantung pada kecepatan komputer Anda dan apakah Anda pernah menggunakan Android Studio untuk proyek lain. Saat build selesai, Android Studio menampilkan pesan BUILD SUCCESSFUL di panel status Build Output .

Untuk menjalankan proyek:

  1. Dari Android Studio, jalankan proyek dengan memilih Run > Run… .
  2. Pilih perangkat Android yang terpasang (atau emulator) untuk menguji aplikasi.

Menggunakan aplikasi

Contoh aplikasi klasifikasi teks di Android

Setelah menjalankan proyek di Android Studio, aplikasi akan otomatis terbuka di perangkat atau emulator perangkat yang terhubung.

Untuk menggunakan pengklasifikasi teks:

  1. Masukkan cuplikan teks ke dalam kotak teks.
  2. Dari tarik-turun Delegasi , pilih CPU atau NNAPI .
  3. Tentukan model dengan memilih AverageWordVec atau MobileBERT .
  4. Pilih Klasifikasi .

Aplikasi ini menghasilkan skor positif dan skor negatif . Kedua skor ini akan berjumlah 1, dan mengukur kemungkinan bahwa sentimen teks masukan positif atau negatif. Angka yang lebih tinggi menunjukkan tingkat kepercayaan yang lebih tinggi.

Anda sekarang memiliki aplikasi klasifikasi teks yang berfungsi. Gunakan bagian berikut untuk lebih memahami cara kerja aplikasi contoh, dan cara mengimplementasikan fitur klasifikasi teks ke aplikasi produksi Anda:

Cara kerja aplikasi contoh

Aplikasi ini menggunakan paket Task Library for Natural Language (NL) untuk mengimplementasikan model klasifikasi teks. Kedua model, Average Word Vector dan MobileBERT, dilatih menggunakan TensorFlow Lite Model Maker . Aplikasi berjalan pada CPU secara default, dengan opsi akselerasi perangkat keras menggunakan delegasi NNAPI.

File dan direktori berikut berisi kode penting untuk aplikasi klasifikasi teks ini:

Ubah aplikasi Anda

Bagian berikut menjelaskan langkah-langkah utama untuk memodifikasi aplikasi Android Anda untuk menjalankan model yang ditunjukkan dalam contoh aplikasi. Petunjuk ini menggunakan aplikasi contoh sebagai titik referensi. Perubahan spesifik yang diperlukan untuk aplikasi Anda mungkin berbeda dari aplikasi contoh.

Buka atau buat proyek Android

Anda memerlukan proyek pengembangan Android di Android Studio untuk mengikuti petunjuk selanjutnya. Ikuti petunjuk di bawah ini untuk membuka proyek yang sudah ada atau membuat proyek baru.

Untuk membuka proyek pengembangan Android yang sudah ada:

  • Di Android Studio, pilih File > Buka dan pilih proyek yang sudah ada.

Untuk membuat proyek pengembangan Android dasar:

Untuk informasi selengkapnya tentang penggunaan Android Studio, lihat dokumentasi Android Studio .

Tambahkan dependensi proyek

Dalam aplikasi Anda sendiri, Anda harus menambahkan dependensi proyek tertentu untuk menjalankan model pembelajaran mesin TensorFlow Lite, dan mengakses fungsi utilitas yang mengonversi data seperti string, menjadi format data tensor yang dapat diproses oleh model yang Anda gunakan.

Petunjuk berikut menjelaskan cara menambahkan dependensi proyek dan modul yang diperlukan ke proyek aplikasi Android Anda sendiri.

Untuk menambahkan dependensi modul:

  1. Pada modul yang menggunakan TensorFlow Lite, perbarui file build.gradle modul untuk menyertakan dependensi berikut.

    Dalam contoh aplikasi, dependensi terletak di app/build.gradle :

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

    Proyek harus menyertakan pustaka tugas Teks ( tensorflow-lite-task-text ).

    Jika Anda ingin memodifikasi aplikasi ini agar berjalan pada unit pemrosesan grafis (GPU), pustaka GPU ( tensorflow-lite-gpu-delegate-plugin ) menyediakan infrastruktur untuk menjalankan aplikasi pada GPU, dan Delegate ( tensorflow-lite-gpu ) menyediakan daftar kompatibilitas. Menjalankan aplikasi ini pada GPU berada di luar cakupan tutorial ini.

  2. Di Android Studio, sinkronkan dependensi proyek dengan memilih: File > Sync Project with Gradle Files .

Inisialisasi model ML

Di aplikasi Android, Anda harus menginisialisasi model machine learning TensorFlow Lite dengan parameter sebelum menjalankan prediksi dengan model tersebut.

Model TensorFlow Lite disimpan sebagai file *.tflite . File model berisi logika prediksi dan biasanya menyertakan metadata tentang cara menafsirkan hasil prediksi, seperti nama kelas prediksi. Biasanya, file model disimpan di direktori src/main/assets proyek pengembangan Anda, seperti pada contoh kode:

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

Untuk kenyamanan dan keterbacaan kode, contoh mendeklarasikan objek pendamping yang menentukan pengaturan model.

Untuk menginisialisasi model di aplikasi Anda:

  1. Buat objek pendamping untuk menentukan pengaturan model. Dalam contoh aplikasi, objek ini terletak di 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. Buat pengaturan untuk model dengan membuat objek pengklasifikasi, dan membuat objek TensorFlow Lite menggunakan BertNLClassifier atau NLClassifier .

    Dalam contoh aplikasi, ini terletak di fungsi initClassifier dalam 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)
  }
}

Aktifkan akselerasi perangkat keras (opsional)

Saat menginisialisasi model TensorFlow Lite di aplikasi Anda, Anda harus mempertimbangkan penggunaan fitur akselerasi hardware untuk mempercepat penghitungan prediksi model. Delegasi TensorFlow Lite adalah modul perangkat lunak yang mempercepat eksekusi model pembelajaran mesin menggunakan perangkat keras pemrosesan khusus pada perangkat seluler, seperti unit pemrosesan grafis (GPU) atau unit pemrosesan tensor (TPU).

Untuk mengaktifkan akselerasi perangkat keras di aplikasi Anda:

  1. Buat variabel untuk menentukan delegasi yang akan digunakan aplikasi. Dalam contoh aplikasi, variabel ini terletak di awal TextClassificationHelper.kt :

    var currentDelegate: Int = 0

  2. Buat pemilih delegasi. Dalam contoh aplikasi, pemilih delegasi terletak di fungsi initClassifier dalam TextClassificationHelper.kt :

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

Disarankan untuk menggunakan delegasi untuk menjalankan model TensorFlow Lite, tetapi tidak wajib. Untuk informasi selengkapnya tentang penggunaan delegasi dengan TensorFlow Lite, lihat Delegasi TensorFlow Lite .

Siapkan data untuk model

Di aplikasi Android, kode Anda menyediakan data ke model untuk diinterpretasikan dengan mengubah data yang ada seperti teks mentah menjadi format data Tensor yang dapat diproses oleh model Anda. Data di Tensor yang Anda teruskan ke model harus memiliki dimensi atau bentuk tertentu yang cocok dengan format data yang digunakan untuk melatih model.

Aplikasi klasifikasi teks ini menerima string sebagai masukan, dan modelnya dilatih secara eksklusif pada korpus bahasa Inggris. Karakter khusus dan kata-kata non-Inggris diabaikan selama inferensi.

Untuk menyediakan data teks ke model:

  1. Pastikan fungsi initClassifier berisi kode untuk delegasi dan model, seperti yang dijelaskan di bagian Inisialisasi model ML dan Aktifkan akselerasi perangkat keras .

  2. Gunakan blok init untuk memanggil fungsi initClassifier . Dalam contoh aplikasi, init terletak di TextClassificationHelper.kt :

    init {
  initClassifier()
}

Jalankan prediksi

Di aplikasi Android, setelah menginisialisasi objek BertNLClassifier atau NLClassifier , Anda dapat mulai memasukkan teks input agar model dapat dikategorikan sebagai "positif" atau "negatif".

Untuk menjalankan prediksi:

  1. Buat fungsi classify , yang menggunakan pengklasifikasi yang dipilih ( currentModel ) dan mengukur waktu yang dibutuhkan untuk mengklasifikasikan teks masukan ( inferenceTime ). Pada contoh aplikasi, fungsi classify terletak di 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. Teruskan hasil dari classify ke objek pendengar.

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

Menangani keluaran model

Setelah Anda memasukkan satu baris teks, model menghasilkan skor prediksi, yang dinyatakan sebagai Float, antara 0 dan 1 untuk kategori 'positif' dan 'negatif'.

Untuk mendapatkan hasil prediksi dari model:

  1. Buat fungsi onResult untuk objek pendengar guna menangani output. Dalam contoh aplikasi, objek pendengar terletak di 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. Tambahkan fungsi onError ke objek pendengar untuk menangani kesalahan:

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

Setelah model mengembalikan serangkaian hasil prediksi, aplikasi Anda dapat bertindak berdasarkan prediksi tersebut dengan menyajikan hasilnya kepada pengguna atau mengeksekusi logika tambahan. Contoh aplikasi mencantumkan skor prediksi di antarmuka pengguna.

Langkah selanjutnya