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. Damit lassen sich eine Vielzahl von Aufgaben erledigen, 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 Text-zu-Text-Anwendungen, sodass Sie die neuesten On-Device-Modelle für generative KI in Ihren Android-Apps verwenden können.

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

MediaPipe Studio-Demo Weitere Informationen zu den Funktionen, Modellen und Konfigurationsoptionen dieser Aufgabe finden Sie in der Übersicht.

Kurzanleitung

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

Abhängigkeiten hinzufügen

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

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

Modell herunterladen

Laden Sie Gemma-3 1B im 4-Bit-quantisierten Format von Hugging Face herunter. Weitere Informationen zu den verfügbaren Modellen finden Sie in der Dokumentation zu Modellen.

Ü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 den Task mit 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 generateResponse()-Methode, um eine Textantwort zu generieren. Dadurch wird eine einzelne Antwort generiert.

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

Wenn Sie die LLM Inference APIs in Aktion sehen und eine umfassende Palette von On-Device-Funktionen für generative KI ausprobieren möchten, sehen Sie sich die Google AI Edge Gallery App an.

Die Google AI Edge Gallery ist eine Open-Source-Android-Anwendung, die Entwicklern als interaktiver Playground dient. Darin wird Folgendes gezeigt:

• Praktische Beispiele für die Verwendung der LLM Inference API für verschiedene Aufgaben, darunter:
  • „Bild fragen“: Laden Sie ein Bild hoch und stellen Sie Fragen dazu. Beschreibungen erhalten, Probleme lösen oder Objekte identifizieren
  • Prompt Lab: Mit Zusammenfassungen, Umschreibungen, Code-Generierung oder Prompts in freier Form können Sie Anwendungsfälle für LLMs mit nur einer Interaktion ausprobieren.
  • AI Chat: Sie können sich in Unterhaltungen über mehrere Themen einbringen.
• 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 damit experimentieren.
• Echtzeit-Benchmarks für die On-Device-Leistung für verschiedene Modelle (Zeit bis zum ersten Token, Decodierungsgeschwindigkeit usw.).
• So importieren und testen Sie Ihre eigenen benutzerdefinierten .litertlm- oder .task-Modelle.

Diese App ist eine Ressource, um die praktische Implementierung der LLM Inference API und das Potenzial von generativer KI auf dem Gerät zu verstehen. Sehen Sie sich den Quellcode an und laden Sie die App aus dem Google AI Edge Gallery-GitHub-Repository herunter.

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-, Bild- und Audioeingaben akzeptieren. Wenn die Multimodalität aktiviert ist, können Nutzer in ihre Prompts eine Kombination aus Bildern und Text oder Audio und Text einfügen.Das LLM gibt dann eine Textantwort aus.

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

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

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

Folgen Sie der Anleitung unten, um die Bild- oder Audioeingabe für die LLM Inference API zu aktivieren.

Bildeingabe

Wenn Sie Bilder in einem Prompt bereitstellen möchten, konvertieren Sie die Eingabebilder oder ‑frames in ein com.google.mediapipe.framework.image.MPImage-Objekt, bevor Sie es 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 Unterstützung von Vision für die LLM Inference API aktivieren möchten, legen Sie die Konfigurationsoption EnableVisionModality auf true in den Diagrammoptionen fest:

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

Legen Sie die maximale Anzahl von 10 Bildern pro Sitzung fest.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(10)
  .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();
}

Audioeingabe

Audio-Unterstützung in LlmInferenceOptions aktivieren

val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()

Audio-Unterstützung in „sessionOptions“ aktivieren

    val sessionOptions =  LlmInferenceSessionOptions.builder()
      ...
      .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
      .build()

Audiodaten während der Inferenz senden. Hinweis: Audio muss im Mono-Kanal-Format als .wav vorliegen.

val audioData: ByteArray = ...
inferenceEngine.llmInferenceSession.addAudio(audioData)

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

val audioData: ByteArray = ...
val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()
val sessionOptions =  LlmInferenceSessionOptions.builder()
  ...
  .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
  .build()

LlmInference.createFromOptions(context, inferenceOptions).use { llmInference ->
  LlmInferenceSession.createFromOptions(llmInference, sessionOptions).use { session ->
    session.addQueryChunk("Transcribe the following speech segment:")
    session.addAudio(audioData)
    val result = session.generateResponse()
  }
}

LoRA-Anpassung

Die LLM Inference API unterstützt die LoRA-Abstimmung (Low-Rank Adaptation) mit der PEFT-Bibliothek (Parameter-Efficient Fine-Tuning). Durch LoRA-Abstimmung wird das Verhalten von LLMs durch einen kostengünstigen Trainingsprozess angepasst. Dabei wird eine kleine Gruppe von trainierbaren Gewichten auf der Grundlage neuer Trainingsdaten erstellt, anstatt das gesamte Modell neu zu trainieren.

Die LLM Inference API unterstützt das Hinzufügen von LoRA-Gewichten zu den Attention-Layern 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, damit LoRA-Gewichte erstellt werden können. 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 die LoRA-Methoden aus PEFT, um ein feinabgestimmtes LoRA-Modell mit Ihrem eigenen Dataset zu trainieren.

Die LLM Inference API unterstützt LoRA nur auf Attention-Layern. Geben Sie daher nur die Attention-Layer 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"],
)

Nach dem Training mit dem vorbereiteten Dataset und dem Speichern des Modells sind die feinabgestimmten 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 für das Basismodell 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 erzeugt zwei Flatbuffer-Dateien, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

Android unterstützt statische LoRA während der Initialisierung. Wenn Sie ein LoRA-Modell laden möchten, geben Sie den LoRA-Modellpfad sowie das zugrunde liegende 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)

Wenn Sie LLM-Inferenz mit LoRA ausführen möchten, verwenden Sie dieselben generateResponse()- oder generateResponseAsync()-Methoden wie für das Basismodell.