Mit TensorFlow Lite und Firebase Empfehlungen in Ihrer App einfügen – iOS-Codelab

1. Übersicht

Hinweis:In diesem Codelab wird die TensorFlow Lite-Bibliothek verwendet. Es wird empfohlen, dass für neuen Code die Google AI Edge LiteRT-Bibliothek verwendet wird.

Willkommen beim Codelab „Empfehlungen mit TensorFlow Lite und Firebase“. In diesem Codelab erfahren Sie, wie Sie TensorFlow Lite und Firebase verwenden, um ein Empfehlungsmodell in Ihrer App bereitzustellen. Dieses Codelab basiert auf diesem TensorFlow Lite-Beispiel.

Mit Empfehlungen können Apps maschinelles Lernen nutzen, um jedem Nutzer die relevantesten Inhalte zu präsentieren. Dabei wird das bisherige Nutzerverhalten berücksichtigt, um Inhalte der App vorzuschlagen, mit denen der Nutzer in Zukunft interagieren könnte. Dazu wird ein Modell verwendet, das auf dem aggregierten Verhalten einer großen Anzahl anderer Nutzer trainiert wurde.

In dieser Anleitung wird gezeigt, wie Sie mit Firebase Analytics Daten von den Nutzern Ihrer App erfassen, aus diesen Daten ein Machine-Learning-Modell für Empfehlungen erstellen und dieses Modell dann in einer iOS-App verwenden, um Inferenz auszuführen und Empfehlungen zu erhalten. Insbesondere schlagen wir Filme vor, die sich ein Nutzer höchstwahrscheinlich ansehen würde, wenn man die Liste der Filme betrachtet, die er zuvor mit „Mag ich“ bewertet hat.

Lerninhalte

• Firebase Analytics in eine Android-App einbinden, um Daten zum Nutzerverhalten zu erheben
• Diese Daten in Google BigQuery exportieren
• Daten vorverarbeiten und ein TF Lite-Empfehlungsmodell trainieren
• TF Lite-Modell in Firebase ML bereitstellen und über Ihre App darauf zugreifen
• On-Device-Inferenz mit dem Modell ausführen, um Nutzern Empfehlungen zu geben

Voraussetzungen

• Xcode 11 oder höher
• CocoaPods 1.9.1 oder höher

Wie werden Sie diese Anleitung verwenden?

Nur lesen Lesen und Übungen durchführen

Wie würden Sie Ihre Erfahrung mit der Entwicklung von iOS-Apps bewerten?

Anfänger Mittelstufe Fortgeschritten

2. Firebase Console-Projekt erstellen

Firebase zum Projekt hinzufügen

5. Rufen Sie die Firebase Console auf.
6. Wählen Sie Create New Project (Neues Projekt erstellen) aus und geben Sie Ihrem Projekt den Namen „Firebase ML iOS Codelab“.

3. Beispielprojekt abrufen

Code herunterladen

Klonen Sie zuerst das Beispielprojekt und führen Sie pod update im Projektverzeichnis aus:

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

Wenn Sie Git nicht installiert haben, können Sie das Beispielprojekt auch von der GitHub-Seite oder über diesen Link herunterladen. Nachdem Sie das Projekt heruntergeladen haben, führen Sie es in Xcode aus und probieren Sie die Empfehlung aus, um ein Gefühl dafür zu bekommen, wie sie funktioniert.

Firebase einrichten

Folgen Sie der Dokumentation, um ein neues Firebase-Projekt zu erstellen. Wenn Sie Ihr Projekt haben, laden Sie die GoogleService-Info.plist-Datei Ihres Projekts aus der Firebase Console herunter und ziehen Sie sie in den Stamm des Xcode-Projekts.

Fügen Sie Firebase zu Ihrer Podfile-Datei hinzu und führen Sie „pod install“ aus.

pod 'FirebaseAnalytics'
pod 'FirebaseMLModelDownloader', '9.3.0-beta'
pod 'TensorFlowLiteSwift'

Importieren Sie Firebase in der didFinishLaunchingWithOptions-Methode von AppDelegate oben in der Datei.

import FirebaseCore

Fügen Sie einen Aufruf hinzu, um Firebase zu konfigurieren.

FirebaseApp.configure()

Führen Sie das Projekt noch einmal aus, um sicherzugehen, dass die App richtig konfiguriert ist und beim Start nicht abstürzt.

1. Achten Sie darauf, dass „Google Analytics für dieses Projekt aktivieren“ aktiviert ist.
2. Folgen Sie den verbleibenden Einrichtungsschritten in der Firebase Console und klicken Sie dann auf „Projekt erstellen“ (oder „Firebase hinzufügen“, wenn Sie ein vorhandenes Google-Projekt verwenden).

4. Firebase Analytics zur App hinzufügen

In diesem Schritt fügen Sie Firebase Analytics der App hinzu, um Daten zum Nutzerverhalten zu protokollieren (in diesem Fall, welche Filme ein Nutzer mag). Diese Daten werden in den nächsten Schritten aggregiert verwendet, um das Empfehlungsmodell zu trainieren.

Firebase Analytics in der App einrichten

Das LikedMoviesViewModel enthält Funktionen zum Speichern der Filme, die dem Nutzer gefallen. Jedes Mal, wenn der Nutzer einen neuen Film liked, möchten wir auch ein Analyseprotokollereignis senden, um dieses Like zu erfassen.

Fügen Sie den folgenden Code hinzu, um ein Analytics-Ereignis zu registrieren, wenn der Nutzer ein Video mit „Gefällt mir“ markiert.

AllMoviesCollectionViewController.swift

import FirebaseAnalytics
//


override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
//

if movie.liked == nil {
      movie.liked = true
      Analytics.logEvent(AnalyticsEventSelectItem, parameters: [AnalyticsParameterItemID: movie.id])
    } else {
      movie.liked?.toggle()
    }
       
}

5. Analytics-Integration testen

In diesem Schritt generieren wir Analytics-Ereignisse in der App und prüfen, ob sie an die Firebase Console gesendet werden.

Debug-Logging für Analytics aktivieren

In der Regel werden von Ihrer App erfasste Ereignisse über einen Zeitraum von etwa einer Stunde zusammengefasst und gemeinsam hochgeladen. So wird der Akku der Geräte der Endnutzer geschont und die Nutzung von Netzwerkdaten reduziert. Um Ihre Analytics-Implementierung zu validieren und Ihre Analytics-Daten im DebugView-Bericht zu sehen, können Sie den Debug-Modus auf Ihrem Entwicklungsgerät aktivieren, damit Ereignisse mit minimaler Verzögerung hochgeladen werden.

Wenn Sie den Fehlerbehebungsmodus für Analytics auf Ihrem Entwicklungsgerät aktivieren möchten, geben Sie das folgende Befehlszeilenargument in Xcode an:

-FIRDebugEnabled

Sie haben Firebase Analytics jetzt erfolgreich in Ihre App eingebunden. Wenn Nutzer Ihre App verwenden und Filme liken, werden ihre Likes aggregiert protokolliert. Wir verwenden diese aggregierten Daten im Rest dieses Codelabs, um unser Empfehlungsmodell zu trainieren. Im folgenden optionalen Schritt wird beschrieben, wie Sie dafür sorgen, dass dieselben Analytics-Ereignisse, die Sie in Logcat gesehen haben, auch in die Firebase Console übertragen werden. Sie können mit der nächsten Seite fortfahren.

Optional: Analytics-Ereignisse in der Firebase Console bestätigen

1. Rufen Sie die Firebase Console auf.
2. Wählen Sie unter „Analytics“ die Option DebugView aus.
3. Wählen Sie in Xcode Run (Ausführen) aus, um die App zu starten und einige Filme zur Liste „Gefällt mir“ hinzuzufügen.
4. Prüfen Sie in DebugView in der Firebase Console, ob diese Ereignisse protokolliert werden, wenn Sie Filme in der App hinzufügen.

HINWEIS:Es kann zu einer Verzögerung kommen, bevor die Analyseereignisse in der Firebase Console angezeigt werden.

6. Analytics-Daten in BigQuery exportieren

BigQuery ist ein Google Cloud-Produkt, mit dem Sie große Datenmengen untersuchen und verarbeiten können. In diesem Schritt verbinden Sie Ihr Firebase Console-Projekt mit BigQuery, damit die von Ihrer App generierten Analytics-Daten automatisch nach BigQuery exportiert werden.

BigQuery-Export aktivieren

1. Rufen Sie die Firebase Console auf.
2. Klicken Sie neben Projektübersicht auf das Zahnradsymbol für die Einstellungen und wählen Sie dann Projekteinstellungen aus.
3. Wählen Sie den Tab Integrationen aus.
4. Wählen Sie im Block BigQuery die Option Verknüpfen (oder Verwalten) aus.
5. Wählen Sie im Schritt Informationen zum Verknüpfen von Firebase mit BigQuery die Option Weiter aus.
6. Klicken Sie im Bereich Integration konfigurieren auf den Schalter, um das Senden von Google Analytics-Daten zu aktivieren, und wählen Sie Mit BigQuery verknüpfen aus.

Sie haben jetzt in Ihrem Firebase Console-Projekt die automatische Übertragung von Firebase Analytics-Ereignisdaten an BigQuery aktiviert. Das geschieht automatisch, ohne dass Sie etwas tun müssen. Allerdings kann es bis zu 24 Stunden dauern, bis das Analytics-Dataset in BigQuery erstellt wird. Nachdem das Dataset erstellt wurde, exportiert Firebase kontinuierlich neue Analytics-Ereignisse in die BigQuery-Tagesverlaufstabelle und gruppiert Ereignisse aus den vergangenen Tagen in der Ereignistabelle.

Für das Training eines Empfehlungsmodells sind viele Daten erforderlich. Da wir noch keine App haben, die große Datenmengen generiert, importieren wir im nächsten Schritt ein Beispieldataset in BigQuery, das wir für den Rest dieser Anleitung verwenden.

7. BigQuery zum Abrufen von Trainingsdaten für Modelle verwenden

Nachdem wir die Firebase Console für den Export nach BigQuery verbunden haben, werden die Ereignisdaten der App-Analyse nach einiger Zeit automatisch in der BigQuery Console angezeigt. Um für diese Anleitung einige erste Daten zu erhalten, importieren wir in diesem Schritt ein vorhandenes Beispieldataset in Ihre BigQuery-Konsole, mit dem wir unser Empfehlungsmodell trainieren können.

Beispieldatensatz in BigQuery importieren

1. Rufen Sie in der Google Cloud Console das BigQuery-Dashboard auf.
2. Wählen Sie im Menü den Namen Ihres Projekts aus.
3. Wählen Sie unten in der linken BigQuery-Navigation Ihren Projektnamen aus, um Details aufzurufen.
4. Wählen Sie Dataset erstellen aus, um den Bereich zum Erstellen von Datasets zu öffnen.
5. Geben Sie „firebase_recommendations_dataset“ für die Dataset-ID ein und wählen Sie Dataset erstellen aus.
6. Das neue Dataset wird im Menü auf der linken Seite unter dem Projektnamen angezeigt. Klicken Sie darauf.
7. Wählen Sie Tabelle erstellen aus, um den Bereich zum Erstellen von Tabellen zu öffnen.
8. Wählen Sie unter Tabelle erstellen aus die Option „Google Cloud Storage“ aus.
9. Geben Sie im Feld Datei aus GCS-Bucket auswählen „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt“ ein.
10. Wählen Sie im Drop-down-Menü Dateiformat die Option „JSONL“ aus.
11. Geben Sie „recommendations_table“ als Tabellenname ein.
12. Klicken Sie auf das Kästchen unter Schema > Automatisch erkennen > Schema und Eingabeparameter.
13. Wählen Sie Tabelle erstellen aus.

HINWEIS:Die oben genannten Schritte sind nur für den Import des Beispieldatasets erforderlich. Normalerweise werden in Firebase automatisch ein Dataset und eine Tabelle in BigQuery erstellt, wenn Analytics-Daten verwendet werden.

Beispiel-Dataset ansehen

An dieser Stelle können Sie optional das Schema untersuchen und eine Vorschau dieses Datensatzes aufrufen.

1. Wählen Sie im linken Menü firebase-recommendations-dataset aus, um die darin enthaltenen Tabellen zu maximieren.
2. Wählen Sie die Tabelle recommendations-table aus, um das Tabellenschema aufzurufen.
3. Wählen Sie Vorschau aus, um die tatsächlichen Analytics-Ereignisdaten zu sehen, die in dieser Tabelle enthalten sind.

HINWEIS:Detaillierte Beschreibungen der einzelnen Felder in den Analysedaten finden Sie in diesem Hilfeartikel.

Anmeldedaten für ein Dienstkonto erstellen

Als Nächstes erstellen wir Dienstkontoanmeldedaten in unserem Google Cloud Console-Projekt, die wir im nächsten Schritt in der Colab-Umgebung verwenden können, um auf unsere BigQuery-Daten zuzugreifen und sie zu laden.

1. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
2. Aktivieren Sie die BigQuery API und die BigQuery Storage API. < click here>
3. Rufen Sie die Seite Dienstkontoschlüssel erstellen auf.
4. Wählen Sie aus der Liste Dienstkonto die Option Neues Dienstkonto aus.
5. Geben Sie im Feld Dienstkontoname einen Namen ein.
6. Wählen Sie in der Liste Rolle die Option Projekt > Inhaber aus.
7. Klicken Sie auf Erstellen. Eine JSON-Datei mit Ihrem Schlüssel wird auf Ihren Computer heruntergeladen.

Im nächsten Schritt verwenden wir Google Colab, um diese Daten vorzuverarbeiten und unser Empfehlungsmodell zu trainieren.

8. Daten vorverarbeiten und Empfehlungsmodell trainieren

In diesem Schritt verwenden wir ein Colab-Notebook, um die folgenden Schritte auszuführen:

1. BigQuery-Daten in das Colab-Notebook importieren
2. Daten vorverarbeiten, um sie für das Modelltraining vorzubereiten
3. Empfehlungsmodell mit den Analysedaten trainieren
4. Exportieren Sie das Modell als TF Lite-Modell.
5. Das Modell in der Firebase Console bereitstellen, damit wir es in unserer App verwenden können

Bevor wir das Colab-Trainings-Notebook starten, aktivieren wir zuerst die Firebase Model Management API, damit Colab das trainierte Modell in unserer Firebase Console bereitstellen kann.

Firebase Model Management API aktivieren

Bucket zum Speichern Ihrer ML-Modelle erstellen

Rufen Sie in der Firebase Console „Storage“ auf und klicken Sie auf „Jetzt starten“.

Folgen Sie dem Dialogfeld, um den Bucket einzurichten.

Firebase ML API aktivieren

Rufen Sie in der Google Cloud Console die Firebase ML API-Seite auf und klicken Sie auf „Aktivieren“.

Colab-Notebook zum Trainieren und Bereitstellen des Modells verwenden

Öffnen Sie das Colab-Notebook über den folgenden Link und führen Sie die Schritte darin aus. Nachdem Sie die Schritte im Colab-Notebook ausgeführt haben, wird eine TF Lite-Modelldatei in der Firebase Console bereitgestellt, die wir mit unserer App synchronisieren können.

In Colab öffnen

9. Modell in Ihrer App herunterladen

In diesem Schritt ändern wir unsere App so, dass das gerade trainierte Modell aus Firebase Machine Learning heruntergeladen wird.

Firebase ML-Abhängigkeit hinzufügen

Die folgende Abhängigkeit ist erforderlich, um Firebase Machine Learning-Modelle in Ihrer App zu verwenden. Sie sollte bereits hinzugefügt sein (bitte prüfen).

Podfile

import FirebaseCore
import FirebaseMLModelDownloader

Modell mit der Firebase Model Manager API herunterladen

Kopieren Sie den folgenden Code in ModelLoader.swift, um die Bedingungen für den Modelldownload festzulegen und eine Downloadaufgabe zu erstellen, um das Remote-Modell mit unserer App zu synchronisieren.

ModelLoader.swift

static func downloadModel(named name: String,
                            completion: @escaping (CustomModel?, DownloadError?) -> Void) {
    guard FirebaseApp.app() != nil else {
      completion(nil, .firebaseNotInitialized)
      return
    }
    guard success == nil && failure == nil else {
      completion(nil, .downloadInProgress)
      return
    }
    let conditions = ModelDownloadConditions(allowsCellularAccess: false)
    ModelDownloader.modelDownloader().getModel(name: name, downloadType: .localModelUpdateInBackground, conditions: conditions) { result in
            switch (result) {
            case .success(let customModel):
                    // Download complete.
                    // The CustomModel object contains the local path of the model file,
                    // which you can use to instantiate a TensorFlow Lite classifier.
                    return completion(customModel, nil)
            case .failure(let error):
                // Download was unsuccessful. Notify error message.
              completion(nil, .downloadFailed(underlyingError: error))
            }
    }
  }

10. TensorFlow Lite-Empfehlungsmodell in Ihre App einbinden

Mit der Tensorflow Lite-Laufzeit können Sie Ihr Modell in der App verwenden, um Empfehlungen zu generieren. Im vorherigen Schritt haben wir einen TFLite-Interpreter mit der heruntergeladenen Modelldatei initialisiert. In diesem Schritt laden wir zuerst ein Dictionary und Labels, die unser Modell im Inferenzschritt begleiten. Dann fügen wir die Vorverarbeitung hinzu, um die Eingaben für unser Modell zu generieren, und die Nachbearbeitung, um die Ergebnisse aus unserer Inferenz zu extrahieren.

Wörterbuch und Labels laden

Die Labels, die zum Generieren der Empfehlungskandidaten durch das Empfehlungsmodell verwendet werden, sind in der Datei sorted_movie_vocab.json im Ordner „assets“ aufgeführt. Kopieren Sie den folgenden Code, um diese Kandidaten zu laden.

RecommendationsViewController.swift

  func getMovies() -> [MovieItem] {
    let barController = self.tabBarController as! TabBarController
    return barController.movies
  }

Vorverarbeitung implementieren

Im Vorverarbeitungsschritt ändern wir die Form der Eingabedaten, damit sie den Erwartungen unseres Modells entsprechen. Hier füllen wir die Eingabelänge mit einem Platzhalterwert auf, wenn wir noch nicht viele Nutzer-Likes generiert haben. Kopieren Sie den folgenden Code:

RecommendationsViewController.swift

  // Given a list of selected items, preprocess to get tflite input.
  func preProcess() -> Data {
    let likedMovies = getLikedMovies().map { (MovieItem) -> Int32 in
      return MovieItem.id
    }
    var inputData = Data(copyingBufferOf: Array(likedMovies.prefix(10)))

    // Pad input data to have a minimum of 10 context items (4 bytes each)
    while inputData.count < 10*4 {
      inputData.append(0)
    }
    return inputData
  }

Interpreter ausführen, um Empfehlungen zu generieren

Hier verwenden wir das Modell, das wir in einem vorherigen Schritt heruntergeladen haben, um die Inferenz für unsere vorverarbeitete Eingabe auszuführen. Wir legen den Typ der Ein- und Ausgabe für unser Modell fest und führen die Inferenz aus, um unsere Filmempfehlungen zu generieren. Kopieren Sie den folgenden Code in Ihre App.

RecommendationsViewController.swift

import TensorFlowLite

RecommendationsViewController.swift

 private var interpreter: Interpreter?

 func loadModel() {
    // Download the model from Firebase
    print("Fetching recommendations model...")
    ModelDownloader.fetchModel(named: "recommendations") { (filePath, error) in
      guard let path = filePath else {
        if let error = error {
          print(error)
        }
        return
      }
      print("Recommendations model download complete")
      self.loadInterpreter(path: path)
    }
  }

 func loadInterpreter(path: String) {
    do {
      interpreter = try Interpreter(modelPath: path)

      // Allocate memory for the model's input `Tensor`s.
      try interpreter?.allocateTensors()

      let inputData = preProcess()

      // Copy the input data to the input `Tensor`.
      try self.interpreter?.copy(inputData, toInputAt: 0)

      // Run inference by invoking the `Interpreter`.
      try self.interpreter?.invoke()

      // Get the output `Tensor`
      let confidenceOutputTensor = try self.interpreter?.output(at: 0)
      let idOutputTensor = try self.interpreter?.output(at: 1)

      // Copy output to `Data` to process the inference results.
      let confidenceOutputSize = confidenceOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})

      let idOutputSize = idOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})

      let confidenceResults =
        UnsafeMutableBufferPointer<Float32>.allocate(capacity: confidenceOutputSize!)
      let idResults =
        UnsafeMutableBufferPointer<Int32>.allocate(capacity: idOutputSize!)
      _ = confidenceOutputTensor?.data.copyBytes(to: confidenceResults)
      _ = idOutputTensor?.data.copyBytes(to: idResults)

      postProcess(idResults, confidenceResults)

      print("Successfully ran inference")
      DispatchQueue.main.async {
        self.tableView.reloadData()
      }
    } catch {
      print("Error occurred creating model interpreter: \(error)")
    }
  }

Nachbearbeitung implementieren

Schließlich verarbeiten wir in diesem Schritt die Ausgabe unseres Modells nach, indem wir die Ergebnisse mit der höchsten Konfidenz auswählen und enthaltene Werte (Filme, die dem Nutzer bereits gefallen haben) entfernen. Kopieren Sie den folgenden Code in Ihre App.

RecommendationsViewController.swift

  // Postprocess to get results from tflite inference.
  func postProcess(_ idResults: UnsafeMutableBufferPointer<Int32>, _ confidenceResults: UnsafeMutableBufferPointer<Float32>) {
    for i in 0..<10 {
      let id = idResults[i]
      let movieIdx = getMovies().firstIndex { $0.id == id }
      let title = getMovies()[movieIdx!].title
      recommendations.append(Recommendation(title: title, confidence: confidenceResults[i]))
    }
  }

App testen

Führen Sie die App noch einmal aus. Wenn Sie einige Filme auswählen, sollte das neue Modell automatisch heruntergeladen und mit der Generierung von Empfehlungen begonnen werden.

11. Glückwunsch!

Sie haben mit TensorFlow Lite und Firebase eine Empfehlungsfunktion in Ihre App eingebaut. Die in diesem Codelab gezeigten Techniken und Pipelines können verallgemeinert und auch für andere Arten von Empfehlungen verwendet werden.

Behandelte Themen

• Firebase ML
• Firebase Analytics
• Analytics-Ereignisse nach BigQuery exportieren
• Analyseereignisse vorverarbeiten
• TensorFlow-Modell für Empfehlungen trainieren
• Modell exportieren und in der Firebase Console bereitstellen
• Filme in einer App empfehlen

Nächste Schritte

• Firebase ML-Empfehlungen in Ihrer App implementieren

Weitere Informationen

• Firebase.google.com

Haben Sie Fragen?

• Stack Overflow-Tag „firebase-machine-learning“

Probleme melden

• GitHub-Probleme