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.

Die Aufgabe unterstützt die folgenden Varianten von Gemma: Gemma-2 2B, Gemma 2B und Gemma 7B. Gemma ist eine Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren wie die Gemini-Modelle. Außerdem werden die folgenden externen Modelle unterstützt: Phi-2, Falcon-RW-1B und StableLM-3B.

Neben den unterstützten Modellen können Nutzer mit AI Edge Torch von Google PyTorch-Modelle in LiteRT-Modelle mit mehreren Signaturen (tflite) exportieren. Diese werden mit Tokenizer-Parametern gebündelt, um Aufgabenpakete zu erstellen, die mit der LLM Inference API kompatibel sind.

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.

Codebeispiel

In diesem Leitfaden wird ein Beispiel für eine einfache App zur Textgenerierung für Android verwendet. Sie können die App als Ausgangspunkt für Ihre eigene Android-App verwenden oder sich an ihr orientieren, wenn Sie eine vorhandene App ändern. Der Beispielcode wird auf GitHub gehostet.

Code herunterladen

In der folgenden Anleitung wird beschrieben, wie Sie mit dem Befehlszeilentool git eine lokale Kopie des Beispielcodes erstellen.

So laden Sie den Beispielcode herunter:

1. Klonen Sie das Git-Repository mit dem folgenden Befehl:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Optional können Sie Ihre Git-Instanz so konfigurieren, dass eine spärliche Überprüfung verwendet wird, sodass nur die Dateien für die Beispielanwendung der LLM-Inferenz-API vorhanden sind:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/android
   

Nachdem Sie eine lokale Version des Beispielcodes erstellt haben, können Sie das Projekt in Android Studio importieren und die App ausführen. Eine Anleitung dazu finden Sie im Einrichtungsleitfaden für Android.

Einrichtung

In diesem Abschnitt werden die wichtigsten Schritte zum Einrichten Ihrer Entwicklungsumgebung und Codeprojekte beschrieben, die speziell für die Verwendung der LLM Inference API vorgesehen sind. Allgemeine Informationen zum Einrichten Ihrer Entwicklungsumgebung für die Verwendung von MediaPipe-Aufgaben, einschließlich Anforderungen an die Plattformversion, finden Sie im Einrichtungsleitfaden für Android.

Abhängigkeiten

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.14'
}

Fügen Sie für Geräte mit Android 12 (API 31) oder höher die Abhängigkeit von der nativen OpenCL-Bibliothek hinzu. Weitere Informationen finden Sie in der Dokumentation zum Tag uses-native-library.

Fügen Sie der Datei AndroidManifest.xml die folgenden uses-native-library-Tags hinzu:

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

Modell

Für die MediaPipe LLM Inference API ist ein trainiertes Text-zu-Text-Sprachmodell erforderlich, das mit dieser Aufgabe kompatibel ist. Nachdem Sie ein Modell heruntergeladen haben, installieren Sie die erforderlichen Abhängigkeiten und pushen Sie das Modell auf das Android-Gerät. Wenn Sie ein anderes Modell als Gemma verwenden, müssen Sie es in ein Format konvertieren, das mit MediaPipe kompatibel ist.

Weitere Informationen zu verfügbaren trainierten Modellen für die LLM-Inferenz-API finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell herunterladen

Bevor Sie die LLM Inference API initialisieren, laden Sie eines der unterstützten Modelle herunter und speichern Sie die Datei in Ihrem Projektverzeichnis:

• Gemma-2 2B: Die neueste Version der Gemma-Modellfamilie. Teil einer Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet werden.
• Gemma 2B: Ist Teil einer Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet werden. Geeignet für eine Vielzahl von Textgenerierungsaufgaben, einschließlich Fragebeantwortung, Zusammenfassung und Argumentation.
• Phi-2: Transformer-Modell mit 2, 7 Milliarden Parametern, das sich am besten für Frage-Antwort-, Chat- und Codeformate eignet.
• Falcon-RW-1B: Modell mit kausalem Decoder und einer Milliarde Parametern, trainiert auf 350 Milliarden Tokens von RefinedWeb.
• StableLM-3B: Ein Decoder-Sprachmodell mit 3 Milliarden Parametern, das mit 1 Billion Token aus verschiedenen englischen und Code-Datasets vortrainiert wurde.

Zusätzlich zu den unterstützten Modellen können Sie mit AI Edge Torch von Google PyTorch-Modelle in LiteRT-Modelle (tflite) mit mehreren Signaturen exportieren. Weitere Informationen finden Sie unter Torch Generative Converter für PyTorch-Modelle.

Wir empfehlen die Verwendung von Gemma-2 2B, das auf Kaggle Models verfügbar ist. Weitere Informationen zu den anderen verfügbaren Modellen finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell in das MediaPipe-Format konvertieren

Die LLM Inference API ist mit zwei Modellkategorien kompatibel, für die teilweise eine Modellkonvertierung erforderlich ist. Anhand der Tabelle können Sie die erforderlichen Schritte für Ihr Modell ermitteln.

Die konvertierten .bin-Dateien für Gemma 2B, Gemma 7B und Gemma-2 2B werden auf Kaggle gehostet. Diese Modelle können direkt mit unserer LLM Inference API bereitgestellt werden. Informationen zum Konvertieren anderer Modelle finden Sie im Abschnitt Modellkonvertierung.

Modell an das Gerät senden

Ü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.bin

Aufgabe erstellen

Die MediaPipe LLM Inference API verwendet die Funktion createFromOptions(), um die Aufgabe einzurichten. Die Funktion createFromOptions() akzeptiert Werte für die Konfigurationsoptionen. Weitere Informationen zu Konfigurationsoptionen finden Sie unter Konfigurationsoptionen.

Im folgenden Code wird die Aufgabe mithilfe einfacher Konfigurationsoptionen initialisiert:

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPATH('/data/local/.../')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .build()

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

Konfigurationsoptionen

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

Daten vorbereiten

Die LLM Inference API akzeptiert die folgenden Eingaben:

• prompt (String): Eine Frage oder ein Prompt.

val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Aufgabe ausführen

Verwenden Sie die Methode generateResponse(), um eine Textantwort auf den im vorherigen Abschnitt bereitgestellten Eingabetext (inputPrompt) 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)

Ergebnisse verarbeiten und anzeigen

Die LLM Inference API gibt ein LlmInferenceResult zurück, das den generierten Antworttext enthält.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

LoRA-Modellanpassung

Die Mediapipe LLM-Inferenz-API kann so konfiguriert werden, dass sie Low-Rank Adaptation (LoRA) für Large Language Models unterstützt. Mithilfe von optimierten LoRA-Modellen können Entwickler das Verhalten von LLMs durch einen kostengünstigen Trainingsablauf anpassen.

Die LoRA-Unterstützung der LLM Inference API funktioniert für alle Gemma-Varianten und Phi-2-Modelle für das GPU-Back-End. LoRA-Gewichte gelten nur für Aufmerksamkeitsschichten. Diese erste Implementierung dient als experimentelle API für zukünftige Entwicklungen. In den kommenden Updates sollen weitere Modelle und verschiedene Arten von Ebenen unterstützt werden.

LoRA-Modelle vorbereiten

Folgen Sie der Anleitung auf HuggingFace, um ein optimiertes LoRA-Modell mit den unterstützten Modelltypen Gemma oder Phi-2 auf Ihrem eigenen Dataset zu trainieren. Die Modelle Gemma-2 2B, Gemma 2B und Phi-2 sind auf HuggingFace im SafeTensors-Format verfügbar. Da die LLM Inference API nur LoRA auf Aufmerksamkeitsschichten unterstützt, geben Sie beim Erstellen der LoraConfig nur Aufmerksamkeitsschichten 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"],
)

Für Tests gibt es öffentlich zugängliche, optimierte LoRA-Modelle, die zur LLM-Inferenz-API auf HuggingFace passen. Beispiel: monsterapi/gemma-2b-lora-maths-orca-200k für Gemma-2B und lole25/phi-2-sft-ultrachat-lora für Phi-2.

Nachdem Sie das Modell mit dem vorbereiteten Dataset trainiert und gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den optimierten LoRA-Modellgewichten. Die safetensors-Datei ist der LoRA-Prüfpunkt, der bei der Modellkonvertierung verwendet wird.

Im nächsten Schritt müssen Sie die Modellgewichte mit dem MediaPipe-Python-Paket in einen TensorFlow Lite-Flatbuffer konvertieren. Die ConversionConfig sollte die Optionen für das Basismodell sowie zusätzliche LoRA-Optionen angeben. Da die API nur LoRA-Inferenzen mit GPU unterstützt, muss das Backend auf 'gpu' festgelegt sein.

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_TFLITE_FILE,
)

converter.convert_checkpoint(config)

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

LoRA-Modellinferenz

Die LLM-Inferenz-API für Web, Android und iOS wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

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

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