Ihrer App mit TensorFlow Lite und Firebase Textklassifizierung auf dem Gerät hinzufügen – iOS-Codelab

1. Übersicht

Willkommen zum Codelab „Textklassifizierung mit TensorFlow Lite und Firebase“. In diesem Codelab erfahren Sie, wie Sie mit TensorFlow Lite und Firebase ein Textklassifizierungsmodell trainieren und in Ihrer App bereitstellen. Dieses Codelab basiert auf diesem TensorFlow Lite Beispiel.

Bei der Textklassifizierung werden Texten anhand ihres Inhalts Tags oder Kategorien zugewiesen. Sie ist eine der grundlegenden Aufgaben in der Verarbeitung natürlicher Sprache (Natural Language Processing, NLP) und hat ein breites Anwendungsspektrum, z. B. Sentimentanalyse, Themenkennzeichnung, Spam-Erkennung und Intent-Erkennung.

Bei der Sentimentanalyse werden Emotionen (positiv, negativ und neutral) in Textdaten mithilfe von Textanalysetechniken interpretiert und klassifiziert. Mit der Sentimentanalyse können Unternehmen die Kundenstimmung in Bezug auf Produkte, Marken oder Dienstleistungen in Online-Unterhaltungen und -Feedback ermitteln.

In dieser Anleitung wird gezeigt, wie Sie ein Modell für maschinelles Lernen für die Sentimentanalyse erstellen, insbesondere um Text als positiv oder negativ zu klassifizieren. Dies ist ein Beispiel für die binäre Klassifizierung oder Klassifizierung in zwei Klassen, eine wichtige und weit verbreitete Art von Problem im Bereich des maschinellen Lernens.

Lerninhalte

• TF Lite-Sentimentanalysemodell mit TF Lite Model Maker trainieren
• TF Lite-Modelle in Firebase ML bereitstellen und über Ihre App darauf zugreifen
• Nutzerfeedback erfassen, um die Modellgenauigkeit mit Google Analytics for Firebase zu messen
• Modellleistung über Firebase Performance Monitoring analysieren
• Auswählen, welches von mehreren bereitgestellten Modellen über Remote Config geladen wird
• Verschiedene Modelle über Firebase A/B Testing testen

Voraussetzungen

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

2. Firebase Console-Projekt erstellen

Firebase zum Projekt hinzufügen

5. Gehe zur Firebase Console.
6. Wähle Neues Projekt erstellen aus und gib deinem Projekt den Namen „Firebase ML iOS Codelab“.

3. Beispielprojekt abrufen

Code herunterladen

Klone zuerst das Beispielprojekt und führe pod update im Projektverzeichnis aus:

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

Wenn du Git nicht installiert hast, kannst du das Beispielprojekt auch von der GitHub-Seite herunterladen oder auf diesen Link klicken. Nachdem du das Projekt heruntergeladen hast, führe es in Xcode aus und probiere die Textklassifizierung aus, um ein Gefühl dafür zu bekommen, wie sie funktioniert.

Firebase einrichten

Folge der Dokumentation, um ein neues Firebase-Projekt zu erstellen. Nachdem du dein Projekt erstellt hast, lade die Datei GoogleService-Info.plist deines Projekts aus der Firebase Console herunter und ziehe sie in das Stammverzeichnis des Xcode-Projekts.

Füge Firebase zu deiner Podfile-Datei hinzu und führe `pod install` aus.

pod 'FirebaseMLModelDownloader', '9.3.0-beta'

Importiere in der Methode didFinishLaunchingWithOptions deiner AppDelegate-Datei Firebase oben in der Datei.

import FirebaseCore

Füge einen Aufruf hinzu, um Firebase zu konfigurieren.

FirebaseApp.configure()

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

4. Sentimentanalysemodell trainieren

Wir verwenden TensorFlow Lite Model Maker, um ein Textklassifizierungsmodell zu trainieren, mit dem die Stimmung eines bestimmten Texts vorhergesagt werden kann.

Dieser Schritt wird als Python-Notebook präsentiert, das du in Google Colab öffnen kannst.

In Colab öffnen

Nach Abschluss dieses Schritts hast du ein TensorFlow Lite-Sentimentanalysemodell, das für die Bereitstellung in einer mobilen App bereit ist.

5. Modell in Firebase ML bereitstellen

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.

Das Modell kann entweder über die Console oder programmatisch mit dem Firebase Admin SDK bereitgestellt werden. In diesem Schritt stellen wir es über die Console bereit.

Öffne zuerst die Firebase Console und klicke im linken Navigationsbereich auf „Machine Learning“. Klicke auf „Erste Schritte“, wenn du diese Seite zum ersten Mal öffnest. Gehe dann zu „Benutzerdefiniert“ und klicke auf die Schaltfläche „Modell hinzufügen“.

Gib bei entsprechender Aufforderung dem Modell den Namen sentiment_analysis und lade die Datei hoch, die du im vorherigen Schritt aus Colab heruntergeladen hast.

6. Modell aus Firebase ML herunterladen

Die Auswahl des Zeitpunkts für das Herunterladen des Remote-Modells aus Firebase in deine App kann schwierig sein, da TFLite-Modelle relativ groß werden können. Idealerweise sollte das Modell nicht sofort beim Start der App geladen werden. Wenn unser Modell nur für eine Funktion verwendet wird und der Nutzer diese Funktion nie nutzt, haben wir eine erhebliche Menge an Daten ohne Grund heruntergeladen. Wir können auch Downloadoptionen festlegen, z. B. Modelle nur abrufen, wenn eine WLAN-Verbindung besteht. Wenn du sicherstellen möchtest, dass das Modell auch ohne Netzwerkverbindung verfügbar ist, musst du es auch ohne die App als Backup bündeln.

Der Einfachheit halber entfernen wir das standardmäßig gebündelte Modell und laden immer ein Modell aus Firebase herunter, wenn die App zum ersten Mal gestartet wird. So kannst du bei der Sentimentanalyse sicher sein, dass die Inferenz mit dem von Firebase bereitgestellten Modell ausgeführt wird.

Importiere oben in ModelLoader.swift das Firebase-Modul.

import FirebaseCore
import FirebaseMLModelDownloader

Implementiere dann die folgenden Methoden.

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

Ersetze in viewDidLoad von ViewController.swift den Aufruf von loadModel() durch unsere neue Methode zum Herunterladen von Modellen.

// Download the model from Firebase
print("Fetching model...")
ModelLoader.downloadModel(named: "sentiment_analysis") { (customModel, error) in
  guard let customModel = customModel else {
    if let error = error {
      print(error)
    }
    return
  }

  print("Model download complete")

  // TODO: Initialize an NLClassifier from the downloaded model
}

Führe die App noch einmal aus. Nach einigen Sekunden sollte in Xcode ein Log angezeigt werden, das darauf hinweist, dass das Remote-Modell erfolgreich heruntergeladen wurde. Gib etwas Text ein und prüfe, ob sich das Verhalten der App geändert hat.

7. Modell in deine App einbinden

Mit der TensorFlow Lite Task Library kannst du TensorFlow Lite-Modelle mit nur wenigen Codezeilen in deine App einbinden. Wir initialisieren eine TFLNLClassifier-Instanz mit dem aus Firebase heruntergeladenen TensorFlow Lite-Modell. Dann verwenden wir sie, um die Texteingabe der App-Nutzer zu klassifizieren und das Ergebnis auf der Benutzeroberfläche anzuzeigen.

Abhängigkeit hinzufügen

Gehe zur Podfile-Datei der App und füge die TensorFlow Lite Task Library (Text) den Abhängigkeiten der App hinzu. Achte darauf, dass du die Abhängigkeit unter der Deklaration target 'TextClassification' hinzufügst.

pod 'TensorFlowLiteTaskText', '~> 0.2.0'

Führe pod install aus, um die neue Abhängigkeit zu installieren.

Textklassifizierer initialisieren

Dann laden wir das aus Firebase heruntergeladene Sentimentanalysemodell mit der Task Library's NLClassifier.

ViewController.swift

Deklariere eine Instanzvariable für `TFLNLClassifier`. Importiere oben in der Datei die neue Abhängigkeit:

import TensorFlowLiteTaskText

Suche diesen Kommentar über der Methode, die wir im letzten Schritt geändert haben:

// TODO: Add a TFLNLClassifier property.

Ersetze das TODO durch den folgenden Code:

private var classifier: TFLNLClassifier?

Initialisiere die Variable textClassifier mit dem aus Firebase heruntergeladenen Sentimentanalysemodell. Suche diesen Kommentar, den wir im letzten Schritt hinzugefügt haben:

// TODO: Initialize an NLClassifier from the downloaded model

Ersetze das TODO durch den folgenden Code:

let options = TFLNLClassifierOptions()
self.classifier = TFLNLClassifier.nlClassifier(modelPath: customModel.path, options: options)

Text klassifizieren

Sobald die classifier-Instanz eingerichtet ist, kannst du die Sentimentanalyse mit einem einzigen Methodenaufruf ausführen.

ViewController.swift

Suche in der Methode classify(text:) den TODO-Kommentar:

// TODO: Run sentiment analysis on the input text

Ersetze den Kommentar durch den folgenden Code:

guard let classifier = self.classifier else { return }

// Classify the text
let classifierResults = classifier.classify(text: text)

// Append the results to the list of results
let result = ClassificationResult(text: text, results: classifierResults)
results.append(result)

8. Finale App ausführen

Du hast das Sentimentanalysemodell in die App eingebunden. Jetzt können wir es testen. Verbinde dein iOS-Gerät und klicke in der Xcode-Symbolleiste auf Ausführen ( ).

Die App sollte die Stimmung der von dir eingegebenen Filmkritik richtig vorhersagen können.

9. App mit weiteren Firebase-Funktionen verbessern

Neben dem Hosting deiner TFLite-Modelle bietet Firebase mehrere andere Funktionen, mit denen du deine Anwendungsfälle für maschinelles Lernen optimieren kannst:

• Firebase Performance Monitoring zum Messen der Inferenzgeschwindigkeit deines Modells auf dem Gerät des Nutzers.
• Google Analytics for Firebase zum Messen der Leistung deines Modells in der Produktion anhand der Nutzerreaktionen.
• Firebase A/B Testing zum Testen mehrerer Versionen deines Modells.
• Erinnerst du dich, dass wir zuvor zwei Versionen unseres TFLite-Modells trainiert haben? A/B-Tests sind eine gute Möglichkeit, um herauszufinden, welche Version in der Produktion besser abschneidet.

Weitere Informationen zur Nutzung dieser Funktionen in deiner App findest du in den folgenden Codelabs:

• Firebase zu deiner TFLite-basierten Android-App hinzufügen
• Firebase zu deiner TFLite-basierten iOS-App hinzufügen

10. Glückwunsch!

In diesem Codelab hast du gelernt, wie du ein Sentimentanalyse-TFLite-Modell trainierst und mit Firebase in deiner mobilen App bereitstellst. Weitere Informationen zu TFLite und Firebase findest du in anderen TFLite- Beispielen und in den Firebase- Anleitungen für den Einstieg.

Behandelte Themen

• TensorFlow Lite
• Firebase ML

Nächste Schritte

• Messe die Inferenzgeschwindigkeit deines Modells mit Firebase Performance Monitoring.
• Stelle das Modell direkt aus Colab über die Firebase ML Model Management API in Firebase bereit.
• Füge einen Mechanismus hinzu, mit dem Nutzer Feedback zum Vorhersageergebnis geben können, und erfasse das Nutzerfeedback mit Google Analytics for Firebase.
• Führe mit Firebase A/B Testing A/B-Tests für das Modell „Average Word Vector“ und das MobileBERT-Modell durch.

Weitere Informationen

• Firebase Machine Learning-Dokumentation
• TensorFlow Lite-Dokumentation
• App-Leistung mit Firebase messen
• A/B-Tests für Modelle mit Firebase

Fragen?

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

Probleme melden

• GitHub-Probleme