Dodaj Firebase do swojej aplikacji na Androida obsługującej TFLite

1. Przegląd

cd824ecfd05a2822.png

Firebase ML umożliwia wdrożenie modelu bezprzewodowo. Dzięki temu możesz zachować niewielki rozmiar aplikacji i pobierać model ML tylko w razie potrzeby, eksperymentować z wieloma modelami lub aktualizować model ML bez konieczności ponownego publikowania całej aplikacji.

Podczas tych zajęć z programowania przekonwertujesz aplikację na Androida korzystającą ze statycznego modelu TFLite na aplikację korzystającą z modelu dynamicznie udostępnianego z Firebase.

Czego się dowiesz

  • Wdrażaj modele TFLite w Firebase ML i uzyskuj do nich dostęp ze swojej aplikacji
  • Śledź opinie użytkowników, aby mierzyć dokładność modelu za pomocą Firebase Analytics
  • Wydajność modelu profilu poprzez Firebase Performance
  • Wybierz, który z wielu wdrożonych modeli ma zostać załadowany poprzez Zdalną konfigurację
  • Eksperymentuj z różnymi modelami za pomocą testów A/B Firebase

Co będziesz potrzebował

  • Najnowsza wersja Androida Studio .
  • Przykładowy kod.
  • Urządzenie testowe z Androidem 5.0 lub nowszym i usługami Google Play 9.8 lub nowszymi lub Emulator z usługami Google Play 9.8 lub nowszymi
  • Jeśli używasz urządzenia, kabel połączeniowy.

Jak będziesz korzystać z tego samouczka?

Przeczytaj tylko i wyłącznie Przeczytaj i wykonaj ćwiczenia

Jak oceniasz swoje doświadczenie w tworzeniu aplikacji na Androida?

Nowicjusz Mediator Biegły

2. Pobierz przykładowy kod

Sklonuj repozytorium GitHub z wiersza poleceń.

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

Jeśli nie masz zainstalowanego gita, możesz także pobrać przykładowy projekt ze strony GitHub lub klikając ten link .

3. Zaimportuj aplikację startową

W Android Studio wybierz katalog codelab-digitclassifier-android ( folder_studio_android.png ) z przykładowego kodu do pobrania ( Plik > Otwórz > .../codelab-digitclassifier-Android/start).

Powinieneś teraz mieć otwarty projekt startowy w Android Studio.

4. Uruchom aplikację startową

Teraz, gdy zaimportowałeś projekt do Android Studio, możesz uruchomić aplikację po raz pierwszy. Podłącz urządzenie z Androidem i kliknij Uruchom ( wykonaj.png ) na pasku narzędzi Android Studio.

Aplikacja powinna uruchomić się na Twoim urządzeniu. W tym momencie, jeśli spróbujesz narysować cyfrę, aplikacja powinna ją rozpoznać.

6e36e1b947b395f2.png

5. Utwórz projekt konsoli Firebase

Dodaj Firebase do projektu

  1. Przejdź do konsoli Firebase .
  2. Wybierz opcję Dodaj projekt .
  3. Wybierz lub wprowadź nazwę projektu.
  4. Wykonaj pozostałe kroki konfiguracji w konsoli Firebase, a następnie kliknij Utwórz projekt (lub Dodaj Firebase, jeśli używasz istniejącego projektu Google).

6. Dodaj Firebase

  1. Na ekranie przeglądu nowego projektu kliknij ikonę Androida, aby uruchomić proces konfiguracji.
  2. Wprowadź nazwę pakietu laboratorium programistycznego: org.tensorflow.lite.examples.digitclassifier

Dodaj plik google-services.json do swojej aplikacji

Po zarejestrowaniu nazwy pakietu i wybraniu Dalej kliknij Pobierz google-services.json , aby uzyskać plik konfiguracyjny Firebase Android, a następnie skopiuj plik google-services.json do katalogu app w swoim projekcie. Po pobraniu pliku możesz pominąć kolejne kroki wyświetlane w konsoli (zostały one już wykonane za Ciebie w projekcie build-Android-start).

Dodaj wtyczkę usług Google do swojej aplikacji

Wtyczka google-services używa pliku google-services.json do skonfigurowania aplikacji do korzystania z Firebase. Dodaj następujący wiersz do bloku plugins na górze pliku build.gradle.kts w katalogu app swojego projektu:

app/build.gradle.kts

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

Następnie dodaj następujący wiersz do bloku plugins pliku build.gradle.kts w projekcie:

projekt/build.gradle.kts

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

Zsynchronizuj swój projekt z plikami gradle

Aby mieć pewność, że wszystkie zależności są dostępne dla Twojej aplikacji, powinieneś w tym momencie zsynchronizować swój projekt z plikami gradle. Wybierz opcję Plik > Synchronizuj projekt z plikami Gradle z paska narzędzi Android Studio.

7. Uruchom aplikację za pomocą Firebase

Teraz, gdy skonfigurowałeś wtyczkę google-services za pomocą pliku JSON, możesz uruchomić aplikację w Firebase. Podłącz urządzenie z Androidem i kliknij Uruchom ( wykonaj.png ) na pasku narzędzi Android Studio.

Aplikacja powinna uruchomić się na Twoim urządzeniu. W tym momencie Twoja aplikacja powinna nadal pomyślnie się kompilować.

8. Wdróż model w Firebase ML

Wdrażanie modelu w Firebase ML jest przydatne z dwóch głównych powodów:

  1. Możemy zachować niewielki rozmiar instalacji aplikacji i pobrać model tylko w razie potrzeby
  2. Model może być regularnie aktualizowany i mieć inny cykl wydawniczy niż cała aplikacja

Zanim będziemy mogli zastąpić model statyczny w naszej aplikacji modelem pobieranym dynamicznie z Firebase, musimy wdrożyć go w Firebase ML. Model można wdrożyć za pośrednictwem konsoli lub programowo przy użyciu pakietu Firebase Admin SDK. W tym kroku będziemy wdrażać za pośrednictwem konsoli.

Aby wszystko było proste, użyjemy modelu TensorFlow Lite, który jest już w naszej aplikacji. Najpierw otwórz konsolę Firebase i kliknij Uczenie maszynowe w lewym panelu nawigacyjnym. Kliknij „Rozpocznij”, jeśli otwierasz po raz pierwszy. Następnie przejdź do „Niestandardowy” i kliknij przycisk „Dodaj model niestandardowy”.

Po wyświetleniu monitu nadaj modelowi opisową nazwę, na przykład mnist_v1 i prześlij plik z katalogu projektu codelab pod start/app/src/main/assets/mnist.tflite . Następnie możesz usunąć ten plik modelu TF Lite z projektu Androida.

3c3c50e6ef12b3b.png

9. Pobierz model z Firebase ML

Wybór momentu pobrania zdalnego modelu z Firebase do aplikacji może być trudny, ponieważ modele TFLite mogą rosnąć stosunkowo duże. W idealnym przypadku chcielibyśmy uniknąć ładowania modelu natychmiast po uruchomieniu aplikacji, ponieważ jeśli nasz model będzie używany tylko do jednej funkcji, a użytkownik nigdy z niej nie skorzysta, pobierzemy znaczną ilość danych bez powodu. Możemy również ustawić opcje pobierania, takie jak pobieranie modeli tylko po podłączeniu do Wi-Fi. Jeśli chcesz mieć pewność, że model będzie dostępny nawet bez połączenia sieciowego, ważne jest, aby zapakować go również bez aplikacji jako kopię zapasową.

Dla uproszczenia usuniemy domyślny model w pakiecie i zawsze pobierzemy model z Firebase po uruchomieniu aplikacji. W ten sposób podczas rozpoznawania cyfr możesz mieć pewność, że wnioskowanie działa na podstawie modelu dostarczonego z Firebase.

W pliku app/build.gradle.kts dodaj zależność Firebase Machine Learning

app/build.gradle.kts

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

Następnie dodaj logikę, aby pobrać model z Firebase.

Zastąpimy digitClassifier.initialize(loadModelFile()) metodą downloadModel("mnist_v1") i zaimplementujemy tę metodę.

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

Uruchom ponownie aplikację i narysuj cyfrę w klasyfikatorze cyfr. Po zakończeniu pobierania powinien zostać wyświetlony komunikat Toast informujący o pobraniu zdalnego modelu oraz dziennik wskazujący, że nowy model jest używany.

10. Śledź opinie użytkowników i konwersję, aby mierzyć dokładność modelu

Google Analytics dla Firebase pozwala zrozumieć, w jaki sposób użytkownicy poruszają się po Twojej aplikacji, gdzie odnoszą sukcesy, a gdzie utknęli i zawrócili. Można go również wykorzystać do zrozumienia najczęściej używanych części aplikacji.

Dokładność modelu będziemy mierzyć, śledząc opinie użytkowników na temat przewidywań modelu. Jeśli użytkownik kliknie „TAK”, będzie to oznaczać, że prognoza była trafna.

Możemy rejestrować zdarzenia Analytics, aby śledzić dokładność naszego modelu. Najpierw musimy dodać Analytics do zależności, zanim będzie można ją wykorzystać w projekcie:

Dodaj zależność Firebase Analytics

app/build.gradle.kts

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

Rejestruj zdarzenia

Następnie w funkcji onCreate ustawimy detektor onclick tak, aby rejestrował zdarzenie correct_inference w Firebase.

MainActivity.kt (onCreate)

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

Uruchom aplikację ponownie i narysuj cyfrę. Naciśnij kilka razy przycisk „Tak”, aby przesłać informację zwrotną potwierdzającą, że wnioski były trafne.

Analityka debugowania

Ogólnie rzecz biorąc, zdarzenia rejestrowane przez Twoją aplikację są grupowane w okresie około jednej godziny i przesyłane razem. Takie podejście oszczędza baterię urządzeń użytkowników końcowych i zmniejsza zużycie danych w sieci. Jednakże w celu sprawdzenia poprawności implementacji analiz (oraz w celu wyświetlenia statystyk w raporcie DebugView) możesz włączyć tryb debugowania na swoim urządzeniu programistycznym, aby przesyłać zdarzenia z minimalnym opóźnieniem.

Aby włączyć tryb debugowania Analytics na urządzeniu z Androidem, wykonaj następujące polecenia:

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

Uruchom aplikację ponownie i narysuj cyfrę. Naciśnij kilka razy przycisk „Tak”, aby przesłać informację zwrotną potwierdzającą, że wnioski były trafne. Teraz możesz przeglądać zdarzenia w dzienniku w czasie zbliżonym do rzeczywistego, korzystając z widoku debugowania w konsoli Firebase. Kliknij Analytics > DebugView na lewym pasku nawigacyjnym.

5276199a086721fd.png

11. Analiza wydajności modelu

Monitorowanie wydajności Firebase to usługa, która pomaga uzyskać wgląd w charakterystykę wydajności aplikacji na iOS, Androida i aplikacje internetowe.

Za pomocą zestawu SDK do monitorowania wydajności zbierasz dane dotyczące wydajności swojej aplikacji, a następnie przeglądasz i analizujesz te dane w konsoli Firebase. Monitorowanie wydajności pomaga zrozumieć, gdzie i kiedy można poprawić wydajność aplikacji, dzięki czemu można wykorzystać te informacje do rozwiązania problemów z wydajnością.

Tutaj dodajemy ślady wydajności wokół wnioskowania i pobierania

Jest to ważne, ponieważ większe modele stosowane w głębokim uczeniu się mogą być dokładniejsze, ale zwrócenie odpowiedzi może zająć więcej czasu. W naszym eksperymencie staramy się znaleźć właściwą równowagę pomiędzy dokładnością i szybkością.

Dodaj zależność wydajności Firebase

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

Dodaj niestandardowe ślady

W funkcji setupDigitClassifier() utwórz nowy downloadTrace i uruchom go tuż przed pobraniem modelu. Następnie dodaj odbiornik onsuccess zatrzymujący śledzenie.

W funkcji classifyDrawing() utwórz nowy classifyTrace i uruchom go tuż przed klasyfikacją. Następnie zatrzymaj śledzenie w odbiorniku onsuccess.

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)
        }
    }
  }

Wyświetl komunikaty dziennika dotyczące zdarzeń związanych z wydajnością

  1. Włącz rejestrowanie debugowania dla monitorowania wydajności w czasie kompilacji, dodając element <meta-data> do pliku AndroidManifest.xml swojej aplikacji, w następujący sposób:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>
  1. Sprawdź komunikaty dziennika pod kątem komunikatów o błędach.
  2. Performance Monitoring oznacza swoje komunikaty dziennika za pomocą FirebasePerformance . Korzystając z filtrowania logcat, możesz w szczególności wyświetlić śledzenie czasu trwania i rejestrowanie żądań sieciowych HTTP/S, uruchamiając następujące polecenie:
adb logcat -s FirebasePerformance
  1. Sprawdź następujące typy dzienników wskazujące, że Monitorowanie wydajności rejestruje zdarzenia dotyczące wydajności:
  • Logging TraceMetric
  • Logging NetworkRequestMetric

12. Wdróż drugi model w Firebase ML

Tworząc nową wersję modelu, na przykład z lepszą architekturą modelu lub wyszkoloną na większym lub zaktualizowanym zbiorze danych, możemy poczuć pokusę zastąpienia naszego obecnego modelu nową wersją. Jednak model dobrze radzący sobie w testach niekoniecznie radzi sobie równie dobrze w produkcji. Dlatego wykonajmy testy A/B na produkcji, aby porównać nasz oryginalny model z nowym.

Włącz interfejs API zarządzania modelem Firebase

Na tym etapie umożliwimy interfejsowi API Firebase Model Management wdrożenie nowej wersji naszego modelu TensorFlow Lite przy użyciu kodu Python.

Utwórz zasobnik do przechowywania modeli uczenia maszynowego

W konsoli Firebase przejdź do opcji Pamięć i kliknij Rozpocznij. fbbea78f0eb3dc9f.png

Postępuj zgodnie z instrukcjami, aby skonfigurować wiadro.

19517c0d6d2aa14d.png

Włącz interfejs API Firebase ML

Przejdź do strony Firebase ML API w Google Cloud Console i kliknij Włącz.

2414fd5cced6c984.png Gdy zostaniesz o to poproszony, wybierz aplikację Digit Classifier.

Wytrenuj nowy model i opublikuj w Firebase ML

Teraz przeszkolimy nową wersję modelu przy użyciu większego zestawu danych, a następnie wdrożymy go programowo bezpośrednio z notatnika szkoleniowego przy użyciu pakietu Firebase Admin SDK.

Pobierz klucz prywatny dla konta usługi

Zanim będziemy mogli korzystać z pakietu Firebase Admin SDK, musimy utworzyć konto usługi. Otwórz panel Konta usług w konsoli Firebase, klikając ten link i kliknij przycisk, aby utworzyć nowe konto usługi dla pakietu Firebase Admin SDK. Po wyświetleniu monitu kliknij przycisk Wygeneruj nowy klucz prywatny. Będziemy używać klucza konta usługi do uwierzytelniania naszych żądań z notatnika Colab.

c3b95de1e5508516.png

Teraz możemy wytrenować i wdrożyć nowy model.

  1. Otwórz ten notatnik Colab i utwórz jego kopię na swoim dysku.
  2. Uruchom pierwszą komórkę „Wytrenuj ulepszony model TensorFlow Lite”, klikając przycisk odtwarzania po lewej stronie. Spowoduje to wytrenowanie nowego modelu i może zająć trochę czasu.
  3. Uruchomienie drugiej komórki spowoduje wyświetlenie monitu o przesłanie pliku. Prześlij plik json pobrany z konsoli Firebase podczas tworzenia konta usługi.

71e847c6a85423b3.png

  1. Uruchom dwie ostatnie komórki.

Po uruchomieniu notatnika colab powinieneś zobaczyć drugi model w konsoli Firebase. Upewnij się, że drugi model ma nazwę mnist_v2 .

c316683bb4d75d57.png

13. Wybierz model poprzez Zdalną konfigurację

Teraz, gdy mamy dwa oddzielne modele, dodamy parametr umożliwiający wybranie modelu do pobrania w czasie wykonywania. Wartość parametru, którą otrzyma klient, określi, który model klient pobierze.

Dodaj reguły konfiguracji w konsoli Firebase

Najpierw otwórz konsolę Firebase i kliknij przycisk Zdalna konfiguracja w lewym menu nawigacyjnym. Następnie kliknij przycisk „Dodaj parametr”.

Nazwij nowy parametr model_name i nadaj mu domyślną wartość "mnist_v1" . Umieszczając nazwę modelu w parametrze zdalnej konfiguracji, możemy przetestować wiele modeli bez dodawania nowego parametru dla każdego modelu, który chcemy przetestować. Kliknij Opublikuj zmiany , aby zastosować aktualizacje.

2949cb95c7214ca4.png

Dodaj zależność Firebase RemoteConfig

app/build.gradle.kts

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

Skonfiguruj zdalną konfigurację Firebase

MainActivity.kt

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

Poproś i użyj konfiguracji

Utwórz żądanie pobrania konfiguracji i dodaj procedurę obsługi zakończenia, aby pobrać i użyć parametrów konfiguracyjnych.

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

Przetestuj zdalną konfigurację

  1. Kliknij 98205811bed9d74.png Przycisk Uruchom .
  2. Sprawdź, czy został wyświetlony komunikat Toast informujący o pobraniu modelu mnist_v1.
  3. Wróć do konsoli Firebase, zmień wartość domyślną na mnist_v2 i wybierz Opublikuj zmiany , aby zastosować aktualizacje.
  4. Uruchom ponownie aplikację i sprawdź, czy wyświetlił się komunikat Toast, że tym razem został pobrany model mnist_v2.

14. Skuteczność modelu testów A/B

Testy A/B Firebase pomagają zoptymalizować działanie aplikacji, ułatwiając przeprowadzanie, analizowanie i skalowanie eksperymentów produktowych i marketingowych. Wreszcie możemy użyć wbudowanego w Firebase testu A/B, aby sprawdzić, który z naszych dwóch modeli działa lepiej.

Przejdź do Analytics -> Zdarzenia w konsoli Firebase. Jeśli wyświetla się zdarzenie correct_inference , oznacz je jako „Zdarzenie konwersji”. Jeśli nie, możesz przejść do Analityka -> Zdarzenia konwersji i kliknąć „Utwórz nowe zdarzenie konwersji” i zapisać correct_inference.

Teraz przejdź do „Zdalnej konfiguracji” w konsoli Firebase, wybierz przycisk „Test A/B” z menu więcej opcji w właśnie dodanym parametrze „nazwa_modelu”.

fad5ea36969d2aeb.png

W następnym menu zaakceptuj domyślną nazwę.

d7c006669ace6e40.png

Wybierz swoją aplikację z menu rozwijanego i zmień kryteria kierowania na 50% aktywnych użytkowników.

cb72dcc7d2666bd3.png

Jeśli udało Ci się wcześniej ustawić zdarzenie correct_inference jako konwersję, użyj tego zdarzenia jako podstawowego wskaźnika do śledzenia. W przeciwnym razie, jeśli nie chcesz czekać, aż zdarzenie pojawi się w Analytics, możesz manually dodać correct_inference .

1ac9c94fb3159271.png

Na koniec na ekranie Warianty ustaw wariant grupy kontrolnej na użycie mnist_v1 i grupę Wariant A na używanie mnist_v2 .

e4510434f8da31b6.png

Kliknij przycisk Recenzja w prawym dolnym rogu.

Gratulacje, pomyślnie utworzyłeś test A/B dla swoich dwóch oddzielnych modeli! Test A/B jest obecnie w wersji roboczej i można go rozpocząć w dowolnym momencie, klikając przycisk „Rozpocznij eksperyment”.

Aby bliżej przyjrzeć się testom A/B, zapoznaj się z dokumentacją testów A/B .

15. Gratulacje!

Podczas tych ćwiczeń z programowania nauczyłeś się, jak zastąpić statycznie powiązany zasób tflite w swojej aplikacji dynamicznie ładowanym modelem TFLite z Firebase. Aby dowiedzieć się więcej o TFLite i Firebase, zapoznaj się z innymi przykładami TFLite i przewodnikami wprowadzającymi do Firebase.

Co omówiliśmy

  • TensorFlow Lite
  • Baza Firebase ML
  • Analityka Firebase
  • Monitorowanie wydajności Firebase
  • Zdalna konfiguracja Firebase
  • Testy A/B Firebase

Następne kroki

  • Zaimplementuj wdrożenie Firebase ML w swojej aplikacji.

Ucz się więcej

Mam pytanie?

Zgłoś problemy