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

1. Übersicht

Hinweis: In diesem Codelab wird die TensorFlow Lite-Bibliothek verwendet. Für jeden neuen Code wird empfohlen, die Tools Google AI Edge Lite RT Library zu verwenden.

Willkommen beim Codelab zur 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 Beispiel aus TensorFlow Lite.

Bei der Textklassifizierung werden Texten anhand ihres Inhalts Tags oder Kategorien zugewiesen. Die Klassifizierung ist eine der grundlegenden Aufgaben der natürlichen Sprachverarbeitung (Natural Language Processing, NLP) mit weitreichenden Anwendungen wie Sentimentanalyse, Themenkennzeichnung, Spamerkennung und Absichtserkennung.

Die Sentimentanalyse ist die Interpretation und Klassifizierung von (positiven, negativen und neutralen) Emotionen in Textdaten mithilfe von Textanalysetechniken. Mithilfe der Sentimentanalyse können Unternehmen die Stimmung der Kunden in Bezug auf Produkte, Marken oder Dienstleistungen in Onlinegesprächen und Feedback ermitteln.

In dieser Anleitung erfahren Sie, wie Sie ein Modell für maschinelles Lernen für die Sentimentanalyse erstellen, insbesondere wenn Sie Text als positiv oder negativ klassifizieren. Dies ist ein Beispiel für die Klassifizierung in zwei Klassen, eine wichtige und weit verbreitete Art von ML-Problem.

Lerninhalte

• TF Lite-Sentimentanalysemodell mit TF Lite Model Maker trainieren
• TF Lite-Modelle in Firebase ML bereitstellen und von der App aus darauf zugreifen
• Nutzerfeedback mit Firebase Analytics erfassen, um die Modellgenauigkeit zu messen
• Leistung des Profilmodells über Firebase Performance Monitoring
• Auswählen, welches der mehreren bereitgestellten Modelle über Remote Config geladen werden soll
• Mit Firebase A/B Testing mit verschiedenen Modellen experimentieren

Voraussetzungen

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

Wie möchten Sie diese Anleitung nutzen?

Nur bis zum Ende lesen Lies sie dir durch und absolviere die Übungen

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

Neuling Mittel Kompetent

2. Firebase Console-Projekt erstellen

Firebase zum Projekt hinzufügen

5. Rufen Sie die Firebase Console auf.
6. Wählen Sie Neues Projekt erstellen aus und geben Sie als Projektnamen „Firebase ML iOS Codelab“ ein.

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-textclassification-ios.git
cd codelab-textclassification-ios
pod install --repo-update

Wenn Sie Git nicht installiert haben, können Sie das Beispielprojekt auch von der GitHub-Seite herunterladen oder auf diesen Link klicken. Nachdem Sie das Projekt heruntergeladen haben, führen Sie es in Xcode aus und experimentieren Sie mit der Textklassifizierung, um ein Gefühl für die Funktionsweise zu bekommen.

Firebase einrichten

Folgen Sie der Dokumentation, um ein neues Firebase-Projekt zu erstellen. Laden Sie die GoogleService-Info.plist-Datei Ihres Projekts aus der Firebase Console herunter und ziehen Sie sie in das Stammverzeichnis des Xcode-Projekts.

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

pod 'FirebaseMLModelDownloader', '9.3.0-beta'

Importieren Sie in der didFinishLaunchingWithOptions-Methode von AppDelegate Firebase 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 sicherzustellen, dass die App richtig konfiguriert ist und beim Start nicht abstürzt.

4. Sentimentanalyse-Modell trainieren

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

Dieser Schritt wird als Python-Notebook dargestellt, das Sie in Google Colab öffnen können.

In Colab öffnen

Nach Abschluss dieses Schritts haben Sie ein Sentimentanalysemodell von TensorFlow Lite, das Sie in einer mobilen App bereitstellen können.

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 Releasezyklus als die gesamte App aktualisiert werden.

Das Modell kann entweder über die Konsole oder programmatisch mit dem Firebase Admin SDK bereitgestellt werden. In diesem Schritt führen wir die Bereitstellung über die Console durch.

Öffnen Sie zuerst die Firebase Console und klicken Sie im linken Navigationsbereich auf Machine Learning. Klicken Sie auf „Jetzt starten“, wenn Sie die App zum ersten Mal öffnen. Gehen Sie dann zu „Benutzerdefiniert“ und klicken Sie auf „Modell hinzufügen“, Schaltfläche.

Wenn Sie dazu aufgefordert werden, nennen Sie das Modell sentiment_analysis und laden Sie die Datei hoch, die Sie im vorherigen Schritt von Colab heruntergeladen haben.

Hinweis:Wenn Sie eine Pipeline haben, um Ihr Modell kontinuierlich neu zu trainieren, können Sie den Uploadprozess in Firebase mit der Firebase ML Model Management API automatisieren.

6. Modell aus Firebase ML herunterladen

Es kann schwierig sein, den Zeitpunkt für das Herunterladen des Remote-Modells von Firebase in Ihre App zu bestimmen, da TFLite-Modelle relativ groß werden können. Im Idealfall 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 verwendet, haben wir eine große Menge an Daten ohne Grund heruntergeladen. Wir können auch Download-Optionen festlegen, sodass Modelle nur dann abgerufen werden, wenn eine WLAN-Verbindung besteht. Wenn Sie dafür sorgen möchten, dass das Modell auch ohne Netzwerkverbindung verfügbar ist, ist es wichtig, es auch ohne die App als Sicherung zu bündeln.

Zur Vereinfachung entfernen wir das gebündelte Standardmodell und laden immer ein Modell aus Firebase herunter, wenn die App zum ersten Mal gestartet wird. So können Sie bei der Sentimentanalyse sicher sein, dass die Inferenz mit dem von Firebase bereitgestellten Modell ausgeführt wird.

Importieren Sie oben in ModelLoader.swift das Firebase-Modul.

import FirebaseCore
import FirebaseMLModelDownloader

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

Ersetzen Sie in ViewController.swift unter viewDidLoad den Aufruf von loadModel() durch die 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ühren Sie die App noch einmal aus. Nach einigen Sekunden sollte in Xcode ein Log-in angezeigt werden, das anzeigt, dass das Remote-Modell erfolgreich heruntergeladen wurde. Geben Sie etwas Text ein und prüfen Sie, ob sich das Verhalten der App nicht geändert hat.

Hinweis: Der Modellname muss mit dem übereinstimmen, den Sie im vorherigen Schritt beim Hochladen des Modells in Firebase angegeben haben.

7. Modell in Ihre App einbinden

Mit der TensorFlow Lite Task Library können Sie TensorFlow Lite-Modelle mit nur wenigen Codezeilen in Ihre App einbinden. Wir initialisieren eine TFLNLClassifier-Instanz mit dem TensorFlow Lite-Modell, das von Firebase heruntergeladen wurde. Dann verwenden wir sie, um den von den App-Nutzern eingegebenen Text zu klassifizieren und das Ergebnis auf der Benutzeroberfläche anzuzeigen.

Abhängigkeit hinzufügen

Rufen Sie die Podfile-Datei der Anwendung auf und fügen Sie den Abhängigkeiten der Anwendung die TensorFlow Lite Task Library (Text) hinzu. Achten Sie darauf, dass Sie die Abhängigkeit unter der target 'TextClassification'-Deklaration hinzufügen.

pod 'TensorFlowLiteTaskText', '~> 0.2.0'

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

Textklassifikator initialisieren

Anschließend laden wir das Sentimentanalysemodell, das wir von Firebase heruntergeladen haben, mithilfe der NLClassifier der Task-Bibliothek.

ViewController.swift

Deklarieren wir eine Instanzvariable „TFLNLClassifier“. Importieren Sie die neue Abhängigkeit oben in der Datei:

import TensorFlowLiteTaskText

Sie finden diesen Kommentar über der im letzten Schritt geänderten Methode:

// TODO: Add a TFLNLClassifier property.

Ersetzen Sie die TODO mit dem folgenden Code:

private var classifier: TFLNLClassifier?

Initialisieren Sie die Variable textClassifier mit dem aus Firebase heruntergeladenen Modell für die Stimmungsanalyse. Suchen Sie den Kommentar, den wir im letzten Schritt hinzugefügt haben:

// TODO: Initialize an NLClassifier from the downloaded model

Ersetzen Sie die TODO mit dem folgenden Code:

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

Text klassifizieren

Sobald die classifier-Instanz eingerichtet ist, können Sie die Sentimentanalyse mit einem einzigen Methodenaufruf ausführen.

ViewController.swift

Suchen Sie in der Methode classify(text:) nach dem TODO-Kommentar:

// TODO: Run sentiment analysis on the input text

Ersetzen Sie 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. Fertige App ausführen

Sie haben das Sentimentanalysemodell in die App eingebunden. Testen wir es. Verbinden Sie Ihr iOS-Gerät und klicken Sie in der Xcode-Symbolleiste auf Run ( ).

Die App sollte das Sentiment der von Ihnen eingegebenen Filmrezension korrekt vorhersagen können.

9. App mit weiteren Firebase-Funktionen optimieren

Neben dem Hosting Ihrer TFLite-Modelle bietet Firebase mehrere weitere Funktionen, mit denen Sie Ihre Anwendungsfälle für maschinelles Lernen optimieren können:

• Firebase Performance Monitoring, um die Geschwindigkeit Ihrer Modellinferenz zu messen, die auf dem .
• Mit Firebase Analytics können Sie die Leistung Ihres Modells in der Produktion messen, indem Sie die Nutzerreaktion messen.
• Firebase A/B Testing zum Testen mehrerer Versionen Ihres Modells
• Erinnern Sie sich daran, dass wir bereits zwei Versionen unseres TFLite-Modells trainiert haben? A/B-Tests sind eine gute Möglichkeit, herauszufinden, welche Version in der Produktion besser abschneidet.

Weitere Informationen zur Nutzung dieser Funktionen in Ihrer App finden Sie in den folgenden Codelabs:

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

10. Glückwunsch!

In diesem Codelab haben Sie gelernt, wie Sie ein TFLite-Modell für die Stimmungsanalyse trainieren und mit Firebase in Ihrer mobilen App bereitstellen. Weitere Informationen zu TFLite und Firebase finden Sie in den anderen TFLite-Beispielen und den Firebase-Startleitfaden.

Behandelte Themen

• TensorFlow Lite
• Firebase ML

Nächste Schritte

• Mit Firebase Performance Monitoring die Inferenzgeschwindigkeit Ihres Modells messen
• Stellen Sie das Modell über die Firebase ML Model Management API direkt in Firebase bereit.
• Fügen Sie einen Mechanismus hinzu, mit dem Nutzer Feedback zum Vorhersageergebnis geben können, und verwenden Sie Firebase Analytics, um Nutzerfeedback zu erfassen.
• A/B-Tests für das Modell „Average Word Vector“ und das Modell „MobileBERT“ mit Firebase A/B Testing.

Weitere Informationen

• Dokumentation zu Firebase Machine Learning
• TensorFlow Lite-Dokumentation
• App-Leistung mit Firebase messen
• A/B Testing-Modelle mit Firebase

Sie haben eine Frage?

• StackOverflow und „firebase-machine-learning“

Probleme melden

• GitHub-Probleme