Tambahkan Firebase ke Aplikasi iOS Anda yang didukung TFLite

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

1. Ikhtisar

Sasaran

Firebase ML memungkinkan Anda menerapkan model over-the-air. Ini memungkinkan Anda menjaga ukuran aplikasi tetap kecil dan hanya mengunduh model ML saat diperlukan, bereksperimen dengan beberapa model, atau memperbarui model ML Anda tanpa harus memublikasikan ulang seluruh aplikasi.

Dalam codelab ini Anda akan mengonversi aplikasi iOS menggunakan model TFLite statis menjadi aplikasi menggunakan model yang disajikan secara dinamis dari Firebase. Anda akan belajar cara:

  1. Terapkan model TFLite ke Firebase ML dan akses dari aplikasi Anda
  2. Mencatat metrik terkait model dengan Analytics
  3. Pilih model mana yang dimuat melalui Remote Config
  4. A/B menguji model yang berbeda

Prasyarat

Sebelum memulai codelab ini pastikan Anda telah menginstal:

  • Xcode 11 (atau lebih tinggi)
  • CocoaPods 1.9.1 (atau lebih tinggi)

2. Buat proyek konsol Firebase

Tambahkan Firebase ke proyek

  1. Buka konsol Firebase .
  2. Pilih Buat Proyek Baru dan beri nama proyek Anda "Firebase ML iOS Codelab".

3. Dapatkan Contoh Proyek

Unduh Kode

Mulailah dengan mengkloning proyek sampel dan menjalankan pod update di direktori proyek:

git clone https://github.com/FirebaseExtended/codelab-digitclassifier-ios.git
cd codelab-digitclassifier-ios
pod install --repo-update

Jika Anda belum menginstal git, Anda juga dapat mengunduh proyek sampel dari halaman GitHub-nya atau dengan mengeklik tautan ini . Setelah Anda mengunduh proyek, jalankan di Xcode dan mainkan dengan pengklasifikasi digit untuk merasakan cara kerjanya.

Siapkan Firebase

Ikuti dokumentasi untuk membuat proyek Firebase baru. Setelah Anda mendapatkan proyek Anda, unduh file GoogleService-Info.plist proyek Anda dari Firebase console dan seret ke akar proyek Xcode.

f06cb08d48de7e10.png

Tambahkan Firebase ke Podfile Anda dan jalankan pod install.

pod 'Firebase/MLCommon'
pod 'FirebaseMLModelInterpreter', '0.20.0'

Dalam metode didFinishLaunchingWithOptions AppDelegate Anda, impor Firebase di bagian atas file

import Firebase

Dan tambahkan panggilan untuk mengonfigurasi Firebase.

FirebaseApp.configure()

Jalankan proyek lagi untuk memastikan aplikasi dikonfigurasi dengan benar dan tidak mogok saat diluncurkan.

4. Terapkan model ke Firebase ML

Menerapkan model ke Firebase ML berguna karena dua alasan utama:

  1. Kami dapat menjaga ukuran pemasangan aplikasi tetap kecil dan hanya mengunduh model jika diperlukan
  2. Model dapat diperbarui secara teratur dan dengan siklus rilis yang berbeda dari seluruh 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 dapat diterapkan baik melalui konsol, atau secara terprogram, menggunakan Firebase Admin SDK. Pada langkah ini kami akan menyebarkan melalui konsol.

Untuk mempermudah, kami akan menggunakan model TensorFlow Lite yang sudah ada di aplikasi kami. Pertama, buka Firebase dan klik Machine Learning di panel navigasi kiri. Kemudian arahkan ke "Kustom" dan klik tombol "Tambah Model".

Saat diminta, beri model nama deskriptif seperti mnist_v1 dan unggah file dari direktori proyek codelab.

3c3c50e6ef12b3b.png

5. Unduh model dari Firebase ML

Memilih kapan mengunduh model jarak jauh dari Firebase ke dalam aplikasi Anda bisa jadi rumit karena model TFLite dapat tumbuh relatif besar. Idealnya kami ingin menghindari memuat model segera saat aplikasi diluncurkan, karena jika model kami digunakan hanya untuk satu fitur dan pengguna tidak pernah menggunakan fitur itu, kami akan mengunduh sejumlah besar data tanpa alasan. Kami juga dapat mengatur opsi unduhan seperti hanya mengambil model saat terhubung ke wifi. Jika Anda ingin memastikan bahwa model tersedia bahkan tanpa koneksi jaringan, Anda juga harus menggabungkan model sebagai bagian dari aplikasi sebagai cadangan.

Demi kesederhanaan, kami akan menghapus model bundel default dan selalu mengunduh 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 bagian atas ModelDownloader.swift , impor modul Firebase.

import Firebase

Kemudian terapkan cara-cara berikut.

static func downloadModel(named name: String,
                          completion: @escaping (RemoteModel?, DownloadError?) -> Void) {
  guard FirebaseApp.app() != nil else {
    completion(nil, .firebaseNotInitialized)
    return
  }
  guard success == nil && failure == nil else {
    completion(nil, .downloadInProgress)
    return
  }

  let remoteModel = CustomRemoteModel(name: name)
  let conditions = ModelDownloadConditions(allowsCellularAccess: true,
                                           allowsBackgroundDownloading: true)

  success = NotificationCenter.default.addObserver(forName: .firebaseMLModelDownloadDidSucceed,
                                                   object: nil,
                                                   queue: nil) { (notification) in
    defer { success = nil; failure = nil }
    guard let userInfo = notification.userInfo,
        let model = userInfo[ModelDownloadUserInfoKey.remoteModel.rawValue] as? RemoteModel
    else {
      completion(nil, .downloadReturnedEmptyModel)
      return
    }
    guard model.name == name else {
      completion(nil, .downloadReturnedWrongModel)
      return
    }
    completion(model, nil)
  }
  failure = NotificationCenter.default.addObserver(forName: .firebaseMLModelDownloadDidFail,
                                                   object: nil,
                                                   queue: nil) { (notification) in
    defer { success = nil; failure = nil }
    guard let userInfo = notification.userInfo,
        let error = userInfo[ModelDownloadUserInfoKey.error.rawValue] as? Error
    else {
      completion(nil, .mlkitError(underlyingError: DownloadError.unknownError))
      return
    }
    completion(nil, .mlkitError(underlyingError: error))
  }
  ModelManager.modelManager().download(remoteModel, conditions: conditions)
}

// Attempts to fetch the model from disk, downloading the model if it does not already exist.
static func fetchModel(named name: String,
                       completion: @escaping (String?, DownloadError?) -> Void) {
  let remoteModel = CustomRemoteModel(name: name)
  if ModelManager.modelManager().isModelDownloaded(remoteModel) {
    ModelManager.modelManager().getLatestModelFilePath(remoteModel) { (path, error) in
      completion(path, error.map { DownloadError.mlkitError(underlyingError: $0) })
    }
  } else {
    downloadModel(named: name) { (model, error) in
      guard let model = model else {
        let underlyingError = error ?? DownloadError.unknownError
        let compositeError = DownloadError.mlkitError(underlyingError: underlyingError)
        completion(nil, compositeError)
        return
      }
      ModelManager.modelManager().getLatestModelFilePath(model) { (path, pathError) in
        completion(path, error.map { DownloadError.mlkitError(underlyingError: $0) })
      }
    }
  }
}

Di viewDidLoad ViewController.swift , ganti panggilan inisialisasi DigitClassifier dengan metode pengunduhan model baru kami.

// Download the model from Firebase
print("Fetching model...")
ModelDownloader.fetchModel(named: "mnist_v1") { (filePath, error) in
  guard let path = filePath else {
    if let error = error {
      print(error)
    }
    return
  }
  print("Model download complete")

  // Initialize a DigitClassifier instance
  DigitClassifier.newInstance(modelPath: path) { result in
    switch result {
    case let .success(classifier):
      self.classifier = classifier
    case .error(_):
      self.resultLabel.text = "Failed to initialize."
    }
  }
}

Jalankan kembali aplikasi Anda. Setelah beberapa detik, Anda akan melihat log in Xcode yang menunjukkan model jarak jauh telah berhasil diunduh. Coba gambarkan angka dan konfirmasikan bahwa perilaku aplikasi tidak berubah.

6. Lacak umpan balik dan konversi pengguna untuk mengukur akurasi model

Kami akan mengukur akurasi model dengan melacak umpan balik pengguna pada prediksi model. Jika pengguna mengklik "ya", itu akan menunjukkan bahwa prediksi itu akurat.

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

pod 'Firebase/Analytics'

Kemudian di ViewController.swift impor Firebase di bagian atas file

import Firebase

Dan tambahkan baris kode berikut dalam metode correctButtonPressed .

Analytics.logEvent("correct_inference", parameters: nil)

Jalankan aplikasi lagi dan gambar satu digit. Tekan tombol "Ya" beberapa kali untuk mengirim umpan balik bahwa kesimpulannya akurat.

Analisis debug

Umumnya, peristiwa yang dicatat oleh aplikasi Anda dikumpulkan bersama selama periode 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 dalam laporan DebugView), Anda dapat mengaktifkan mode Debug di perangkat pengembangan Anda untuk mengunggah peristiwa dengan penundaan minimal.

Untuk mengaktifkan mode Debug Analytics di perangkat pengembangan Anda, tentukan argumen baris perintah berikut di Xcode:

-FIRDebugEnabled

Jalankan aplikasi lagi dan gambar satu digit. Tekan tombol "Ya" beberapa kali untuk mengirim umpan balik 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.

5276199a086721fd.png

7. Lacak waktu inferensi dengan Kinerja Firebase

Saat menguji model Anda, metrik kinerja yang dibuat pada perangkat pengembangan tidak cukup untuk menangkap bagaimana model akan tampil di tangan pengguna Anda, karena sulit untuk mengetahui perangkat keras apa yang akan digunakan pengguna untuk menjalankan aplikasi Anda. Untungnya, Anda dapat mengukur kinerja model Anda di perangkat pengguna dengan Firebase Performance untuk mendapatkan gambaran yang lebih baik tentang kinerja model Anda.

Untuk mengukur waktu yang diperlukan untuk menjalankan inferensi, pertama-tama impor Firebase di DigitClassifier.swift:

import Firebase

Kemudian mulai pelacakan kinerja dalam metode klasifikasi dan hentikan pelacakan saat inferensi selesai. Pastikan Anda menambahkan baris kode berikut di dalam penutupan DispatchQueue.global.async dan tidak langsung di bawah deklarasi metode.

let inferenceTrace = Performance.startTrace(name: "tflite inference")
defer {
  inferenceTrace?.stop()
}

Jika Anda penasaran, Anda dapat mengaktifkan logging debug melalui petunjuk di sini untuk mengonfirmasi bahwa jejak kinerja Anda sedang dicatat. Setelah beberapa saat, jejak kinerja juga akan terlihat di Firebase Console.

8. Terapkan model kedua ke Firebase ML

Saat membuat versi baru dari model Anda, seperti model dengan arsitektur model yang lebih baik atau yang dilatih pada kumpulan data yang lebih besar atau diperbarui, kami mungkin merasa tergoda untuk mengganti model kami saat ini dengan versi baru. Namun, model yang berkinerja baik dalam pengujian tidak selalu berkinerja sama baiknya dalam produksi. Oleh karena itu, mari kita lakukan pengujian A/B dalam produksi untuk membandingkan model asli kita dengan yang baru.

Aktifkan API Manajemen Model Firebase

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

Buat ember untuk menyimpan model ML Anda

Di Konsol Firebase Anda, buka Penyimpanan dan klik Mulai. fbbe78f0eb3dc9f.png

Ikuti dialog untuk menyiapkan ember Anda.

19517c0d6d2aa14d.png

Aktifkan Firebase ML API

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

2414fd5cced6c984.png Pilih aplikasi Digit Classifier saat ditanya.

Sekarang kita akan melatih model versi baru dengan menggunakan kumpulan data yang lebih besar, dan kemudian kita akan menerapkannya secara terprogram langsung dari buku catatan pelatihan menggunakan Firebase Admin SDK.

Unduh kunci pribadi untuk akun layanan

Sebelum kita dapat menggunakan Firebase Admin SDK, kita harus membuat akun layanan. Buka panel Akun Layanan Firebase console dengan mengklik tautan ini dan klik tombol untuk membuat akun layanan baru untuk Firebase Admin SDK. Saat diminta, klik tombol Generate New Private Key. Kami akan menggunakan kunci akun layanan untuk mengautentikasi permintaan kami dari notebook colab.

c3b95de1e5508516.png

Sekarang kita dapat melatih dan menerapkan model baru.

  1. Buka notebook colab ini dan buat salinannya di bawah Drive Anda sendiri.
  2. Jalankan sel pertama "Latih model TensorFlow Lite yang ditingkatkan" dengan mengklik tombol putar di sebelah kirinya. Ini akan melatih model baru dan mungkin membutuhkan waktu.
  3. Menjalankan sel kedua akan membuat permintaan unggah file. Unggah file json yang Anda unduh dari Firebase Console saat membuat akun layanan.

71e847c6a85423b3.png

  1. Jalankan dua sel terakhir.

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

c316683bb4d75d57.png

9. Pilih model melalui Remote Config

Sekarang kami memiliki dua model terpisah, kami akan menambahkan parameter untuk memilih model mana yang akan diunduh saat runtime. Nilai parameter yang diterima klien akan menentukan model mana yang diunduh klien. Pertama, buka konsol Firebase dan klik tombol Remote Config di menu navigasi kiri. Kemudian, klik tombol "Tambah Parameter".

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

Setelah menambahkan parameter, Anda akan melihatnya di Konsol:

699b3fd32acce887.png

Dalam kode kita, kita perlu menambahkan tanda centang saat memuat model jarak jauh. Saat kami menerima parameter dari Remote Config, kami akan mengambil model jarak jauh dengan nama yang sesuai; jika tidak, kami akan mencoba memuat mnist_v1 . Sebelum kita dapat menggunakan Remote Config, kita harus menambahkannya ke proyek kita dengan menetapkannya sebagai dependensi di Podfile:

pod 'Firebase/RemoteConfig'

Jalankan pod install dan buka kembali proyek Xcode. Di ModelDownloader.swift , terapkan metode fetchParameterizedModel .

static func fetchParameterizedModel(completion: @escaping (String?, DownloadError?) -> Void) {
  RemoteConfig.remoteConfig().fetchAndActivate { (status, error) in
    DispatchQueue.main.async {
      if let error = error {
        let compositeError = DownloadError.mlkitError(underlyingError: error)
        completion(nil, compositeError)
        return
      }

      let modelName: String
      if let name = RemoteConfig.remoteConfig().configValue(forKey: "model_name").stringValue {
        modelName = name
      } else {
        let defaultName = "mnist_v1"
        print("Unable to fetch model name from config, falling back to default \(defaultName)")
        modelName = defaultName
      }

      fetchModel(named: modelName, completion: completion)
    }
  }
}

Terakhir, di ViewController.swift , ganti panggilan fetchModel dengan metode baru yang baru saja kita terapkan.

// Download the model from Firebase
print("Fetching model...")
ModelDownloader.fetchParameterizedModel { (filePath, error) in
  guard let path = filePath else {
    if let error = error {
      print(error)
    }
    return
  }
  print("Model download complete")

  // Initialize a DigitClassifier instance
  DigitClassifier.newInstance(modelPath: path) { result in
    switch result {
    case let .success(classifier):
      self.classifier = classifier
    case .error(_):
      self.resultLabel.text = "Failed to initialize."
    }
  }
}

Jalankan kembali aplikasi dan pastikan masih memuat model dengan benar.

10. Uji A/B kedua model

Terakhir, kita dapat menggunakan perilaku Pengujian A/B bawaan Firebase untuk melihat model mana yang berkinerja lebih baik. Buka Analytics -> Acara 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.

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.

fad5ea36969d2aeb.png

Di menu berikutnya, terima nama default.

d7c006669ace6e40.png

Pilih aplikasi Anda di tarik-turun dan ubah kriteria penargetan menjadi 50% pengguna aktif.

6246dd7c660b53fb.png

Jika Anda dapat menetapkan peristiwa correct_inference sebagai konversi sebelumnya, gunakan peristiwa ini sebagai metrik utama untuk dilacak. Jika tidak, jika Anda tidak ingin menunggu acara muncul di Analytics, Anda dapat menambahkan correct_inference secara manual.

1ac9c94fb3159271.png

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

e4510434f8da31b6.png

Klik tombol Tinjau di sudut kanan bawah.

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

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

11. Kesimpulan

Dalam codelab ini, Anda mempelajari cara mengganti aset tflite yang dibundel 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.

Punya Pertanyaan?

Laporkan Masalah