Menambahkan Firebase ke Aplikasi Android yang didukung TFLite

1. Ringkasan

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

Dalam codelab ini, Anda akan mengonversi aplikasi Android menggunakan model TFLite statis menjadi aplikasi menggunakan model yang disajikan 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 yang dimuat melalui Remote Config
• Bereksperimen dengan berbagai model melalui Firebase A/B Testing

Hal yang akan Anda perlukan

• 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.

2. Mendapatkan kode contoh

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.

3. Mengimpor aplikasi awal

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

Sekarang, project awal akan terbuka 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. Membuat 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 Create 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 Next, klik Download google-services.json untuk mendapatkan file konfigurasi Android Firebase, lalu salin file google-services.json ke direktori app di project Anda. Setelah file didownload, Anda dapat memilih Skip langkah berikutnya yang ditampilkan di konsol (yang telah dilakukan untuk Anda dalam project build-android-start).

Menambahkan plugin google-services ke aplikasi Anda

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

Guna memastikan bahwa semua dependensi tersedia untuk aplikasi, Anda harus menyinkronkan project dengan file gradle pada tahap ini. Pilih File > Sinkronkan Project dengan File Gradle 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 tetap berhasil dibuat.

8. Men-deploy model ke Firebase ML

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

1. Kita dapat memastikan 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 kita bisa mengganti model statis di aplikasi dengan model yang didownload secara dinamis dari Firebase, kita perlu men-deploy model tersebut ke Firebase ML. Model ini dapat di-deploy melalui konsol atau secara terprogram, menggunakan Firebase Admin SDK. Pada langkah ini, kita akan men-deploy melalui konsol.

Agar lebih sederhana, 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 ini pertama kalinya Anda buka. Lalu buka "Kustom" dan klik tombol "Add custom model" tombol.

Saat diminta, beri model nama deskriptif 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.

9. Download model dari Firebase ML

Memilih kapan akan mendownload model jarak jauh dari Firebase ke aplikasi Anda bisa jadi sedikit rumit karena model TFLite dapat berukuran relatif besar. Idealnya, kita ingin menghindari pemuatan model segera saat aplikasi diluncurkan, karena jika model kita hanya digunakan 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 Anda ingin memastikan bahwa model tersedia bahkan tanpa koneksi jaringan, penting juga untuk memaketkan model tanpa aplikasi sebagai cadangan.

Agar lebih praktis, kita akan menghapus model default yang dipaketkan dan selalu mendownload model dari Firebase saat aplikasi dimulai. Dengan cara ini, saat menjalankan pengenalan digit, Anda dapat 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 satu digit dalam pengklasifikasi digit. Setelah download selesai, Anda akan melihat pesan Toast bahwa model jarak jauh telah didownload dan log yang menunjukkan model baru Anda sedang digunakan.

10. Lacak masukan dan konversi pengguna untuk mengukur akurasi model

Google Analytics for Firebase menyediakan cara bagi Anda untuk memahami cara pengguna menelusuri aplikasi Anda, 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 pada prediksi model. Jika pengguna mengklik "YA", hal ini akan menunjukkan bahwa prediksi tersebut akurat.

Kita dapat mencatat peristiwa Analytics ke dalam log untuk melacak akurasi model. 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")

Mencatat Peristiwa ke Dalam Log

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

MainActivity.kt (onCreate)

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

Jalankan lagi aplikasi dan gambar satu digit. Tekan "Ya" beberapa kali untuk mengirim masukan bahwa inferensi tersebut akurat.

Analisis debug

Umumnya, peristiwa yang dicatat ke dalam log oleh aplikasi Anda akan ditumpuk bersama selama kurang lebih satu jam dan diupload secara bersamaan. Pendekatan ini menghemat baterai pada perangkat dan mengurangi penggunaan data jaringan. Namun, untuk memvalidasi penerapan analisis (dan, untuk melihat analisis di 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 lagi aplikasi dan gambar satu digit. Tekan "Ya" beberapa kali untuk mengirim masukan bahwa inferensi tersebut akurat. Kini Anda dapat melihat peristiwa log secara hampir 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. Dengan begitu, Anda dapat menggunakan informasi tersebut untuk memperbaiki masalah performa.

Di sini kita menambahkan trace performa seputar inferensi dan download

Hal ini penting karena model yang lebih besar yang digunakan dalam deep learning berpotensi lebih akurat, tetapi model ini juga bisa membutuhkan waktu lebih lama untuk memberikan respons. Dalam eksperimen ini, 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 Rekaman Aktivitas Kustom

Di fungsi setupDigitClassifier(), buat downloadTrace baru, lalu mulai tepat sebelum mendownload model. Kemudian, tambahkan pemroses aktif yang menghentikan rekaman aktivitas.

Di fungsi classifyDrawing(), buat klasifikasiTrace baru, dan mulai 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 pesan log untuk mencari peristiwa performa

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 tag FirebasePerformance. Dengan 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 ke dalam log:

• Logging TraceMetric
• Logging NetworkRequestMetric

12. Men-deploy model kedua ke Firebase ML

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

Mengaktifkan 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.

Mengaktifkan Firebase ML API

Buka halaman API Firebase ML di Google Cloud Console dan klik Aktifkan.

Pilih aplikasi Pengklasifikasi Digit saat diminta.

Latih model baru dan Publikasikan ke Firebase ML

Sekarang kita akan melatih versi baru model dengan menggunakan set data yang lebih besar, lalu 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 Firebase console dengan mengklik link ini, lalu klik tombol untuk 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 dalam Drive Anda sendiri.
2. Jalankan sel pertama "Latih model TensorFlow Lite yang ditingkatkan" dengan mengklik tombol {i>play<i} di sebelah kirinya. Tindakan ini akan melatih model baru dan mungkin memerlukan waktu beberapa saat.
3. Menjalankan sel kedua akan membuat prompt upload file. Upload file json yang didownload 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 bernama 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. Lalu, klik "Add Parameter" tombol.

Beri nama parameter baru model_name dan beri nilai default "mnist_v1". Dengan memasukkan nama model di parameter remote config, 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)
  }

Minta dan Gunakan 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 Publikasikan Perubahan 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 dapat menggunakan perilaku A/B Testing bawaan Firebase untuk melihat model mana yang berperforma 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 dan klik "Buat Peristiwa Konversi Baru" dan letakkan correct_inference.

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

Di menu berikutnya, terima nama default.

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

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

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

Klik tombol Tinjau di pojok kanan bawah.

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

Untuk mempelajari A/B testing 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' Stackoverflow

Melaporkan Masalah

• Masalah GitHub