Menambahkan Firebase ke Aplikasi Android yang didukung TFLite

1. Ringkasan

Dengan Firebase ML, Anda dapat men-deploy model secara over the air (OTA). Ini memungkinkan Anda untuk membuat ukuran aplikasi tetap kecil dan hanya mendownload model ML jika diperlukan, bereksperimen dengan beberapa model, atau mengupdate model ML Anda tanpa harus memublikasikan ulang seluruh aplikasi.

Dalam codelab ini, Anda akan mengonversi aplikasi Android menggunakan model TFLite statis menjadi aplikasi menggunakan model yang disalurkan secara dinamis dari Firebase.

Yang akan Anda pelajari

• Men-deploy model TFLite ke Firebase ML dan mengaksesnya dari aplikasi Anda
• Melacak masukan pengguna untuk mengukur akurasi model dengan Firebase Analytics
• Membuat profil performa model melalui Firebase Performance
• Pilih salah satu dari beberapa model yang di-deploy dan dimuat melalui Remote Config
• Bereksperimen dengan berbagai model melalui Firebase A/B Testing

Yang Anda butuhkan

• Versi Android Studio terbaru.
• Kode contoh.
• Perangkat pengujian dengan Android 5.0+ dan layanan Google Play 9.8 atau yang lebih baru, atau Emulator dengan layanan Google Play 9.8 atau yang lebih baru
• Jika menggunakan perangkat, gunakan kabel koneksi.

Bagaimana Anda akan menggunakan tutorial ini?

Hanya membacanya Membacanya dan menyelesaikan latihan

Bagaimana penilaian Anda terhadap pengalaman membuat aplikasi Android?

Pemula Menengah Mahir

2. Mendapatkan kode contoh

Buat clone repositori GitHub dari command line.

$ git clone https://github.com/FirebaseExtended/codelab-digitclassifier-android.git

Jika belum menginstal git, Anda juga dapat mendownload project contoh dari halaman GitHub-nya atau dengan mengklik link ini.

Repositori "codelab-digit-classifier-android" berisi dua folder:

• start—Kode awal yang akan Anda buat dalam codelab ini.
• final—Kode lengkap untuk aplikasi contoh yang telah selesai.

3. Mengimpor aplikasi awal

Dari Android Studio, pilih direktori codelab-digitclassifier-android ( ) dari download kode contoh (File > Open > .../codelab-digitclassifier-android/start).

Sekarang Anda seharusnya sudah membuka project awal di Android Studio.

4. Menjalankan aplikasi awal

Setelah mengimpor project ke Android Studio, Anda siap menjalankan aplikasi untuk pertama kalinya. Hubungkan perangkat Android, lalu klik Run ( ) di toolbar Android Studio.

Aplikasi akan diluncurkan di perangkat Anda. Pada tahap ini, jika Anda mencoba menggambar digit, aplikasi seharusnya dapat mengenalinya.

5. Buat project Firebase console

Menambahkan Firebase ke project

1. Buka Firebase console.
2. Pilih Tambahkan project.
3. Pilih atau masukkan Nama project.
4. Ikuti langkah-langkah penyiapan yang tersisa di Firebase console, lalu klik Buat project (atau Tambahkan Firebase, jika Anda menggunakan project Google yang sudah ada).

6. Tambahkan Firebase

1. Dari layar ringkasan project baru Anda, klik ikon Android untuk meluncurkan alur kerja penyiapan.
2. Masukkan nama paket codelab: org.tensorflow.lite.examples.digitclassifier

Menambahkan file google-services.json ke aplikasi Anda

Setelah mendaftarkan nama paket dan memilih Berikutnya, klik Download google-services.json untuk mendapatkan file konfigurasi Android Firebase Anda, lalu salin file google-services.json ke direktori app di project Anda. Setelah file didownload, Anda dapat Lewati langkah berikutnya yang ditampilkan di konsol (langkah tersebut telah dilakukan untuk Anda di project build-android-start).

Menambahkan plugin google-services ke aplikasi

Plugin google-services menggunakan file google-services.json untuk mengonfigurasi aplikasi Anda agar menggunakan Firebase. Tambahkan baris berikut ke blok plugins di bagian atas file build.gradle.kts di direktori app project Anda:

app/build.gradle.kts

id("com.google.gms.google-services")

Kemudian, tambahkan baris berikut ke blok plugins file build.gradle.kts dalam project:

project/build.gradle.kts

id("com.google.gms.google-services") version "4.3.15" apply false

Menyinkronkan project dengan file gradle

Untuk memastikan bahwa semua dependensi tersedia untuk aplikasi, Anda harus menyinkronkan project dengan file gradle pada tahap ini. Pilih File > Sync Project with Gradle Files dari toolbar Android Studio.

7. Menjalankan aplikasi dengan Firebase

Setelah mengonfigurasi plugin google-services dengan file JSON, Anda siap menjalankan aplikasi dengan Firebase. Hubungkan perangkat Android, lalu klik Run ( ) di toolbar Android Studio.

Aplikasi akan diluncurkan di perangkat Anda. Pada tahap ini, aplikasi Anda seharusnya masih berhasil dibuat.

8. Men-deploy model ke Firebase ML

Men-deploy model ke Firebase ML berguna untuk dua alasan utama:

1. Kita dapat membuat ukuran penginstalan aplikasi tetap kecil dan hanya mendownload model jika diperlukan
2. Model dapat diupdate secara berkala dan dengan siklus rilis yang berbeda dari seluruh aplikasi

Sebelum bisa mengganti model statis di aplikasi dengan model yang didownload secara dinamis dari Firebase, kita perlu men-deploy-nya ke Firebase ML. Model tersebut dapat di-deploy melalui konsol, atau secara terprogram, menggunakan Firebase Admin SDK. Pada langkah ini, kita akan men-deploy melalui konsol.

Agar mudah, kita akan menggunakan model TensorFlow Lite yang sudah ada di aplikasi. Pertama, buka Firebase Console dan klik Machine Learning di panel navigasi kiri. Klik 'Mulai' jika Anda membuka akun ini untuk pertama kalinya. Lalu navigasikan ke "Custom" dan klik tombol "Add custom model".

Saat diminta, beri nama deskriptif pada model seperti mnist_v1, lalu upload file dari direktori project codelab di bagian start/app/src/main/assets/mnist.tflite. Kemudian, Anda dapat menghapus file model TF Lite ini dari project Android.

Catatan: Jika memiliki pipeline untuk melatih ulang model secara terus-menerus, Anda dapat mengotomatiskan proses upload ke Firebase menggunakan Firebase ML Model Management API.

9. Download model dari Firebase ML

Memilih kapan untuk mendownload model jarak jauh dari Firebase ke aplikasi Anda bisa jadi sulit karena model TFLite dapat tumbuh relatif besar. Idealnya, kita ingin menghindari pemuatan model segera saat aplikasi diluncurkan, karena jika model kita digunakan hanya untuk satu fitur dan pengguna tidak pernah menggunakan fitur tersebut, kita akan mendownload data dalam jumlah besar tanpa alasan. Kita juga dapat menyetel opsi download seperti hanya mengambil model saat terhubung ke Wi-Fi. Jika ingin memastikan bahwa model tersedia meskipun tanpa koneksi jaringan, Anda juga harus memaketkannya tanpa aplikasi sebagai cadangan.

Agar lebih mudah, kita akan menghapus model paket default dan selalu mendownload model dari Firebase saat aplikasi dimulai. Dengan cara ini saat menjalankan pengenalan digit, Anda bisa yakin bahwa inferensi berjalan dengan model yang disediakan dari Firebase.

Di file app/build.gradle.kts, tambahkan dependensi Firebase Machine Learning

app/build.gradle.kts

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

Kemudian, tambahkan logika untuk mendownload model dari Firebase.

Kita akan mengganti digitClassifier.initialize(loadModelFile()) dengan downloadModel("mnist_v1") dan menerapkan metode ini.

MainActivity.kt

  private fun downloadModel(modelName: String): Task<CustomModel> {
    val conditions = CustomModelDownloadConditions.Builder()
    .requireWifi()
    .build()
    return FirebaseModelDownloader.getInstance()
        .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
        .addOnCompleteListener {
          val model = it.result
          if (model == null) {
            showToast("Failed to get model file.")
          } else {
            showToast("Downloaded remote model: $modelName")
            digitClassifier.initialize(model)
          }
        }
      .addOnFailureListener {
        showToast("Model download failed for $modelName, please check your connection.")
      }
  }

Jalankan kembali aplikasi Anda dan gambar digit di pengklasifikasi digit. Setelah download selesai, Anda akan melihat pesan Toast bahwa model jarak jauh didownload dan log yang menunjukkan model baru Anda sedang digunakan.

10. Melacak masukan dan konversi pengguna untuk mengukur akurasi model

Google Analytics for Firebase menyediakan cara bagi Anda untuk memahami cara pengguna bergerak dalam aplikasi, di mana mereka berhasil, dan di mana mereka terhenti dan kembali. Alat ini juga dapat digunakan untuk memahami bagian aplikasi yang paling sering digunakan.

Kami akan mengukur akurasi model dengan melacak masukan pengguna tentang prediksi model. Jika pengguna mengklik "YA", itu akan menunjukkan bahwa prediksinya akurat.

Kita dapat mencatat peristiwa Analytics ke dalam log untuk melacak akurasi model kita. Pertama, kita harus menambahkan Analytics ke dependensi sebelum dapat digunakan dalam project:

Menambahkan dependensi Firebase Analytics

app/build.gradle.kts

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

Log Peristiwa

Kemudian, pada fungsi onCreate, kita akan menetapkan pemroses onclick untuk mencatat peristiwa correct_inference ke dalam Firebase.

MainActivity.kt (onCreate)

// Setup YES button
yesButton?.setOnClickListener {
  Firebase.analytics.logEvent("correct_inference", null)
}

Jalankan kembali aplikasi dan gambar digit. Tekan tombol "Yes" beberapa kali untuk mengirim masukan bahwa inferensi akurat.

CATATAN: Laporan Firebase Analytics dapat dilihat untuk analisis di Firebase Console sekitar 24 jam setelah diupload.

Analisis debug

Umumnya, peristiwa yang dicatat oleh aplikasi Anda dikelompokkan bersama selama sekitar satu jam dan diupload bersama. Pendekatan ini menghemat baterai pada perangkat pengguna akhir dan mengurangi penggunaan data jaringan. Namun, untuk memvalidasi penerapan analisis (dan, untuk melihat analisis dalam laporan DebugView), Anda dapat mengaktifkan mode Debug di perangkat pengembangan untuk mengupload peristiwa dengan penundaan minimal.

Untuk mengaktifkan mode Debug Analytics di perangkat Android, jalankan perintah berikut:

adb shell setprop debug.firebase.analytics.app org.tensorflow.lite.examples.digitclassifier

Jalankan kembali aplikasi dan gambar digit. Tekan tombol "Yes" beberapa kali untuk mengirim masukan bahwa inferensi akurat. Sekarang Anda dapat menampilkan peristiwa log hampir secara real-time melalui tampilan debug di Firebase console. Klik Analytics > DebugView dari menu navigasi sebelah kiri.

11. Menganalisis Performa Model

Firebase Performance Monitoring adalah layanan yang membantu Anda memperoleh laporan tentang karakteristik performa aplikasi iOS, Android, dan web Anda.

Anda menggunakan Performance Monitoring SDK untuk mengumpulkan data performa dari aplikasi, lalu meninjau dan menganalisis data tersebut di Firebase console. Performance Monitoring membantu Anda memahami di mana dan kapan performa aplikasi dapat ditingkatkan, sehingga Anda dapat menggunakan informasi tersebut untuk memperbaiki masalah performa.

Di sini kita menambahkan rekaman aktivitas performa seputar inferensi dan download

Hal ini penting karena model yang lebih besar yang digunakan dalam deep-learning memiliki potensi untuk menjadi lebih akurat, tetapi juga membutuhkan waktu lebih lama untuk memberikan respons. Dalam eksperimen kami, kami mencoba menemukan keseimbangan yang tepat antara akurasi dan kecepatan.

Menambahkan dependensi Firebase Performance

project/build.gradle.kts

plugins {
  // ...

  // Add the dependency for the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf") version "1.4.2" apply false
}

app/build.gradle.kts

plugins {
  // ...

  // Add the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf")
}

// ...

dependencies {
  // ...

  // Add the dependency for the Performance Monitoring library
  implementation("com.google.firebase:firebase-perf")
}

Menambahkan Pelacakan Kustom

Pada fungsi setupDigitClassifier(), buat downloadTrace baru, dan memulainya tepat sebelum mendownload model. Kemudian, tambahkan pemroses on Success yang menghentikan rekaman aktivitas.

Dalam fungsi classifyDrawing(), buat DefineTrace baru, dan memulainya tepat sebelum klasifikasi. Kemudian, hentikan rekaman aktivitas di pemroses onberhasil.

MainActivity.kt

class MainActivity : AppCompatActivity() {
  // ...
  
  private val firebasePerformance = FirebasePerformance.getInstance()
  
  // ...

  private fun setupDigitClassifier() {
    // Add these lines to create and start the trace
    val downloadTrace = firebasePerformance.newTrace("download_model")
    downloadTrace.start()
    downloadModel("mnist_v1")
      // Add these lines to stop the trace on success
      .addOnSuccessListener {
        downloadTrace.stop()
      }
  }

// ...

  private fun classifyDrawing() {
    val bitmap = drawView?.getBitmap()

    if ((bitmap != null) && (digitClassifier.isInitialized)) {
      // Add these lines to create and start the trace
      val classifyTrace = firebasePerformance.newTrace("classify")
      classifyTrace.start()
      digitClassifier
        .classifyAsync(bitmap)
        .addOnSuccessListener { resultText -> 
          // Add this line to stop the trace on success
          classifyTrace.stop()
          predictedTextView?.text = resultText
        }
        .addOnFailureListener { e ->
          predictedTextView?.text = getString(
            R.string.tfe_dc_classification_error_message,
            e.localizedMessage
          )
          Log.e(TAG, "Error classifying drawing.", e)
        }
    }
  }

Melihat peristiwa performa pada pesan log

1. Aktifkan logging debug untuk Performance Monitoring pada waktu build dengan menambahkan elemen <meta-data> ke file AndroidManifest.xml aplikasi Anda, seperti berikut:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>

2. Periksa apakah ada pesan error di pesan log Anda.
3. Performance Monitoring menandai pesan log-nya dengan FirebasePerformance. Dengan menggunakan pemfilteran logcat, Anda dapat secara khusus melihat trace durasi dan logging permintaan jaringan HTTP/S dengan menjalankan perintah berikut:

adb logcat -s FirebasePerformance

4. Periksa jenis log berikut yang menunjukkan bahwa Performance Monitoring mencatat peristiwa performa:

• Logging TraceMetric
• Logging NetworkRequestMetric

12. Men-deploy model kedua ke Firebase ML

Saat memunculkan versi baru model Anda, seperti model dengan arsitektur model yang lebih baik atau model yang dilatih dengan set data yang lebih besar atau telah diperbarui, kita mungkin merasa tergoda untuk mengganti model saat ini dengan versi baru. Namun, model yang berperforma baik dalam pengujian belum tentu berperforma baik dalam produksi. Oleh karena itu, mari lakukan pengujian A/B dalam produksi untuk membandingkan model asli dan model baru.

Aktifkan Firebase Model Management API

Pada langkah ini, kita akan mengaktifkan Firebase Model Management API untuk men-deploy versi baru model TensorFlow Lite menggunakan kode Python.

Membuat bucket untuk menyimpan model ML Anda

Di Firebase Console, buka Storage, lalu klik Mulai.

Ikuti dialog untuk menyiapkan bucket Anda.

Aktifkan Firebase ML API

Buka halaman Firebase ML API di Konsol Google Cloud, lalu klik Aktifkan.

Pilih aplikasi Pengklasifikasi Digit jika diminta.

Melatih model baru dan Memublikasikan ke Firebase ML

Sekarang kita akan melatih versi baru model dengan menggunakan set data yang lebih besar, kemudian kita akan men-deploy-nya secara terprogram langsung dari notebook pelatihan menggunakan Firebase Admin SDK.

Mendownload kunci pribadi untuk akun layanan

Sebelum dapat menggunakan Firebase Admin SDK, kita harus membuat akun layanan. Buka panel Akun Layanan di Firebase console dengan mengklik link ini, lalu klik tombol guna membuat akun layanan baru untuk Firebase Admin SDK. Saat diminta, klik tombol Buat Kunci Pribadi Baru. Kita akan menggunakan kunci akun layanan untuk mengautentikasi permintaan dari notebook Colab.

Sekarang kita dapat melatih dan men-deploy model baru.

1. Buka notebook Colab ini dan buat salinannya di Drive Anda sendiri.
2. Jalankan sel pertama "Train an enhanced TensorFlow Lite model" dengan mengklik tombol putar di sebelah kirinya. Tindakan ini akan melatih model baru dan mungkin memerlukan waktu beberapa saat.
3. Menjalankan sel kedua akan membuat perintah upload file. Upload file json yang Anda download dari Firebase Console saat membuat akun layanan.

4. Jalankan dua sel terakhir.

Setelah menjalankan notebook colab, Anda akan melihat model kedua di Firebase console. Pastikan model kedua diberi nama mnist_v2.

13. Pilih model melalui Remote Config

Setelah memiliki dua model terpisah, kita akan menambahkan parameter untuk memilih model yang akan didownload saat runtime. Nilai parameter yang diterima klien akan menentukan model mana yang didownload klien.

Menambahkan Aturan Konfigurasi di Firebase console

Pertama, buka Firebase console dan klik tombol Remote Config di menu navigasi sebelah kiri. Kemudian, klik tombol "Add Parameter".

Beri nama parameter baru model_name dan beri nilai default "mnist_v1". Dengan memasukkan nama model dalam parameter konfigurasi jarak jauh, kita dapat menguji beberapa model tanpa menambahkan parameter baru untuk setiap model yang ingin diuji. Klik Publikasikan Perubahan untuk menerapkan pembaruan.

Menambahkan dependensi Firebase RemoteConfig

app/build.gradle.kts

implementation("com.google.firebase:firebase-config-ktx")

Mengonfigurasi Firebase Remote Config

MainActivity.kt

  private fun configureRemoteConfig() {
    remoteConfig = Firebase.remoteConfig
    val configSettings = remoteConfigSettings {
      minimumFetchIntervalInSeconds = 3600
    }
    remoteConfig.setConfigSettingsAsync(configSettings)
  }

Meminta dan Menggunakan Konfigurasi

Buat permintaan pengambilan untuk konfigurasi dan tambahkan pengendali penyelesaian untuk mengambil dan menggunakan parameter konfigurasi.

MainActivity.kt

 private fun setupDigitClassifier() {
    configureRemoteConfig()
    remoteConfig.fetchAndActivate()
      .addOnCompleteListener { task ->
        if (task.isSuccessful) {
          val modelName = remoteConfig.getString("model_name")
          val downloadTrace = firebasePerformance.newTrace("download_model")
          downloadTrace.start()
          downloadModel(modelName)
            .addOnSuccessListener {
              downloadTrace.stop()
            }
        } else {
          showToast("Failed to fetch model name.")
        }
      }
  }

Menguji Remote Config

1. Klik tombol Run.
2. Pastikan Anda melihat pesan Toast bahwa model mnist_v1 telah didownload.
3. Kembali ke Firebase Console, ubah nilai default menjadi mnist_v2, lalu pilih Publish Changes untuk menerapkan update.
4. Mulai ulang aplikasi dan periksa untuk melihat pesan Toast bahwa model mnist_v2 didownload kali ini.

14. Efektivitas Model Pengujian A/B

Firebase A/B Testing membantu Anda mengoptimalkan pengalaman aplikasi dengan mempermudah eksperimen produk dan marketing untuk dijalankan, dianalisis, serta diskalakan. Terakhir, kita bisa menggunakan perilaku A/B Testing bawaan Firebase untuk melihat mana dari dua model kami yang memiliki performa lebih baik.

Buka Analytics -> Peristiwa di Firebase console. Jika peristiwa correct_inference ditampilkan, tandai sebagai "Peristiwa konversi", jika tidak, Anda dapat membuka Analytics -> Peristiwa Konversi, lalu mengklik "Buat Peristiwa Konversi Baru", lalu tempatkan correct_inference.

Sekarang buka "Remote Config di Firebase console, pilih tombol "A/B testing" dari menu opsi lainnya pada parameter "model_name" yang baru saja kita tambahkan.

Di menu berikutnya, terima nama default.

Pilih aplikasi Anda di dropdown dan ubah kriteria penargetan menjadi 50% pengguna aktif.

Jika Anda dapat menetapkan peristiwa correct_inference sebagai konversi sebelumnya, gunakan peristiwa ini sebagai metrik utama yang perlu dilacak. Atau, jika tidak ingin menunggu peristiwa muncul di Analytics, Anda dapat menambahkan correct_inference manually.

Terakhir, di layar Varian, tetapkan varian grup kontrol agar menggunakan mnist_v1 dan grup Varian A menggunakan mnist_v2.

Klik tombol Tinjau di pojok kanan bawah.

Selamat, Anda telah berhasil membuat pengujian A/B untuk dua model yang terpisah. Pengujian A/B saat ini masih dalam status draf dan dapat dimulai kapan saja dengan mengklik tombol "Mulai Eksperimen".

Untuk memahami pengujian A/B lebih lanjut, lihat dokumentasi A/B Testing.

15. Selamat!

Dalam codelab ini, Anda telah mempelajari cara mengganti aset tflite yang dipaketkan secara statis di aplikasi dengan model TFLite yang dimuat secara dinamis dari Firebase. Untuk mempelajari lebih lanjut tentang TFLite dan Firebase, lihat contoh TFLite lainnya dan panduan memulai Firebase.

Yang telah kita bahas

• TensorFlow Lite
• Firebase ML
• Firebase Analytics
• Firebase Performance Monitoring
• Firebase Remote Config
• Firebase A/B Testing

Langkah Berikutnya

• Implementasikan Deployment Firebase ML di aplikasi Anda.

Pelajari Lebih Lanjut

• Dokumentasi Firebase Machine Learning
• Dokumentasi TensorFlow Lite
• Model A/B Testing dengan Firebase

Ada Pertanyaan?

• 'firebase-machine-learning' di Stackoverflow

Melaporkan Masalah

• Masalah GitHub