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. Auf diese Weise 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 mit einem statischen TFLite-Modell in eine App mit einem Modell, das dynamisch von Firebase bereitgestellt wird.

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
  • Profilmodellleistung über Firebase Performance
  • Wählen Sie aus, welches von mehreren bereitgestellten Modellen über Remote Config geladen wird
  • Experimentieren Sie mit verschiedenen Modellen über Firebase A/B-Tests

Was du brauchen wirst

  • Android Studio-Version 3.4+.
  • Beispielcode.
  • Ein Testgerät mit Android 2.3+ 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äts ein Verbindungskabel.

Wie werden Sie dieses Tutorial verwenden?

Nur durchlesen Lies es und vervollständige die Übungen

Wie würden Sie Ihre Erfahrung beim Erstellen 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 codelab-digitclassifier-android ( 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 in Android Studio importiert haben, können Sie die App zum ersten Mal ausführen. Verbinden Sie Ihr Android-Gerät und klicken Sie auf Ausführen ( ausführen.png ) in der Symbolleiste von Android Studio.

Die App sollte auf Ihrem Gerät starten. Wenn Sie zu diesem Zeitpunkt versuchen, eine Ziffer zu zeichnen, sollte die App diese erkennen können.

6e36e1b947b395f2.png

5. Erstellen Sie ein Firebase-Konsolenprojekt

Fügen Sie dem Projekt Firebase hinzu

  1. Gehen Sie zur Firebase-Konsole .
  2. Wählen Sie Projekt hinzufügen aus .
  3. Wählen Sie einen Projektnamen aus oder geben Sie einen 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. Fügen Sie Firebase hinzu

  1. Klicken Sie auf dem Übersichtsbildschirm Ihres neuen Projekts auf das Android-Symbol, um den Einrichtungsablauf 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 Download google-services.json , um Ihre Firebase-Android-Konfigurationsdatei abzurufen, und 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 Plug-in für Google-Dienste hinzu

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

app/build.gradle

apply plugin: 'com.google.gms.google-services'

Fügen Sie dann die folgende Zeile zum Abschnitt " dependencies " Ihrer build.gradle-Datei im Projekt hinzu:

project/build.gradle

classpath 'com.google.gms:google-services:4.3.3'

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 Symbolleiste von Android Studio Datei > Projekt mit Gradle-Dateien synchronisieren.

7. Führen Sie die App mit Firebase aus

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

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

8. Stellen Sie ein Modell in Firebase ML bereit

Das Bereitstellen eines Modells in Firebase ML ist aus zwei Hauptgründen nützlich:

  1. Wir können die App-Installationsgröße 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 mithilfe des Firebase Admin SDK bereitgestellt werden. In diesem Schritt werden wir über die Konsole bereitstellen.

Der Einfachheit halber verwenden wir das TensorFlow Lite-Modell, das bereits in unserer App enthalten ist. Öffnen Sie zunächst die Firebase Console und klicken Sie im linken Navigationsbereich auf Machine Learning. Klicken Sie auf „Erste Schritte“, wenn Sie die Seite 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 aussagekräftigen Namen wie mnist_v1 und laden Sie die Datei aus dem Codelab-Projektverzeichnis unter start/app/src/main/assets/mnist.tflite . Dann 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 Menge an Daten heruntergeladen. Wir können auch Download-Optionen festlegen, z. B. Modelle nur abrufen, wenn sie mit WLAN verbunden sind. Wenn Sie sicherstellen möchten, dass das Modell auch ohne Netzwerkverbindung verfügbar ist, ist es wichtig, es auch ohne die App als Backup zu bündeln.

Der Einfachheit halber entfernen wir das standardmäßig gebündelte Modell und laden immer ein Modell von Firebase herunter, wenn die App gestartet wird. Auf diese Weise können Sie beim Ausführen 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 die Firebase Machine Learning-Abhängigkeit hinzu

app/build.gradle

implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.3'

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 setupDigitClassifier() {
    downloadModel("mnist_v1")
  }

  private fun downloadModel(modelName: String): Task<Void> {
    val remoteModel = FirebaseCustomRemoteModel.Builder(modelName).build()
    val firebaseModelManager = FirebaseModelManager.getInstance()
    return firebaseModelManager
      .isModelDownloaded(remoteModel)
      .continueWithTask { task ->
        // Create update condition if model is already downloaded, otherwise create download
        // condition.
        val conditions = if (task.result != null && task.result == true) {
          FirebaseModelDownloadConditions.Builder()
            .requireWifi()
            .build() // Update condition that requires wifi.
        } else {
          FirebaseModelDownloadConditions.Builder().build(); // Download condition.
        }
        firebaseModelManager.download(remoteModel, conditions)
      }
      .addOnSuccessListener {
        firebaseModelManager.getLatestModelFile(remoteModel)
          .addOnCompleteListener {
            val model = it.result
            if (model == null) {
              showToast("Failed to get model file.")
            } else {
              showToast("Downloaded remote model: $model")
              digitClassifier.initialize(model)
            }
          }
      }
      .addOnFailureListener {
        showToast("Model download failed for digit classifier, please check your connection.")
      }
  }

Führen Sie Ihre App erneut aus und zeichnen Sie eine Ziffer in den 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 das Feedback und die Konvertierung von Benutzern, um die Modellgenauigkeit zu messen

Google Analytics for Firebase bietet Ihnen eine Möglichkeit zu verstehen, wie sich Benutzer 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 messen die Genauigkeit des Modells, indem wir das Benutzerfeedback zu Modellvorhersagen verfolgen. Wenn ein Benutzer auf „JA“ klickt, zeigt dies an, 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:

Fügen Sie eine Firebase Analytics-Abhängigkeit hinzu

app/build.gradle

implementation 'com.google.firebase:firebase-analytics-ktx:17.4.1'

Ereignisse protokollieren

Dann legen wir bei der Funktion onCreate den Listener correct_inference in Firebase zu protokollieren.

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 einige Male auf die Schaltfläche "Ja", um eine Rückmeldung zu senden, dass die Schlussfolgerung korrekt war.

Debug-Analyse

Im Allgemeinen werden von Ihrer App protokollierte Ereignisse über einen Zeitraum von etwa einer Stunde zusammengefasst und zusammen hochgeladen. Dieser Ansatz schont den Akku auf den Geräten der Endbenutzer und reduziert die Netzwerkdatennutzung. Um Ihre Analyseimplementierung zu validieren (und um Ihre Analyse im DebugView-Bericht anzuzeigen), können Sie jedoch den Debug-Modus auf Ihrem Entwicklungsgerät aktivieren, um Ereignisse mit minimaler Verzögerung hochzuladen.

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

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 einige Male auf 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 Leistungsüberwachungs-SDK, um Leistungsdaten von Ihrer App zu erfassen, und überprüfen und analysieren diese Daten dann in der Firebase-Konsole. Die Leistungsüberwachung hilft Ihnen zu verstehen, wo und wann die Leistung Ihrer App verbessert werden kann, damit Sie diese Informationen verwenden können, um Leistungsprobleme zu beheben.

Hier fügen wir Leistungsspuren um Inferenz und Download hinzu

Dies ist wichtig, da größere Modelle, die beim Deep Learning verwendet werden, möglicherweise genauer sind, aber auch länger dauern können, 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

buildscript {

  // ...

    dependencies {
      // ...

      // Add the dependency for the Performance Monitoring plugin
      classpath 'com.google.firebase:perf-plugin:1.3.1'  // Performance Monitoring plugin
    }
}

app/build.gradle

// Apply the Performance Monitoring plugin
apply plugin: 'com.google.firebase.firebase-perf'

// ...

dependencies {
  // ...

  // Add the dependency for the Performance Monitoring library
  implementation 'com.google.firebase:firebase-perf:19.0.7'
}

Fügen Sie benutzerdefinierte Ablaufverfolgungen hinzu

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

Erstellen Sie in der Funktion classifyDrawing() ein neues classifyTrace und starten Sie es direkt vor der Klassifizierung. Stoppen Sie dann die Ablaufverfolgung 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)
        }
    }
  }

Anzeigen von Protokollmeldungen für Leistungsereignisse

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

AndroidManifest.xml

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

12. Stellen Sie ein zweites Modell in Firebase ML bereit

Wenn Sie eine neue Version Ihres Modells entwickeln, z. B. eine mit besserer Modellarchitektur oder eine, die auf einem größeren oder aktualisierten Datensatz trainiert wurde, fühlen wir uns möglicherweise versucht, unser aktuelles Modell durch die neue Version zu ersetzen. Ein Modell, das beim Testen gut abschneidet, muss jedoch nicht unbedingt genauso gut in der Produktion abschneiden. Lassen Sie uns daher A/B-Tests in der Produktion durchführen, um unser ursprüngliches Modell und das neue 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 Bucket einzurichten.

19517c0d6d2aa14d.png

Aktivieren Sie die Firebase ML-API

Gehen Sie in der Google Cloud Console zur Firebase ML API-Seite 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 Datasets und stellen es dann programmgesteuert direkt aus dem Trainingsnotebook mithilfe des Firebase Admin SDK 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 das Bedienfeld „Dienstkonten“ der Firebase-Konsole, indem Sie auf diesen Link klicken, und klicken Sie auf die Schaltfläche, 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 zum Authentifizieren unserer Anforderungen aus dem Colab-Notebook.

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 Drive.
  2. Führen Sie die erste Zelle „Trainieren eines verbesserten TensorFlow Lite-Modells“ aus, indem Sie auf die Wiedergabeschaltfläche links davon klicken. Dadurch wird ein neues Modell trainiert, was einige Zeit in Anspruch nehmen kann.
  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 ein zweites Modell in der Firebase-Konsole sehen. Stellen Sie sicher, dass das zweite Modell mnist_v2 .

c316683bb4d75d57.png

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

Da wir nun zwei separate Modelle haben, fügen wir einen Parameter hinzu, um auszuwählen, welches Modell zur Laufzeit heruntergeladen werden soll. Der Wert des Parameters, den der Client erhält, 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 Config. 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

implementation 'com.google.firebase:firebase-config-ktx:19.1.4'

Konfigurieren Sie Firebase Remote Config

MainActivity.kt

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

Konfig 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 mnist_v1-Modell heruntergeladen wurde.
  3. Gehen Sie zurück zur Firebase Console, ändern Sie den Standardwert in mnist_v2 und wählen Sie Änderungen veröffentlichen aus, um die Aktualisierungen anzuwenden.
  4. Starten Sie die App neu und prüfen Sie, ob die Toast-Meldung angezeigt wird, dass das mnist_v2-Modell dieses Mal heruntergeladen wird.

14. Wirksamkeit des A/B-Testmodells

Firebase A/B-Tests helfen Ihnen, Ihr App-Erlebnis zu optimieren, indem Sie Produkt- und Marketingexperimente einfach ausführen, analysieren und skalieren können. Schließlich können wir das integrierte A/B-Testverhalten von Firebase verwenden, um zu sehen, welches unserer beiden Modelle besser abschneidet.

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

Gehen Sie nun zu „Remote Config“ in der Firebase-Konsole, 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 Ihre App in der Dropdown-Liste aus und ändern Sie die Ausrichtungskriterien 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 zu verfolgende Metrik. Andernfalls, wenn Sie nicht warten möchten, bis das Ereignis in Analytics angezeigt wird, können Sie correct_inference manually hinzufügen.

1ac9c94fb3159271.png

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

e4510434f8da31b6.png

Klicken Sie auf die Schaltfläche Überprüfen in der unteren rechten Ecke.

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-Erste-Schritte-Leitfä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.

Lern mehr

Eine Frage haben?

Probleme melden