LiteRT Next – Übersicht

LiteRT Next ist eine neue Reihe von APIs, die LiteRT insbesondere in Bezug auf Hardwarebeschleunigung und Leistung für On-Device-ML- und KI-Anwendungen verbessert. Die APIs sind ein Alpharelease und in Kotlin und C++ verfügbar.

Die LiteRT Next Compiled Model API basiert auf der TensorFlow Lite Interpreter API und vereinfacht das Laden und Ausführen von Modellen für maschinelles Lernen auf dem Gerät. Die neuen APIs bieten eine neue optimierte Möglichkeit zur Nutzung der Hardwarebeschleunigung. Es ist nicht mehr erforderlich, sich mit Modell-FlatBuffers, I/O-Buffer-Interoperabilität und Delegaten zu befassen. Die LiteRT Next APIs sind nicht mit den LiteRT APIs kompatibel. Informationen zur Verwendung von LiteRT Next-Funktionen finden Sie in der Anleitung.

Beispielimplementierungen von LiteRT Next finden Sie in den folgenden Demoanwendungen:

Kurzanleitung

Die Ausführung der Inferenz mit den LiteRT Next APIs umfasst die folgenden wichtigen Schritte:

  1. Laden Sie ein kompatibles Modell.
  2. Die Eingabe- und Ausgabetensor-Buffer zuweisen.
  3. Kompiliertes Modell aufrufen
  4. Lesen Sie die Inferenzen in einen Ausgabepuffer.

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

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

Kotlin

// 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 Leitfäden Einstieg in Kotlin und Einstieg in C++.

Wichtige Features

LiteRT Next bietet die folgenden Vorteile und Funktionen:

  • Neue LiteRT API: Optimieren Sie die Entwicklung mit automatischer Beschleunigerauswahl, echter asynchroner Ausführung und effizienter E/A-Pufferverwaltung.
  • Hervorragende GPU-Leistung: Nutzen Sie die modernste GPU-Beschleunigung für die On-Device-ML. Die neue Interoperabilität von Buffers ermöglicht das Zero-Copy-Verfahren und minimiert die Latenz bei verschiedenen GPU-Buffertypen.
  • Überlegene Inferenz mit generativer KI: Ermöglicht die einfachste Integration mit der besten Leistung für GenAI-Modelle.
  • Einheitliche NPU-Beschleunigung: Bietet Entwicklern nahtlosen Zugriff auf NPUs von großen Chipsatzanbietern. Die LiteRT-NPU-Beschleunigung ist über ein Early-Access-Programm verfügbar.

Wichtige Verbesserungen

LiteRT Next (Compiled Model API) enthält die folgenden wichtigen Verbesserungen gegenüber LiteRT (TFLite Interpreter API): Eine ausführliche Anleitung zum Einrichten Ihrer Anwendung mit LiteRT Next finden Sie im Einstiegsleitfaden.

  • Beschleunigernutzung: Für die Ausführung von Modellen auf der GPU mit LiteRT sind explizites Erstellen von Delegaten, Funktionsaufrufe und Graphänderungen erforderlich. Geben Sie bei LiteRT Next einfach den Beschleuniger an.
  • Native Hardware-Buffer-Interoperabilität: LiteRT bietet keine Puffer an und leitet alle Daten über den CPU-Speicher. Mit LiteRT Next können Sie Android-Hardware-Buffers (AHWB), OpenCL-Buffers, OpenGL-Buffers oder andere spezielle Buffers übergeben.
  • Asynchrone Ausführung: LiteRT Next bietet eine neu gestaltete asynchrone API mit einem echten asynchronen Mechanismus, der auf Synchronisierungsbarrieren basiert. So können durch die Verwendung verschiedener Hardware wie CPUs, GPUs, CPUs und NPUs für verschiedene Aufgaben insgesamt kürzere Ausführungszeiten erzielt werden.
  • Modellladen: In LiteRT Next ist beim Laden eines Modells kein separater Builder-Schritt erforderlich.