Fügen Sie Firebase zu Ihrer TFLite-basierten Android-App hinzu

1. Übersicht

cd824ecfd05a2822.png

Mit Firebase ML können Sie Ihr Modell drahtlos bereitstellen. Dadurch können Sie die App-Größe klein halten und das ML-Modell nur bei Bedarf herunterladen, mit mehreren Modellen experimentieren oder Ihr ML-Modell aktualisieren, ohne die gesamte App erneut veröffentlichen zu müssen.

In diesem Codelab konvertieren Sie eine Android-App, die ein statisches TFLite-Modell verwendet, in eine App, die ein dynamisch von Firebase bereitgestelltes Modell verwendet.

Was Sie lernen werden

  • Stellen Sie TFLite-Modelle in Firebase ML bereit und greifen Sie über Ihre App darauf zu
  • Verfolgen Sie Benutzerfeedback, um die Modellgenauigkeit mit Firebase Analytics zu messen
  • Profilieren Sie die Modellleistung über Firebase Performance
  • Wählen Sie aus, welches der mehreren bereitgestellten Modelle über Remote Config geladen wird
  • Experimentieren Sie mit verschiedenen Modellen über Firebase A/B Testing

Was du brauchen wirst

  • Neueste Android Studio- Version.
  • Beispielcode.
  • Ein Testgerät mit Android 5.0+ und Google Play-Diensten 9.8 oder höher oder ein Emulator mit Google Play-Diensten 9.8 oder höher
  • Bei Verwendung eines Gerätes ein Verbindungskabel.

Wie werden Sie dieses Tutorial nutzen?

Lesen Sie es nur durch Lesen Sie es und absolvieren Sie die Übungen

Wie würden Sie Ihre Erfahrungen mit der Entwicklung von Android-Apps bewerten?

Anfänger Dazwischenliegend Kompetent

2. Holen Sie sich den Beispielcode

Klonen Sie das GitHub-Repository über die Befehlszeile.

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

Wenn Sie Git nicht installiert haben, können Sie das Beispielprojekt auch von der GitHub-Seite herunterladen oder auf diesen Link klicken.

3. Importieren Sie die Starter-App

Wählen Sie in Android Studio das Verzeichnis codelab-digitclassifier-android aus ( android_studio_folder.png ) aus dem Beispielcode-Download ( Datei > Öffnen > .../codelab-digitclassifier-android/start).

Sie sollten nun das Startprojekt in Android Studio geöffnet haben.

4. Führen Sie die Starter-App aus

Nachdem Sie das Projekt nun in Android Studio importiert haben, können Sie die App zum ersten Mal ausführen. Schließen Sie Ihr Android-Gerät an und klicken Sie auf Ausführen ( ausführen.png )in der Android Studio-Symbolleiste.

Die App sollte auf Ihrem Gerät gestartet werden. Wenn Sie jetzt versuchen, eine Ziffer zu zeichnen, sollte die App diese erkennen können.

6e36e1b947b395f2.png

5. Erstellen Sie ein Firebase-Konsolenprojekt

Fügen Sie Firebase zum Projekt hinzu

  1. Gehen Sie zur Firebase-Konsole .
  2. Wählen Sie Projekt hinzufügen .
  3. Wählen Sie einen Projektnamen aus oder geben Sie ihn ein.
  4. Befolgen Sie die verbleibenden Einrichtungsschritte in der Firebase-Konsole und klicken Sie dann auf Projekt erstellen (oder Firebase hinzufügen, wenn Sie ein vorhandenes Google-Projekt verwenden).

6. Firebase hinzufügen

  1. Klicken Sie im Übersichtsbildschirm Ihres neuen Projekts auf das Android-Symbol, um den Einrichtungsworkflow zu starten.
  2. Geben Sie den Paketnamen des Codelabs ein: org.tensorflow.lite.examples.digitclassifier

Fügen Sie Ihrer App die Datei „google-services.json“ hinzu

Nachdem Sie den Paketnamen registriert und Weiter ausgewählt haben, klicken Sie auf „Google-services.json herunterladen“ , um Ihre Firebase-Android-Konfigurationsdatei zu erhalten. Kopieren Sie dann die Datei „google-services.json“ in das app Verzeichnis in Ihrem Projekt. Nachdem die Datei heruntergeladen wurde, können Sie die nächsten in der Konsole angezeigten Schritte überspringen (sie wurden bereits im Build-Android-Start-Projekt für Sie erledigt).

Fügen Sie Ihrer App das Google-Services-Plugin hinzu

Das Google-Services-Plugin verwendet die Datei google-services.json, um Ihre Anwendung für die Verwendung von Firebase zu konfigurieren. Fügen Sie die folgende Zeile zum plugins Block oben in der Datei build.gradle.kts im app Verzeichnis Ihres Projekts hinzu:

app/build.gradle.kts

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

Fügen Sie dann die folgende Zeile zum plugins Block Ihrer build.gradle.kts-Datei im Projekt hinzu:

project/build.gradle.kts

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

Synchronisieren Sie Ihr Projekt mit Gradle-Dateien

Um sicherzustellen, dass alle Abhängigkeiten für Ihre App verfügbar sind, sollten Sie Ihr Projekt an dieser Stelle mit Gradle-Dateien synchronisieren. Wählen Sie in der Android Studio-Symbolleiste Datei > Projekt mit Gradle-Dateien synchronisieren .

7. Führen Sie die App mit Firebase aus

Nachdem Sie nun das google-services -Plugin mit Ihrer JSON-Datei konfiguriert haben, können Sie die App mit Firebase ausführen. Schließen Sie Ihr Android-Gerät an und klicken Sie auf Ausführen ( ausführen.png )in der Android Studio-Symbolleiste.

Die App sollte auf Ihrem Gerät gestartet werden. Zu diesem Zeitpunkt sollte Ihre App immer noch erfolgreich erstellt werden.

8. Stellen Sie ein Modell für Firebase ML bereit

Die Bereitstellung eines Modells in Firebase ML ist aus zwei Hauptgründen nützlich:

  1. Wir können die Installationsgröße der App klein halten und das Modell nur bei Bedarf herunterladen
  2. Das Modell kann regelmäßig und mit einem anderen Release-Zyklus als die gesamte App aktualisiert werden

Bevor wir das statische Modell in unserer App durch ein dynamisch heruntergeladenes Modell von Firebase ersetzen können, müssen wir es in Firebase ML bereitstellen. Das Modell kann entweder über die Konsole oder programmgesteuert mit dem Firebase Admin SDK bereitgestellt werden. In diesem Schritt führen wir die Bereitstellung über die Konsole durch.

Der Einfachheit halber verwenden wir das TensorFlow Lite-Modell, das bereits in unserer App enthalten ist. Öffnen Sie zunächst die Firebase-Konsole und klicken Sie im linken Navigationsbereich auf Machine Learning. Klicken Sie auf „Erste Schritte“, wenn Sie es zum ersten Mal öffnen. Navigieren Sie dann zu „Benutzerdefiniert“ und klicken Sie auf die Schaltfläche „Benutzerdefiniertes Modell hinzufügen“.

Wenn Sie dazu aufgefordert werden, geben Sie dem Modell einen beschreibenden Namen wie mnist_v1 und laden Sie die Datei aus dem Codelab-Projektverzeichnis unter start/app/src/main/assets/mnist.tflite hoch. Anschließend können Sie diese TF Lite-Modelldatei aus dem Android-Projekt löschen.

3c3c50e6ef12b3b.png

9. Laden Sie das Modell von Firebase ML herunter

Die Entscheidung, wann das Remote-Modell von Firebase in Ihre App heruntergeladen werden soll, kann schwierig sein, da TFLite-Modelle relativ groß werden können. Idealerweise möchten wir vermeiden, das Modell sofort beim Start der App zu laden, denn wenn unser Modell nur für eine Funktion verwendet wird und der Benutzer diese Funktion nie verwendet, haben wir ohne Grund eine erhebliche Datenmenge heruntergeladen. Wir können auch Download-Optionen festlegen, z. B. dass Modelle nur dann abgerufen werden, wenn eine WLAN-Verbindung besteht. Wenn Sie sicherstellen möchten, dass das Modell auch ohne Netzwerkverbindung verfügbar ist, ist es wichtig, es auch ohne App als Backup zu bündeln.

Der Einfachheit halber entfernen wir das standardmäßig gebündelte Modell und laden beim Start der App immer ein Modell von Firebase herunter. Auf diese Weise können Sie bei der Ausführung der Ziffernerkennung sicher sein, dass die Inferenz mit dem von Firebase bereitgestellten Modell ausgeführt wird.

Fügen Sie in der Datei app/build.gradle.kts die Firebase Machine Learning-Abhängigkeit hinzu

app/build.gradle.kts

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

Fügen Sie dann Logik hinzu, um das Modell von Firebase herunterzuladen.

Wir ersetzen digitClassifier.initialize(loadModelFile()) durch downloadModel("mnist_v1") und implementieren diese Methode.

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

Führen Sie Ihre App erneut aus und zeichnen Sie eine Ziffer im Ziffernklassifikator. Sobald der Download abgeschlossen ist, sollten Sie eine Toast-Meldung sehen, dass das Remote-Modell heruntergeladen wurde, und ein Protokoll, das angibt, dass Ihr neues Modell verwendet wird.

10. Verfolgen Sie Benutzerfeedback und Konvertierung, um die Modellgenauigkeit zu messen

Google Analytics für Firebase bietet Ihnen die Möglichkeit zu verstehen, wie sich Nutzer durch Ihre Anwendung bewegen, wo sie erfolgreich sind und wo sie stecken bleiben und umkehren. Es kann auch verwendet werden, um die am häufigsten verwendeten Teile Ihrer Anwendung zu verstehen.

Wir werden die Genauigkeit des Modells messen, indem wir das Benutzerfeedback zu Modellvorhersagen verfolgen. Wenn ein Benutzer auf „JA“ klickt, bedeutet dies, dass die Vorhersage korrekt war.

Wir können ein Analytics-Ereignis protokollieren, um die Genauigkeit unseres Modells zu verfolgen. Zuerst müssen wir Analytics zur Abhängigkeit hinzufügen, bevor es im Projekt verwendet werden kann:

Firebase Analytics-Abhängigkeit hinzufügen

app/build.gradle.kts

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

Protokollereignisse

Dann stellen wir in der onCreate Funktion den Onclick-Listener so ein, dass das correct_inference Ereignis in Firebase protokolliert wird.

MainActivity.kt (onCreate)

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

Führen Sie die App erneut aus und zeichnen Sie eine Ziffer. Drücken Sie mehrmals die Schaltfläche „Ja“, um eine Rückmeldung zu senden, dass die Schlussfolgerung korrekt war.

Debug-Analysen

Im Allgemeinen werden von Ihrer App protokollierte Ereignisse über einen Zeitraum von etwa einer Stunde gebündelt und gemeinsam hochgeladen. Dieser Ansatz schont den Akku der Endbenutzergeräte und reduziert die Netzwerkdatennutzung. Zum Zwecke der Validierung Ihrer Analyseimplementierung (und um Ihre Analysen im DebugView-Bericht anzuzeigen) können Sie jedoch den Debug-Modus auf Ihrem Entwicklungsgerät aktivieren, um Ereignisse mit minimaler Verzögerung hochzuladen.

Um den Analytics-Debug-Modus auf einem Android-Gerät zu aktivieren, führen Sie die folgenden Befehle aus:

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

Führen Sie die App erneut aus und zeichnen Sie eine Ziffer. Drücken Sie mehrmals die Schaltfläche „Ja“, um eine Rückmeldung zu senden, dass die Schlussfolgerung korrekt war. Jetzt können Sie die Protokollereignisse nahezu in Echtzeit über die Debug-Ansicht in der Firebase-Konsole anzeigen. Klicken Sie in der linken Navigationsleiste auf Analytics > DebugView.

5276199a086721fd.png

11. Analysieren Sie die Leistung des Modells

Firebase Performance Monitoring ist ein Dienst, der Ihnen hilft, Einblick in die Leistungsmerkmale Ihrer iOS-, Android- und Web-Apps zu gewinnen.

Sie verwenden das Performance Monitoring SDK, um Leistungsdaten Ihrer App zu sammeln und diese Daten dann in der Firebase-Konsole zu überprüfen und zu analysieren. Die Leistungsüberwachung hilft Ihnen zu verstehen, wo und wann die Leistung Ihrer App verbessert werden kann, sodass Sie diese Informationen zur Behebung von Leistungsproblemen nutzen können.

Hier fügen wir Perf-Traces rund um Inferenz und Download hinzu

Dies ist wichtig, da größere Modelle, die beim Deep Learning verwendet werden, möglicherweise genauer sind, es aber auch länger dauern kann, bis sie eine Antwort zurückgeben. In unserem Experiment versuchen wir, die richtige Balance zwischen Genauigkeit und Geschwindigkeit zu finden.

Firebase-Leistungsabhängigkeit hinzufügen

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

Fügen Sie benutzerdefinierte Traces hinzu

Erstellen Sie in der Funktion setupDigitClassifier() einen neuen downloadTrace und starten Sie ihn unmittelbar vor dem Herunterladen des Modells. Fügen Sie dann einen Onsuccess-Listener hinzu, der den Trace stoppt.

Erstellen Sie in der Funktion classifyDrawing() ein neues „classifyTrace“ und starten Sie es unmittelbar vor der Klassifizierung. Stoppen Sie dann den Trace im Onsuccess-Listener.

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

Protokollmeldungen für Leistungsereignisse anzeigen

  1. Aktivieren Sie die Debug-Protokollierung für die Leistungsüberwachung zur Erstellungszeit, indem Sie ein <meta-data> -Element zur AndroidManifest.xml Datei Ihrer App hinzufügen, etwa so:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>
  1. Überprüfen Sie Ihre Protokollnachrichten auf etwaige Fehlermeldungen.
  2. Performance Monitoring markiert seine Protokollnachrichten mit FirebasePerformance . Mithilfe der Logcat-Filterung können Sie die Protokollierung der Dauerverfolgung und HTTP/S-Netzwerkanforderungen gezielt anzeigen, indem Sie den folgenden Befehl ausführen:
adb logcat -s FirebasePerformance
  1. Suchen Sie nach den folgenden Protokolltypen, die darauf hinweisen, dass Performance Monitoring Leistungsereignisse protokolliert:
  • Logging TraceMetric
  • Logging NetworkRequestMetric

12. Stellen Sie ein zweites Modell für Firebase ML bereit

Wenn wir eine neue Version Ihres Modells entwickeln, beispielsweise eine mit besserer Modellarchitektur oder eine, die auf einem größeren oder aktualisierten Datensatz trainiert wurde, könnten wir versucht sein, unser aktuelles Modell durch die neue Version zu ersetzen. Allerdings schneidet ein Modell, das beim Testen gut abschneidet, nicht zwangsläufig auch in der Produktion gleich gut ab. Führen wir daher A/B-Tests in der Produktion durch, um unser ursprüngliches Modell mit dem neuen zu vergleichen.

Aktivieren Sie die Firebase Model Management API

In diesem Schritt aktivieren wir die Firebase Model Management API, um eine neue Version unseres TensorFlow Lite-Modells mithilfe von Python-Code bereitzustellen.

Erstellen Sie einen Bucket zum Speichern Ihrer ML-Modelle

Gehen Sie in Ihrer Firebase-Konsole zu „Speicher“ und klicken Sie auf „Erste Schritte“. fbbea78f0eb3dc9f.png

Folgen Sie dem Dialog, um Ihren Eimer einzurichten.

19517c0d6d2aa14d.png

Aktivieren Sie die Firebase ML-API

Gehen Sie zur Seite „Firebase ML API“ in der Google Cloud Console und klicken Sie auf „Aktivieren“.

2414fd5cced6c984.png Wählen Sie die Digit Classifier-App aus, wenn Sie dazu aufgefordert werden.

Trainieren Sie ein neues Modell und veröffentlichen Sie es in Firebase ML

Jetzt trainieren wir eine neue Version des Modells mithilfe eines größeren Datensatzes und stellen sie dann mithilfe des Firebase Admin SDK programmgesteuert direkt aus dem Trainingsnotizbuch bereit.

Laden Sie den privaten Schlüssel für das Dienstkonto herunter

Bevor wir das Firebase Admin SDK verwenden können, müssen wir ein Dienstkonto erstellen. Öffnen Sie den Bereich „Dienstkonten“ der Firebase-Konsole, indem Sie auf diesen Link klicken und auf die Schaltfläche klicken, um ein neues Dienstkonto für das Firebase Admin SDK zu erstellen. Wenn Sie dazu aufgefordert werden, klicken Sie auf die Schaltfläche „Neuen privaten Schlüssel generieren“. Wir verwenden den Dienstkontoschlüssel zur Authentifizierung unserer Anfragen aus dem Colab-Notizbuch.

c3b95de1e5508516.png

Jetzt können wir das neue Modell trainieren und bereitstellen.

  1. Öffnen Sie dieses Colab-Notizbuch und erstellen Sie eine Kopie davon in Ihrem eigenen Laufwerk.
  2. Führen Sie die erste Zelle „Trainieren Sie ein verbessertes TensorFlow Lite-Modell“ aus, indem Sie links daneben auf die Wiedergabeschaltfläche klicken. Dies trainiert ein neues Modell und kann einige Zeit dauern.
  3. Wenn Sie die zweite Zelle ausführen, wird eine Aufforderung zum Hochladen einer Datei erstellt. Laden Sie die JSON-Datei hoch, die Sie beim Erstellen Ihres Dienstkontos von der Firebase Console heruntergeladen haben.

71e847c6a85423b3.png

  1. Führen Sie die letzten beiden Zellen aus.

Nachdem Sie das Colab-Notebook ausgeführt haben, sollten Sie in der Firebase-Konsole ein zweites Modell sehen. Stellen Sie sicher, dass das zweite Modell den Namen mnist_v2 trägt.

c316683bb4d75d57.png

13. Wählen Sie über Remote Config ein Modell aus

Da wir nun über zwei separate Modelle verfügen, fügen wir einen Parameter hinzu, um auszuwählen, welches Modell zur Laufzeit heruntergeladen werden soll. Der Wert des Parameters, den der Client empfängt, bestimmt, welches Modell der Client herunterlädt.

Fügen Sie Konfigurationsregeln in der Firebase-Konsole hinzu

Öffnen Sie zunächst die Firebase-Konsole und klicken Sie im linken Navigationsmenü auf die Schaltfläche „Remote-Konfiguration“. Klicken Sie dann auf die Schaltfläche „Parameter hinzufügen“.

Benennen Sie den neuen Parameter model_name und geben Sie ihm den Standardwert "mnist_v1" . Indem wir den Namen des Modells in den Remote-Konfigurationsparameter einfügen, können wir mehrere Modelle testen, ohne für jedes Modell, das wir testen möchten, einen neuen Parameter hinzuzufügen. Klicken Sie auf Änderungen veröffentlichen , um die Aktualisierungen anzuwenden.

2949cb95c7214ca4.png

Firebase RemoteConfig-Abhängigkeit hinzufügen

app/build.gradle.kts

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

Konfigurieren Sie die Firebase-Remotekonfiguration

MainActivity.kt

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

Konfiguration anfordern und verwenden

Erstellen Sie eine Abrufanforderung für die Konfiguration und fügen Sie einen Abschlusshandler hinzu, um die Konfigurationsparameter abzurufen und zu verwenden.

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

Testen Sie die Remote-Konfiguration

  1. Drücke den 98205811bbed9d74.png Schaltfläche „Ausführen“ .
  2. Überprüfen Sie, ob die Toast-Meldung angezeigt wird, dass das Modell mnist_v1 heruntergeladen wurde.
  3. Gehen Sie zurück zur Firebase-Konsole, ändern Sie den Standardwert in „mnist_v2“ und wählen Sie „Änderungen veröffentlichen“ , um die Updates anzuwenden.
  4. Starten Sie die App neu und prüfen Sie, ob die Toast-Meldung angezeigt wird, dass das Modell mnist_v2 dieses Mal heruntergeladen wird.

14. Wirksamkeit des A/B-Testmodells

Firebase A/B Testing hilft Ihnen, Ihr App-Erlebnis zu optimieren, indem es die Durchführung, Analyse und Skalierung von Produkt- und Marketingexperimenten vereinfacht. Schließlich können wir das integrierte A/B-Testverhalten von Firebase nutzen, um zu sehen, welches unserer beiden Modelle besser abschneidet.

Gehen Sie in der Firebase-Konsole zu Analytics -> Ereignisse. Wenn das Ereignis „ correct_inference angezeigt wird, markieren Sie es als „Conversion-Ereignis“. Wenn nicht, können Sie zu Analytics -> Conversion-Ereignisse gehen, auf „Neues Conversion-Ereignis erstellen“ klicken und correct_inference.

Gehen Sie nun zu „Remote Config“ in der Firebase-Konsole und wählen Sie die Schaltfläche „A/B-Test“ aus dem Menü „Weitere Optionen“ für den Parameter „model_name“, den wir gerade hinzugefügt haben.

fad5ea36969d2aeb.png

Übernehmen Sie im folgenden Menü den Standardnamen.

d7c006669ace6e40.png

Wählen Sie im Dropdown-Menü Ihre App aus und ändern Sie die Targeting-Kriterien auf 50 % der aktiven Benutzer.

cb72dcc7d2666bd3.png

Wenn Sie das Ereignis correct_inference zuvor als Conversion festlegen konnten, verwenden Sie dieses Ereignis als primäre Metrik zum Verfolgen. Andernfalls können Sie, wenn Sie nicht warten möchten, bis das Ereignis in Analytics angezeigt wird, correct_inference manually hinzufügen.

1ac9c94fb3159271.png

Stellen Sie schließlich auf dem Bildschirm „Varianten“ Ihre Kontrollgruppenvariante auf die Verwendung mnist_v1 und Ihre Variante-A-Gruppe auf die Verwendung von mnist_v2 ein.

e4510434f8da31b6.png

Klicken Sie unten rechts auf die Schaltfläche „Überprüfen“.

Herzlichen Glückwunsch, Sie haben erfolgreich einen A/B-Test für Ihre beiden separaten Modelle erstellt! Der A/B-Test befindet sich derzeit im Entwurfsstadium und kann jederzeit durch Klicken auf die Schaltfläche „Experiment starten“ gestartet werden.

Weitere Informationen zu A/B-Tests finden Sie in der Dokumentation zu A/B-Tests .

15. Herzlichen Glückwunsch!

In diesem Codelab haben Sie gelernt, wie Sie ein statisch gebündeltes TFLite-Asset in Ihrer App durch ein dynamisch geladenes TFLite-Modell von Firebase ersetzen. Um mehr über TFLite und Firebase zu erfahren, werfen Sie einen Blick auf andere TFLite-Beispiele und die Firebase-Einführungsleitfäden.

Was wir abgedeckt haben

  • TensorFlow Lite
  • Firebase ML
  • Firebase Analytics
  • Firebase-Leistungsüberwachung
  • Firebase-Remote-Konfiguration
  • Firebase A/B-Tests

Nächste Schritte

  • Implementieren Sie die Firebase ML-Bereitstellung in Ihrer App.

Erfahren Sie mehr

Eine Frage haben?

Probleme melden