LLM-Inferenzleitfaden für Android

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät ausführen für Android-Apps, mit denen eine breite Palette von Aufgaben, wie das Generieren von Text, das Abrufen von Informationen in natürlicher Sprache das Zusammenfassen von Dokumenten. Die Aufgabe unterstützt mehrere Large Language Models (Text-zu-Text), damit Sie die neuesten On-Device- auf generativer KI basierende Modelle für Ihre Android-Apps einbinden.

Die Aufgabe unterstützt Gemma 2B ist ein Teil eines Eine Familie leichtgewichtiger, hochmoderner offener Modelle, die auf derselben Forschung basieren und die Technologie, mit der die Gemini-Modelle erstellt wurden. Außerdem werden die folgenden externen Modelle unterstützt: Phi-2 Falcon-RW-1B und StableLM-3B, sowie alle über AI Edge exportierten Modelle.

Weitere Informationen zu Funktionen, Modellen und Konfigurationsoptionen Sehen Sie sich die Übersicht an.

Codebeispiel

Dieser Leitfaden bezieht sich auf ein Beispiel für eine einfache App zur Textgenerierung für Android. Ich können Sie die App als Ausgangspunkt für Ihre eigene Android-App verwenden oder darauf verweisen. wenn Sie eine vorhandene App ändern. Der Beispielcode wird auf GitHub

Code herunterladen

In der folgenden Anleitung erfahren Sie, wie Sie eine lokale Kopie des Beispiels erstellen. mit dem Befehlszeilentool git 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. Konfigurieren Sie optional Ihre Git-Instanz für den Sparse-Checkout, damit Sie nur die Dateien für die Beispielanwendung der LLM Inference API:

   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 importieren in Android Studio ein und führen die App aus. Anweisungen hierzu finden Sie im Einrichtungsleitfaden für Android-Geräte

Einrichtung

In diesem Abschnitt werden die wichtigsten Schritte zum Einrichten Ihrer Entwicklungsumgebung und die die LLM Inference API nutzen. Allgemeine Informationen zu Einrichten Ihrer Entwicklungsumgebung für die Verwendung von MediaPipe-Aufgaben, einschließlich Anforderungen an die Plattformversion finden Sie im Einrichtungsleitfaden für Android-Geräte

Abhängigkeiten

Die LLM Inference API verwendet die com.google.mediapipe:tasks-genai-Bibliothek. Dieses Element hinzufügen Abhängigkeit zur build.gradle-Datei deiner Android-App:

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

Modell

Die MediaPipe LLM Inference API erfordert ein trainiertes Text-zu-Text-Sprachmodell, das mit dieser Aufgabe kompatibel sind. Installieren Sie nach dem Herunterladen eines Modells die erforderliche und das Modell auf das Android-Gerät zu übertragen. Wenn Sie ein Modell verwenden müssen Sie das Modell in ein Format konvertieren, MediaPipe

Weitere Informationen zu verfügbaren trainierten Modellen für die LLM Inference API finden Sie in der Aufgabe Übersicht über Modelle.

Modell herunterladen

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

• Gemma 2B: Teil einer Familie von leichten, hochmodernen offenen Modellen, die aus dem der gleichen Forschung und Technologie, die zur Erstellung Gemini-Modelle. Gut geeignet für eine Vielzahl von Aufgaben zur Textgenerierung, einschließlich Fragenbeantwortung, Zusammenfassung und Logik.
• Phi-2: 2,7 Milliarden Parameter Transformer-Modell, am besten für Frage-Antwort, Chat und Code geeignet Format.
• Falcon-RW-1B: 1 Milliarde kausaler Decoder-Parameter, das mit 350 Mrd. Tokens von RefinedWeb
• StableLM-3B: 3 Sprachmodell nur mit Parameterdecoder mit 1 Billion vortrainiert Tokens verschiedener englischer und Code-Datasets.

Alternativ können Sie Modelle verwenden, die AI Edge Troch.

Wir empfehlen die Verwendung von Gemma 2B, das auf Kaggle verfügbar ist Modelle und kommt in einem Format, das bereits mit der LLM Inference API kompatibel ist. Wenn Sie LLM verwenden, müssen Sie das Modell in ein MediaPipe-freundliches Format. Weitere Informationen zu Gemma 2B finden Sie in der Gemma- Website. Weitere Informationen zur anderen Informationen zu verfügbaren Modellen finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell in das MediaPipe-Format konvertieren

Konvertierung des nativen Modells

Wenn Sie ein externes LLM (Phi-2, Falcon oder StableLM) oder ein anderes LLM ohne Kaggle verwenden Version von Gemma, verwenden Sie unsere Conversion-Skripts, um das Modell kompatibel mit MediaPipe.

Für den Modellkonvertierungsprozess ist das MediaPipe-PyPI-Paket erforderlich. Die Conversion Skript ist in allen MediaPipe-Paketen nach dem 0.10.11 verfügbar.

Installieren und importieren Sie die Abhängigkeiten so:

$ python3 -m pip install mediapipe

Verwenden Sie die Bibliothek genai.converter, um das Modell zu konvertieren:

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

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Zum Konvertieren des LoRA-Modells sollte in ConversionConfig das Basismodell angegeben werden sowie zusätzliche LoRA-Optionen. Da die API nur unterstützt LoRA-Inferenz mit GPU, muss das Back-End auf 'gpu' eingestellt 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 Converter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und das andere für das LoRA-Modell.

AI Edge-Modellkonvertierung

Wenn Sie ein LLM verwenden, das über AI Edge einem TFLite-Modell zugeordnet ist, nutzen Sie unser Bündelskript, um ein Task Bundle zu erstellen. Der Bündelungsprozess mit zusätzlichen Metadaten (z.B. Tokenizer-Parameter) erforderlich um eine End-to-End-Inferenz auszuführen.

Für die Modellbündelung ist das MediaPipe-PyPI-Paket erforderlich. Die Conversion Skript ist in allen MediaPipe-Paketen nach dem 0.10.14 verfügbar.

Installieren und importieren Sie die Abhängigkeiten so:

$ python3 -m pip install mediapipe

Verwenden Sie die Bibliothek genai.bundler, um das Modell zu bündeln:

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

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Modell auf das Gerät übertragen

Inhalt des Ordners output_path an Android übertragen .

$ 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 createFromOptions()-Funktion zum Einrichten der für die Aufgabe. Die Funktion createFromOptions() akzeptiert Werte für die Konfiguration Optionen. Weitere Informationen zu Konfigurationsoptionen finden Sie unter Konfiguration Optionen.

Mit dem folgenden Code wird die Aufgabe mit grundlegenden 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 Eingabeaufforderung.

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 die Eingabe zu generieren. aus dem vorherigen Abschnitt (inputPrompt) zu lesen. Dies erzeugt eine einzelne die generierte Antwort.

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

Verwenden Sie zum Streamen der Antwort die Methode generateResponseAsync().

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 eine LlmInferenceResult zurück, die die generierten Antworttext.

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]

Anpassung des LoRA-Modells

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

Die LoRA-Unterstützung der LLM Inference API funktioniert für Gemma-2B- und Phi-2-Modelle für im GPU-Back-End, wobei LoRA-Gewichtungen nur für Aufmerksamkeitsebenen gelten. Dieses Die erste Implementierung dient als experimentelles API für zukünftige Entwicklungen. mit Plänen, in Zukunft weitere Modelle und verschiedene Arten von Ebenen zu unterstützen. Aktualisierungen.

LoRA-Modelle vorbereiten

Folgen Sie der Anleitung auf HuggingFace, um ein abgestimmtes LoRA-Modell mit Ihrem eigenen Dataset mit den unterstützten Modelltypen Gemma-2B oder Phi-2 zu trainieren. Die Gemma-2B- und Phi-2-Modelle sind auf HuggingFace im Safetensors-Format verfügbar. Da die LLM Inference API nur LoRA für Aufmerksamkeitsebenen unterstützt, geben Sie die Aufmerksamkeitsebenen nur beim Erstellen der LoraConfig so an:

# For Gemma-2B
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"],
)

Zu Testzwecken gibt es öffentlich zugängliche, abgestimmte LoRA-Modelle, die zur LLM Inference 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 vorbereitete Dataset trainiert und das Modell gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den abgestimmten LoRA-Modellgewichtungen. Die Safetensors-Datei ist der bei der Modellkonvertierung verwendete LoRA-Prüfpunkt.

Im nächsten Schritt müssen Sie die Modellgewichtungen mithilfe des MediaPipe Python-Pakets in einen TensorFlow Lite-Flatbuffer umwandeln. In ConversionConfig sollten die Basismodelloptionen sowie zusätzliche LoRA-Optionen angegeben werden. Da die API nur LoRA-Inferenzen mit GPU unterstützt, muss das Back-End auf 'gpu' festgelegt werden.

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 Converter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und das andere für das LoRA-Modell.

Inferenz des LoRA-Modells

Die Web-, Android- und iOS LLM Inference API wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen. Das Web unterstützt dynamische LoRA, mit denen verschiedene LoRA-Modelle während der Laufzeit gewechselt werden können. Android und iOS unterstützen statische LoRA-Werte, bei denen während der Lebensdauer der Aufgabe dieselben LoRA-Gewichtungen verwendet werden.

// 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 zum Ausführen von LLM-Inferenzen mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie das Basismodell.