Halaman ini diterjemahkan oleh Cloud Translation API.

Tambahkan Firebase ke Aplikasi Android Anda yang didukung TFLite

1. Ikhtisar

Firebase ML memungkinkan Anda menerapkan model melalui udara. Hal ini memungkinkan Anda menjaga ukuran aplikasi tetap kecil dan hanya mendownload model ML saat diperlukan, bereksperimen dengan beberapa model, atau memperbarui model ML tanpa harus memublikasikan ulang seluruh aplikasi.

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

Apa yang akan Anda pelajari

Terapkan model TFLite ke Firebase ML dan akses model tersebut dari aplikasi Anda
Lacak masukan pengguna untuk mengukur akurasi model dengan Firebase Analytics
Profil performa model melalui Firebase Performance
Pilih salah satu dari beberapa model yang diterapkan yang dimuat melalui Remote Config
Bereksperimenlah dengan berbagai model melalui Pengujian A/B Firebase

Apa yang Anda perlukan

Versi Android Studio terbaru.
Kode sampel.
Perangkat uji dengan Android 5.0+ dan layanan Google Play 9.8 atau lebih baru, atau Emulator dengan layanan Google Play 9.8 atau lebih baru
Jika menggunakan perangkat, kabel koneksi.

Bagaimana Anda akan menggunakan tutorial ini?

Bacalah sampai tuntas saja

Bacalah dan selesaikan latihannya

Bagaimana menilai pengalaman Anda dalam membuat aplikasi Android?

Pemula

Intermediat

Ahli

2. Dapatkan kode contoh

Kloning repositori GitHub dari baris perintah.

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

Jika Anda belum menginstal git, Anda juga dapat mengunduh proyek sampel dari halaman GitHub atau dengan mengeklik tautan ini .

3. Impor aplikasi pemula

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

Anda sekarang seharusnya sudah membuka proyek awal di Android Studio.

4. Jalankan aplikasi starter

Sekarang Anda telah mengimpor proyek ke Android Studio, Anda siap menjalankan aplikasi untuk pertama kalinya. Hubungkan perangkat Android Anda, dan klik Jalankan ( )di bilah alat Android Studio.

Aplikasi ini akan diluncurkan di perangkat Anda. Pada titik ini, jika Anda mencoba menggambar sebuah angka, aplikasi seharusnya dapat mengenalinya.

5. Buat proyek konsol Firebase

Tambahkan Firebase ke proyek

Buka konsol Firebase .
Pilih Tambahkan proyek .
Pilih atau masukkan nama Proyek.
Ikuti langkah penyiapan selanjutnya di Firebase console, lalu klik Buat proyek (atau Tambahkan Firebase, jika Anda menggunakan proyek Google yang sudah ada).

6. Tambahkan Firebase

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

Tambahkan file google-services.json ke aplikasi Anda

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

Tambahkan plugin layanan Google 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 proyek Anda:

aplikasi/build.gradle.kts

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

Kemudian tambahkan baris berikut ke blok plugins file build.gradle.kts Anda di proyek:

proyek/build.gradle.kts

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

Sinkronkan proyek Anda dengan file gradle

Untuk memastikan bahwa semua dependensi tersedia untuk aplikasi Anda, Anda harus menyinkronkan proyek Anda dengan file gradle pada saat ini. Pilih File > Sinkronkan Proyek dengan File Gradle dari toolbar Android Studio.

7. Jalankan aplikasi dengan Firebase

Sekarang setelah Anda mengonfigurasi plugin google-services dengan file JSON, Anda siap menjalankan aplikasi dengan Firebase. Hubungkan perangkat Android Anda, dan klik Jalankan ( )di bilah alat Android Studio.

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

8. Terapkan model ke Firebase ML

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

Kami dapat menjaga ukuran pemasangan aplikasi tetap kecil dan hanya mengunduh modelnya jika diperlukan
Model dapat diperbarui secara berkala dan dengan siklus rilis yang berbeda dari keseluruhan aplikasi

Sebelum kita dapat mengganti model statis di aplikasi kita dengan model yang diunduh secara dinamis dari Firebase, kita perlu menerapkannya ke Firebase ML. Model ini dapat diterapkan melalui konsol, atau secara terprogram, menggunakan Firebase Admin SDK. Pada langkah ini kami akan menerapkan melalui konsol.

Untuk mempermudah, kita akan menggunakan model TensorFlow Lite yang sudah ada di aplikasi kita. Pertama, buka Firebase Console dan klik Machine Learning di panel navigasi kiri. Klik 'Memulai' jika Anda membukanya untuk pertama kali. Kemudian navigasikan ke "Kustom" dan klik tombol "Tambahkan model khusus".

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

9. Unduh model dari Firebase ML

Memilih waktu untuk mendownload model jarak jauh dari Firebase ke aplikasi Anda bisa jadi rumit karena model TFLite dapat berkembang secara relatif besar. Idealnya kita tidak ingin memuat model secara langsung saat aplikasi diluncurkan, karena jika model kita hanya digunakan untuk satu fitur dan pengguna tidak pernah menggunakan fitur tersebut, kita akan mengunduh sejumlah besar data tanpa alasan. Kita juga dapat mengatur opsi pengunduhan seperti hanya mengambil model saat terhubung ke wifi. Jika Anda ingin memastikan bahwa model tersedia bahkan tanpa koneksi jaringan, penting juga untuk menggabungkannya tanpa aplikasi sebagai cadangan.

Demi kesederhanaan, kami akan menghapus model paket default 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

aplikasi/build.gradle.kts

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

Kemudian tambahkan logika untuk mendownload model dari Firebase.

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

Aktivitas Utama.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 gambarkan sebuah digit di pengklasifikasi digit. Setelah pengunduhan selesai, Anda akan melihat pesan Toast bahwa model jarak jauh telah diunduh dan log yang menunjukkan model baru Anda sedang digunakan.

10. Lacak masukan dan konversi pengguna untuk mengukur akurasi model

Google Analytics untuk Firebase memberikan cara bagi Anda untuk memahami cara pengguna menelusuri aplikasi Anda, titik keberhasilan mereka, titik kegagalan, dan titik baliknya. Ini juga dapat digunakan untuk memahami bagian aplikasi Anda yang paling sering digunakan.

Kami akan mengukur keakuratan model dengan melacak masukan pengguna mengenai prediksi model. Jika pengguna mengklik "YA", ini akan menunjukkan bahwa prediksi tersebut akurat.

Kami dapat mencatat peristiwa Analytics untuk melacak keakuratan model kami. Pertama, kita harus menambahkan Analytics ke ketergantungan sebelum dapat digunakan dalam proyek:

Tambahkan ketergantungan Firebase Analytics

aplikasi/build.gradle.kts

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

Catat Peristiwa

Kemudian pada fungsi onCreate kita akan mengatur pendengar onclick untuk mencatat peristiwa correct_inference ke Firebase.

Aktivitas Utama.kt (onCreate)

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

Jalankan aplikasi lagi dan gambar satu digit. Tekan tombol "Ya" beberapa kali untuk mengirimkan masukan bahwa kesimpulannya akurat.

Analisis debug

Umumnya, peristiwa yang dicatat oleh aplikasi Anda dikumpulkan bersama-sama selama jangka waktu sekitar satu jam dan diunggah bersama-sama. Pendekatan ini menghemat baterai pada perangkat pengguna akhir dan mengurangi penggunaan data jaringan. Namun, untuk tujuan memvalidasi penerapan analitik Anda (dan, untuk melihat analitik Anda di laporan DebugView), Anda dapat mengaktifkan mode Debug di perangkat pengembangan Anda untuk mengunggah peristiwa dengan penundaan minimal.

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

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

Jalankan aplikasi lagi dan gambar satu digit. Tekan tombol "Ya" beberapa kali untuk mengirimkan masukan bahwa kesimpulannya akurat. Sekarang Anda dapat melihat peristiwa log hampir secara real-time melalui tampilan debug di Firebase console. Klik Analytics > DebugView dari bilah navigasi kiri.

11. Analisis Kinerja Model

Firebase Performance Monitoring adalah layanan yang membantu Anda mendapatkan wawasan tentang karakteristik kinerja aplikasi iOS, Android, dan web Anda.

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

Di sini kami menambahkan jejak kinerja seputar inferensi dan pengunduhan

Hal ini penting karena model yang lebih besar yang digunakan dalam pembelajaran mendalam berpotensi menjadi lebih akurat, namun model tersebut juga membutuhkan waktu lebih lama untuk memberikan respons. Dalam percobaan kami, kami mencoba menemukan keseimbangan yang tepat antara akurasi dan kecepatan.

Tambahkan ketergantungan Firebase Performance

proyek/build.gradle.kts

plugins {
  // ...

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

aplikasi/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")
}

Tambahkan Jejak Khusus

Dalam fungsi setupDigitClassifier() buat downloadTrace baru, dan mulai tepat sebelum mengunduh model. Kemudian tambahkan pendengar yang berhasil menghentikan jejak.

Dalam fungsi classifyDrawing() buat classifyTrace baru, dan mulai tepat sebelum klasifikasi. Kemudian hentikan jejak di pendengar yang berhasil.

Aktivitas Utama.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)
        }
    }
  }

Lihat pesan log untuk peristiwa kinerja

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

AndroidManifest.xml

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

Periksa pesan log Anda apakah ada pesan kesalahan.
Performance Monitoring menandai pesan lognya dengan FirebasePerformance . Dengan menggunakan pemfilteran logcat, Anda dapat secara khusus melihat pelacakan durasi dan pencatatan permintaan jaringan HTTP/S dengan menjalankan perintah berikut:

adb logcat -s FirebasePerformance

Periksa jenis log berikut yang menunjukkan bahwa Performance Monitoring mencatat peristiwa kinerja:

Logging TraceMetric
Logging NetworkRequestMetric

12. Terapkan model kedua ke Firebase ML

Saat membuat versi baru model Anda, seperti model dengan arsitektur model yang lebih baik atau model yang dilatih dengan kumpulan data yang lebih besar atau diperbarui, kami mungkin tergoda untuk mengganti model saat ini dengan versi baru. Namun, model yang memiliki performa baik dalam pengujian belum tentu memiliki performa yang sama baiknya 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.

Buat keranjang untuk menyimpan model ML Anda

Di Firebase Console Anda, buka Penyimpanan dan klik Mulai.

Ikuti dialog untuk menyiapkan keranjang Anda.

Aktifkan Firebase ML API

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

Pilih aplikasi Digit Classifier saat ditanya.

Latih model baru dan Publikasikan ke Firebase ML

Sekarang kita akan melatih model versi baru menggunakan kumpulan data yang lebih besar, lalu kita akan menerapkannya secara terprogram langsung dari notebook pelatihan menggunakan Firebase Admin SDK.

Unduh kunci pribadi untuk akun layanan

Sebelum kita dapat menggunakan Firebase Admin SDK, kita perlu membuat akun layanan. Buka panel Akun Layanan di Firebase console dengan mengeklik tautan ini dan klik tombol untuk membuat akun layanan baru untuk Firebase Admin SDK. Saat diminta, klik tombol Hasilkan Kunci Pribadi Baru. Kami akan menggunakan kunci akun layanan untuk mengautentikasi permintaan kami dari notebook colab.

Sekarang kita dapat melatih dan menerapkan model baru.

Buka buku catatan colab ini dan buat salinannya di Drive Anda sendiri.
Jalankan sel pertama "Latih model TensorFlow Lite yang ditingkatkan" dengan mengeklik tombol putar di sebelah kirinya. Ini akan melatih model baru dan mungkin memerlukan waktu.
Menjalankan sel kedua akan membuat perintah unggah file. Unggah file json yang Anda unduh dari Firebase Console saat membuat akun layanan Anda.

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

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

Tambahkan Aturan Konfigurasi di Firebase console

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

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

Tambahkan ketergantungan Firebase RemoteConfig

aplikasi/build.gradle.kts

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

Konfigurasikan Konfigurasi Jarak Jauh Firebase

Aktivitas Utama.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.

Aktivitas Utama.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.")
        }
      }
  }

Uji Konfigurasi Jarak Jauh

Klik Tombol Jalankan .
Periksa apakah Anda melihat pesan Toast bahwa model mnist_v1 telah diunduh.
Kembali ke Firebase Console, ubah nilai default menjadi mnist_v2 dan pilih Publikasikan Perubahan untuk menerapkan pembaruan.
Mulai ulang aplikasi dan periksa untuk melihat pesan Toast bahwa model mnist_v2 diunduh kali ini.

14. Efektivitas Model Uji A/B

Pengujian A/B Firebase membantu Anda mengoptimalkan pengalaman aplikasi dengan mempermudah menjalankan, menganalisis, dan menskalakan eksperimen produk dan pemasaran. Terakhir, kita dapat menggunakan perilaku Pengujian A/B 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 tuliskan correct_inference.

Sekarang buka "Remote Config di Firebase console, pilih tombol "A/B test" 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 sebelumnya Anda dapat menetapkan peristiwa correct_inference sebagai konversi, gunakan peristiwa ini sebagai metrik utama untuk dilacak. Jika tidak, jika Anda tidak ingin menunggu peristiwa tersebut muncul di Analytics, Anda dapat menambahkan correct_inference manually .

Terakhir, pada layar Variants, atur varian grup kontrol Anda untuk menggunakan mnist_v1 dan grup Varian A Anda untuk menggunakan mnist_v2 .

Klik tombol Tinjau di sudut 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 mengeklik tombol "Mulai Eksperimen".

Untuk melihat pengujian A/B lebih dekat, lihat dokumentasi Pengujian A/B .

15. Selamat!

Dalam codelab ini, Anda mempelajari cara mengganti aset tflite yang digabungkan secara statis di aplikasi Anda 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.

Apa yang telah kami bahas

TensorFlow Lite
FirebaseML
Analisis Firebase
Pemantauan Kinerja Firebase
Konfigurasi Jarak Jauh Firebase
Pengujian A/B Firebase

Langkah selanjutnya

Terapkan Penerapan Firebase ML di aplikasi Anda.

Belajarlah lagi

Ada pertanyaan?

Stackoverflow 'pembelajaran mesin firebase'

Laporkan Masalah

Masalah Github