LiteRT für Android

Mit LiteRT können Sie TensorFlow-, PyTorch- und JAX-Modelle in Ihren Android-Apps ausführen. Das LiteRT-System bietet vorgefertigte und anpassbare Ausführungsumgebungen für die schnelle und effiziente Ausführung von Modellen auf Android, einschließlich Optionen für die Hardwarebeschleunigung.

Beispiele für Android-Anwendungen, die LiteRT verwenden, finden Sie im Repository LiteRT-Beispiele.

Modelle für maschinelles Lernen

LiteRT verwendet TensorFlow-, PyTorch- und JAX-Modelle, die in ein kleineres, portables und effizienteres Format für Machine-Learning-Modelle konvertiert werden. Sie können vordefinierte Modelle mit LiteRT unter Android verwenden oder eigene Modelle erstellen und in das LiteRT-Format konvertieren.

Auf dieser Seite wird die Verwendung bereits erstellter Modelle für maschinelles Lernen beschrieben. Das Erstellen, Trainieren, Testen oder Konvertieren von Modellen wird nicht behandelt. Weitere Informationen zum Auswählen, Ändern, Erstellen und Konvertieren von Modellen für maschinelles Lernen für LiteRT finden Sie auf der Seite Modelle.

Modelle unter Android ausführen

Ein LiteRT-Modell, das in einer Android-App ausgeführt wird, nimmt Daten auf, verarbeitet sie und generiert eine Vorhersage basierend auf der Logik des Modells. Für die Ausführung eines LiteRT-Modells ist eine spezielle Laufzeitumgebung erforderlich. Die Daten, die an das Modell übergeben werden, müssen in einem bestimmten Datenformat vorliegen, das als Tensor bezeichnet wird. Wenn ein Modell die Daten verarbeitet, was als Inferenz bezeichnet wird, werden Vorhersageergebnisse als neue Tensoren generiert und an die Android-App übergeben, damit sie Maßnahmen ergreifen kann, z. B. das Ergebnis einem Nutzer anzeigen oder zusätzliche Geschäftslogik ausführen.

Abbildung 1. Funktioneller Ausführungsablauf für LiteRT-Modelle in Android-Apps.

Auf der Ebene des funktionalen Designs benötigt Ihre Android-App die folgenden Elemente, um ein LiteRT-Modell auszuführen:

• LiteRT-Laufzeitumgebung zum Ausführen des Modells
• Modelleingabe-Handler zum Transformieren von Daten in Tensoren
• Handler für die Modellausgabe zum Empfangen von Ausgabetensor und Interpretieren dieser als Vorhersageergebnisse

In den folgenden Abschnitten wird beschrieben, wie die LiteRT-Bibliotheken und ‑Tools diese funktionalen Elemente bereitstellen.

Apps mit LiteRT erstellen

In diesem Abschnitt wird der empfohlene, häufigste Weg zur Implementierung von LiteRT in Ihrer Android-App beschrieben. Sie sollten sich vor allem die Abschnitte Laufzeitumgebung und Entwicklerbibliotheken ansehen. Wenn Sie ein benutzerdefiniertes Modell entwickelt haben, lesen Sie den Abschnitt Erweiterte Entwicklungspfade.

Optionen für die Laufzeitumgebung

Es gibt mehrere Möglichkeiten, eine Laufzeitumgebung für die Ausführung von Modellen in Ihrer Android-App zu aktivieren. Dies sind die bevorzugten Optionen:

• LiteRT in der Google Play-Dienste-Laufzeitumgebung (empfohlen)
• Eigenständige LiteRT-Laufzeitumgebung

Im Allgemeinen sollten Sie die von Google Play-Diensten bereitgestellte Laufzeitumgebung verwenden, da sie speichereffizienter als die Standardumgebung ist. Sie wird dynamisch geladen, wodurch die Größe Ihrer App geringer bleibt. Google Play-Dienste verwenden außerdem automatisch die neueste stabile Version der LiteRT-Laufzeitumgebung. So erhalten Sie im Laufe der Zeit zusätzliche Funktionen und eine verbesserte Leistung. Wenn Sie Ihre App auf Geräten anbieten, auf denen Google Play-Dienste nicht verfügbar sind, oder wenn Sie Ihre ML-Laufzeitumgebung genau verwalten müssen, sollten Sie die Standard-LiteRT-Laufzeit verwenden. Bei dieser Option wird zusätzlicher Code in Ihre App eingebunden. So haben Sie mehr Kontrolle über die ML-Laufzeit in Ihrer App, allerdings wird die Downloadgröße Ihrer App dadurch erhöht.

Sie greifen in Ihrer Android-App auf diese Laufzeitumgebungen zu, indem Sie Ihrer App-Entwicklungsumgebung LiteRT-Entwicklungsbibliotheken hinzufügen. Informationen zur Verwendung der Standardlaufzeitumgebungen in Ihrer App finden Sie im nächsten Abschnitt.

Bibliotheken

Sie können über die Google Play-Dienste auf die Interpreter API zugreifen. Sie können die Core- und Support-Bibliotheken von LiteRT in Ihrer Android-App verwenden. Programmierdetails zur Verwendung von LiteRT-Bibliotheken und ‑Laufzeitumgebungen finden Sie unter Entwicklungstools für Android.

Modelle abrufen

Wenn Sie ein Modell in einer Android-App ausführen möchten, benötigen Sie ein Modell im LiteRT-Format. Sie können vorgefertigte Modelle verwenden oder ein eigenes Modell erstellen und in das Lite-Format konvertieren. Weitere Informationen zum Abrufen von Modellen für Ihre Android-App finden Sie auf der LiteRT-Seite Models.

Eingabedaten verarbeiten

Alle Daten, die Sie an ein ML-Modell übergeben, müssen ein Tensor mit einer bestimmten Datenstruktur sein, die oft als Form des Tensors bezeichnet wird. Damit Daten mit einem Modell verarbeitet werden können, muss der App-Code Daten aus ihrem nativen Format, z. B. Bild-, Text- oder Audiodaten, in einen Tensor in der für das Modell erforderlichen Form umwandeln.

Inferenzen ausführen

Das Verarbeiten von Daten durch ein Modell, um ein Vorhersageergebnis zu generieren, wird als Ausführen einer Inferenz bezeichnet. Um eine Inferenz in einer Android-App auszuführen, sind eine LiteRT-Laufzeitumgebung, ein Modell und Eingabedaten erforderlich.

Die Geschwindigkeit, mit der ein Modell auf einem bestimmten Gerät eine Inferenz generieren kann, hängt von der Größe der verarbeiteten Daten, der Komplexität des Modells und den verfügbaren Rechenressourcen wie Arbeitsspeicher und CPU oder speziellen Prozessoren ab, die als Beschleuniger bezeichnet werden. Modelle für maschinelles Lernen können auf diesen spezialisierten Prozessoren wie Grafikprozessoren (GPUs) und Tensor Processing Units (TPUs) schneller ausgeführt werden. Dazu werden LiteRT-Hardwaretreiber verwendet, die als Delegates bezeichnet werden. Weitere Informationen zu Delegaten und zur Hardwarebeschleunigung der Modellverarbeitung finden Sie in der Übersicht zur Hardwarebeschleunigung.

Ausgabeergebnisse verarbeiten

Modelle generieren Vorhersageergebnisse als Tensoren, die von Ihrer Android-App verarbeitet werden müssen, indem eine Aktion ausgeführt oder dem Nutzer ein Ergebnis angezeigt wird. Die Ergebnisse der Modellausgabe können so einfach wie eine Zahl sein, die einem einzelnen Ergebnis entspricht (0 = Hund, 1 = Katze, 2 = Vogel) für eine Bildklassifizierung, oder viel komplexere Ergebnisse, z. B. mehrere Begrenzungsrahmen für mehrere klassifizierte Objekte in einem Bild, mit Konfidenzwerten für die Vorhersage zwischen 0 und 1.

Erweiterte Entwicklungspfade

Wenn Sie komplexere und benutzerdefinierte LiteRT-Modelle verwenden, müssen Sie möglicherweise komplexere Entwicklungsansätze als die oben beschriebenen verwenden. In den folgenden Abschnitten werden erweiterte Techniken zum Ausführen von Modellen und zum Entwickeln von Modellen für LiteRT in Android-Apps beschrieben.

Erweiterte Laufzeitumgebungen

Zusätzlich zur Standardlaufzeit und zur Laufzeitumgebung für Google Play-Dienste für LiteRT gibt es weitere Laufzeitumgebungen, die Sie mit Ihrer Android-App verwenden können. Diese Umgebungen werden am wahrscheinlichsten verwendet, wenn Sie ein Machine-Learning-Modell haben, das ML-Vorgänge verwendet, die von der Standardlaufzeitumgebung für LiteRT nicht unterstützt werden.

• Flexible Laufzeit für LiteRT
• Benutzerdefinierte LiteRT-Laufzeit

Mit der LiteRT-Flex-Laufzeit können Sie bestimmte Operatoren einfügen, die für Ihr Modell erforderlich sind. Als erweiterte Option zum Ausführen Ihres Modells können Sie LiteRT für Android erstellen, um Operatoren und andere Funktionen einzuschließen, die zum Ausführen Ihres TensorFlow-Modells für maschinelles Lernen erforderlich sind. Weitere Informationen finden Sie unter LiteRT für Android erstellen.

C- und C++-APIs

LiteRT bietet auch eine API zum Ausführen von Modellen mit C und C++. Wenn Ihre App das Android NDK verwendet, sollten Sie diese API in Betracht ziehen. Sie sollten diese API auch in Betracht ziehen, wenn Sie Code zwischen mehreren Plattformen teilen möchten. Weitere Informationen zu dieser Entwicklungsoption finden Sie auf der Seite Entwicklungstools.

Serverbasierte Modellausführung

Im Allgemeinen sollten Sie Modelle in Ihrer App auf einem Android-Gerät ausführen, um von der geringeren Latenz und dem verbesserten Datenschutz für Ihre Nutzer zu profitieren. Es gibt jedoch Fälle, in denen es besser ist, ein Modell auf einem Cloud-Server auszuführen. Das kann beispielsweise der Fall sein, wenn Sie ein großes Modell haben, das sich nicht einfach auf eine Größe komprimieren lässt, die auf die Android-Geräte Ihrer Nutzer passt, oder das auf diesen Geräten nicht mit angemessener Leistung ausgeführt werden kann. Dieser Ansatz ist möglicherweise auch die bevorzugte Lösung, wenn eine konsistente Leistung des Modells auf einer Vielzahl von Geräten oberste Priorität hat.

Google Cloud bietet eine umfassende Suite von Diensten zum Ausführen von KI-Modellen. Weitere Informationen finden Sie auf der Seite KI- und Machine-Learning-Produkte von Google Cloud.

Entwicklung und Optimierung benutzerdefinierter Modelle

Zu den anspruchsvolleren Entwicklungspfaden gehört wahrscheinlich die Entwicklung benutzerdefinierter Modelle für maschinelles Lernen und die Optimierung dieser Modelle für die Verwendung auf Android-Geräten. Wenn Sie benutzerdefinierte Modelle erstellen möchten, sollten Sie Quantisierungstechniken für Modelle in Betracht ziehen, um die Speicher- und Verarbeitungskosten zu senken. Weitere Informationen zum Erstellen leistungsstarker Modelle für die Verwendung mit LiteRT finden Sie im Abschnitt „Modelle“ unter Best Practices für die Leistung.

Unterstützte Android-Versionen

Wichtig:Halten Sie Ihre Abhängigkeiten auf dem neuesten Stand, um die Kompatibilität mit den neuesten Funktionen und Sicherheitsupdates zu gewährleisten.

Compiled Model API im Vergleich zur Interpreter API

• Compiled Model API: Beschleunigerorientierte AOT-/JIT-kompilierte Ausführung mit einheitlicher Puffer-Interop und asynchronen Pipelines.
• Interpreter API: Abwärtskompatibel mit vorhandenem TensorFlow Lite-Code.

Sie können die API zur Laufzeit auswählen. Die meisten neuen Leistungs- und Beschleunigerfunktionen sind in der Compiled Model API verfügbar.

Beispielimplementierungen:

• Bildsegmentierung (Kotlin, CPU/GPU)
• Asynchrone Segmentierung (C++, CPU/GPU/NPU)
• Semantische Ähnlichkeit (C++) – lokales Beispiel

Common & CPU

GPU

NPU

Kurzanleitung (Compiled Model API)

Die Ausführung der Inferenz mit der Compiled Model API umfasst die folgenden wichtigen Schritte:

1. Laden Sie ein kompatibles Modell.
2. Weisen Sie die Eingabe- und Ausgabetensorpuffer zu.
3. Kompiliertes Modell aufrufen
4. Lesen Sie die Inferenz in einen Ausgabepuffer.

Die folgenden Code-Snippets zeigen eine grundlegende Implementierung des gesamten Prozesses in Kotlin und C++.

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

// Invoke
compiled_model.Run(input_buffers, output_buffers);

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.CPU)
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Weitere Informationen finden Sie in den Anleitungen Erste Schritte mit Kotlin und Erste Schritte mit C++.

Wichtige Funktionen (Compiled Model API)

• Schlüsselfertige Auswahl von Beschleunigern und asynchrone Ausführung: Wählen Sie bei der Erstellung CPU/GPU/NPU aus und führen Sie die Ausführung asynchron ohne Delegate-Plumbing aus.
• Einheitliche Zero-Copy-Puffer: AHWB-/GL-/OpenCL-/WebGPU-/Metal-Puffer können für die Vor- und Nachbearbeitung sowie für die Inferenz gemeinsam genutzt werden.
• Durchsatz für generative KI: Optimiert für große Modelle mit Arbeitsspeicher-Caching und GPU-/NPU-Fallbacks.

Die Interpreter API bleibt der Kompatibilitätspfad für vorhandene TensorFlow Lite-Codebases. Verwenden Sie sie, wenn Sie ein stabiles Delegierungsverhalten oder Wrapper von Drittanbietern benötigen, die den klassischen Interpreter erwarten.

Beschleuniger

• CPU (Standard): XNNPACK-optimiert, dynamische Formen werden unterstützt.
• GPU:Derzeit OpenCL-Back-End; WebGPU- und Metal-Back-Ends sind über die Compiled Model API verfügbar.
• NPU:Qualcomm AI Engine Direct und MediaTek NeuroPilot werden für AOT/JIT unterstützt. Pixel AOT ist verfügbar. Die Unterstützung von Apple/Intel-NPUs ist geplant.

Wann sollte eine API ausgewählt werden?

• Verwenden Sie die Compiled Model API, wenn Sie den schnellsten Pfad zu GPU/NPU, Zero-Copy-Puffern oder asynchroner Ausführung benötigen.
• Verwenden Sie die Interpreter API, wenn Sie maximale Kompatibilität mit vorhandenem TensorFlow Lite-Code, Tools oder Delegates benötigen.