LLM-Inferenzleitfaden für Android

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät für Android-Anwendungen ausführen. Sie können damit eine Vielzahl von Aufgaben ausführen, z. B. Text generieren, Informationen in natürlicher Sprache abrufen und Dokumente zusammenfassen. Die Aufgabe bietet integrierte Unterstützung für mehrere Large Language Models für die Text-zu-Text-Transformation, sodass Sie die neuesten On-Device-Modelle für generative KI auf Ihre Android-Apps anwenden können.

Wenn Sie Ihrer Android-Anwendung schnell die LLM Inference API hinzufügen möchten, folgen Sie der Kurzanleitung. Ein einfaches Beispiel für eine Android-Anwendung, in der die LLM Inference API ausgeführt wird, finden Sie in der Beispielanwendung. Weitere Informationen zur Funktionsweise der LLM Inference API finden Sie in den Abschnitten Konfigurationsoptionen, Modellkonvertierung und LoRA-Abstimmung.

In der MediaPipe Studio-Demo können Sie sich diese Aufgabe in Aktion ansehen. Weitere Informationen zu den Funktionen, Modellen und Konfigurationsoptionen dieser Aufgabe finden Sie in der Übersicht.

Kurzanleitung

So fügen Sie Ihrer Android-App die LLM Inference API hinzu: Die LLM Inference API ist für High-End-Android-Geräte wie Google Pixel 8 und Samsung S23 oder höher optimiert und unterstützt keine gerätespezifischen Emulatoren zuverlässig.

Abhängigkeiten hinzufügen

Die LLM Inference API verwendet die com.google.mediapipe:tasks-genai-Bibliothek. Fügen Sie der Datei build.gradle Ihrer Android-App diese Abhängigkeit hinzu:

dependencies {
    implementation 'com.google.mediapipe:tasks-genai:0.10.24'
}

Modell herunterladen

Laden Sie Gemma-3 1B in einem 4‑Bit-Quantisierungsformat von Hugging Face herunter. Weitere Informationen zu den verfügbaren Modellen finden Sie in der Modelldokumentation.

Übertragen Sie den Inhalt des Ordners output_path auf das Android-Gerät.

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.task

Aufgabe initialisieren

Initialisieren Sie die Aufgabe mit den grundlegenden Konfigurationsoptionen:

// Set the configuration options for the LLM Inference task
val taskOptions = LlmInferenceOptions.builder()
        .setModelPath('/data/local/tmp/llm/model_version.task')
        .setMaxTopK(64)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, taskOptions)

Task ausführen

Verwenden Sie die Methode generateResponse(), um eine Textantwort zu generieren. Dies führt zu einer einzelnen generierten Antwort.

val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")

Verwenden Sie die Methode generateResponseAsync(), um die Antwort zu streamen.

val options = LlmInference.LlmInferenceOptions.builder()
  ...
  .setResultListener { partialResult, done ->
    logger.atInfo().log("partial result: $partialResult")
  }
  .build()

llmInference.generateResponseAsync(inputPrompt)

Beispielanwendung

In der Google AI Edge Gallery App können Sie die LLM Inference APIs in Aktion sehen und sich ein umfassendes Spektrum an On-Device-Funktionen für generative KI ansehen.

Die Google AI Edge Gallery ist eine Open-Source-Android-Anwendung, die als interaktiver Playground für Entwickler dient. Sie enthält Folgendes:

• Praktische Beispiele für die Verwendung der LLM-Inferenz-API für verschiedene Aufgaben, darunter:
  • Bild fragen: Laden Sie ein Bild hoch und stellen Sie Fragen dazu. Sie können Beschreibungen abrufen, Probleme beheben oder Objekte identifizieren.
  • Prompt Lab: Hier können Sie Texte zusammenfassen, umschreiben, Code generieren oder Prompts im Freiformat verwenden, um Anwendungsfälle für LLMs mit nur einer Antwort zu untersuchen.
  • KI-Chat: Unterhaltungen über mehrere Themen.
• Sie können eine Vielzahl von LiteRT-optimierten Modellen aus der Hugging Face LiteRT-Community und offiziellen Google-Releases (z.B. Gemma 3N) entdecken, herunterladen und testen.
• Echtzeit-On-Device-Leistungsmesswerte für verschiedene Modelle (Time To First Token, Dekodierungsgeschwindigkeit usw.)
• So importieren und testen Sie eigene benutzerdefinierte .task-Modelle.

Diese App ist eine Ressource, um die praktische Implementierung der LLM Inference API und das Potenzial der On-Device-Generative AI zu verstehen. Quellcode ansehen und App aus dem GitHub-Repository der Google AI Edge Gallery herunterladen

Konfigurationsoptionen

Verwenden Sie die folgenden Konfigurationsoptionen, um eine Android-App einzurichten:

Multimodale Prompts

Die Android APIs der LLM Inference API unterstützen multimodale Prompts mit Modellen, die Text- und Bildeingaben akzeptieren. Wenn die Multimodalität aktiviert ist, können Nutzer eine Kombination aus Bildern und Text in ihre Prompts einfügen. Das LLM liefert dann eine Textantwort.

Verwenden Sie zum Einstieg eine MediaPipe-kompatible Variante von Gemma 3n:

• Gemma-3n E2B: Ein 2B-Modell der Gemma-3n-Familie.
• Gemma-3n E4B: Ein 4B-Modell der Gemma-3n-Familie.

Weitere Informationen finden Sie in der Gemma-3n-Dokumentation.

Wenn Sie Bilder in einem Prompt angeben möchten, konvertieren Sie die Eingabebilder oder ‑frames in ein com.google.mediapipe.framework.image.MPImage-Objekt, bevor Sie sie an die LLM Inference API übergeben:

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(image).build()

Wenn Sie die Bilderkennung für die LLM Inference API aktivieren möchten, legen Sie in den Diagrammoptionen die Konfigurationsoption EnableVisionModality auf true fest:

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    ...
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

Gemma-3n akzeptiert maximal ein Bild pro Sitzung. Legen Sie daher MaxNumImages auf 1 fest.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(1)
  .build();

Im Folgenden finden Sie ein Beispiel für die Implementierung der LLM Inference API, die für die Verarbeitung von Bild- und Texteingaben eingerichtet ist:

MPImage image = getImageFromAsset(BURGER_IMAGE);

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    .setTopK(10)
    .setTemperature(0.4f)
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

try (LlmInference llmInference =
    LlmInference.createFromOptions(ApplicationProvider.getApplicationContext(), options);
  LlmInferenceSession session =
    LlmInferenceSession.createFromOptions(llmInference, sessionOptions)) {
  session.addQueryChunk("Describe the objects in the image.");
  session.addImage(image);
  String result = session.generateResponse();
}

LoRA-Anpassung

Die LLM Inference API unterstützt die LoRA-Abstimmung (Low-Rank Adaptation) mithilfe der Bibliothek PEFT (Parameter-Efficient Fine-Tuning). Bei der LoRA-Optimierung wird das Verhalten von LLMs durch einen kosteneffizienten Trainingsablauf angepasst. Dabei werden anhand neuer Trainingsdaten eine kleine Anzahl trainierbarer Gewichte erstellt, anstatt das gesamte Modell neu zu trainieren.

Die LLM Inference API unterstützt das Hinzufügen von LoRA-Gewichten zu den Aufmerksamkeitsschichten der Modelle Gemma-2 2B, Gemma 2B und Phi-2. Laden Sie das Modell im safetensors-Format herunter.

Das Basismodell muss das Format safetensors haben, um LoRA-Gewichte zu erstellen. Nach dem LoRA-Training können Sie die Modelle in das FlatBuffers-Format konvertieren, um sie in MediaPipe auszuführen.

LoRA-Gewichte vorbereiten

Verwenden Sie den Leitfaden LoRA-Methoden von PEFT, um ein optimiertes LoRA-Modell mit Ihrem eigenen Datensatz zu trainieren.

Die LLM Inference API unterstützt LoRA nur auf Aufmerksamkeitsebenen. Geben Sie daher nur die Aufmerksamkeitsebenen in LoraConfig an:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Nachdem Sie das Modell mit dem vorbereiteten Dataset trainiert und gespeichert haben, sind die optimierten LoRA-Modellgewichte in adapter_model.safetensors verfügbar. Die Datei safetensors ist der LoRA-Prüfpunkt, der bei der Modellkonvertierung verwendet wird.

Modellkonvertierung

Verwenden Sie das MediaPipe-Python-Paket, um die Modellgewichte in das Flatbuffer-Format zu konvertieren. Mit ConversionConfig werden die Optionen des Basismodells sowie die zusätzlichen LoRA-Optionen angegeben.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_FILE,
)

converter.convert_checkpoint(config)

Der Konverter erstellt zwei Flatbuffer-Dateien, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

Android unterstützt statische LoRA-Verbindungen während der Initialisierung. Wenn Sie ein LoRA-Modell laden möchten, geben Sie den Pfad zum LoRA-Modell sowie das Basis-LLM an.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath(BASE_MODEL_PATH)
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath(LORA_MODEL_PATH)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Verwenden Sie für die Ausführung der LLM-Inferenz mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie für das Basismodell.