Przewodnik po wnioskowaniu LLM na Androida

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie na urządzeniu w przypadku aplikacji na Androida. Możesz go używać do wykonywania wielu zadań, takich jak generowanie tekstu, pozyskiwanie informacji w formie naturalnego języka czy streszczanie dokumentów. Zadanie zapewnia wbudowane wsparcie dla wielu dużych modeli językowych do konwersji tekstu na tekst, dzięki czemu możesz stosować najnowsze modele generatywnej AI na urządzeniu w swoich aplikacjach na Androida.

Aby szybko dodać interfejs LLM Inference API do aplikacji na Androida, postępuj zgodnie z krótkim wprowadzeniem. Podstawowy przykład aplikacji na Androida korzystającej z interfejsu LLM Inference API znajdziesz w przykładowej aplikacji. Więcej informacji o tym, jak działa interfejs LLM Inference API, znajdziesz w sekcjach Opcje konfiguracji, Konwertowanie modelu i Ustawianie modelu LoRa.

Możesz zobaczyć to zadanie w działaniu w demonstracji MediaPipe Studio. Więcej informacji o możliwościach, modelach i opcjach konfiguracji związanych z tym zadaniem znajdziesz w sekcji Omówienie.

Krótkie wprowadzenie

Aby dodać interfejs LLM Inference API do aplikacji na Androida, wykonaj te czynności. Interfejs LLM Inference API jest zoptymalizowany pod kątem zaawansowanych urządzeń z Androidem, takich jak Pixel 8 i Samsung S23 lub nowszych, i nie obsługuje niezawodnie emulatorów urządzeń.

Dodawanie zależności

Interfejs LLM Inference API korzysta z biblioteki com.google.mediapipe:tasks-genai. Dodaj ten element zależny do pliku build.gradle aplikacji na Androida:

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

Pobieranie modelu

Pobierz Gemma-3 1B w 4-bitowym formacie kwantyzowanym z HuggingFace. Więcej informacji o dostępnych modelach znajdziesz w dokumentacji modeli.

Przekaż zawartość folderu output_path na urządzenie z Androidem.

$ 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

Inicjowanie zadania

Inicjalizacja zadania z podstawowymi opcjami konfiguracji:

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

Uruchamianie zadania

Aby wygenerować odpowiedź tekstową, użyj metody generateResponse(). Spowoduje to wygenerowanie jednej odpowiedzi.

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

Aby przesyłać strumieniowo odpowiedź, użyj metody generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Przykładowa aplikacja

Aby zobaczyć, jak działają interfejsy LLM Inference API, i poznać szeroki zakres możliwości generatywnej AI na urządzeniu, wypróbuj aplikację Google AI Edge Gallery.

Google AI Edge Gallery to aplikacja na Androida typu open source, która jest interaktywnym miejscem do testowania dla deweloperów. Prezentuje:

• praktyczne przykłady korzystania z interfejsu LLM Inference API do różnych zadań, w tym:
  • Zapytaj obraz: prześlij obraz i zadaj pytania na jego temat. Uzyskaj opisy, rozwiąż problemy lub zidentyfikuj obiekty.
  • Prompt Lab: podsumowuj, przepisuj, generuj kod lub używaj promptów niestandardowych, aby poznać przypadki użycia LLM w jednym obrocie.
  • Czat AI: prowadzenie rozmów wieloetapowych.
• Możliwość odkrywania, pobierania i eksperymentowania z różnymi modelami zoptymalizowanymi pod kątem LiteRT z Hugging Face LiteRT Community oraz oficjalnych wersji Google (np. Gemma 3N).
• Testy porównawcze wydajności na urządzeniu w czasie rzeczywistym dla różnych modeli (czas do pierwszego znacznika, szybkość dekodowania itp.).
• Jak importować i testować własne modele niestandardowe .task.

Ta aplikacja to zasób, który pozwala zrozumieć praktyczne wdrożenie interfejsu LLM Inference API i potencjał generatywnej AI na urządzeniu. Zapoznaj się z kodem źródłowym i pobierz aplikację z repozytorium Google AI Edge Gallery na GitHubie.

Opcje konfiguracji

Aby skonfigurować aplikację na Androida, użyj tych opcji konfiguracji:

Prompty multimodalne

Interfejsy API LLM Inference API na Androida obsługują multimodalne prompty z modelami, które przyjmują dane wejściowe w postaci tekstu i obrazów. Gdy multimodalność jest włączona, użytkownicy mogą umieszczać w promptach kombinację obrazów i tekstu, a model LLM generuje tekstową odpowiedź.

Na początek użyj Gemma3n zgodnego z MediaPipe:

• Gemma-3n E2B: model 2B rodziny Gemma-3n.
• Gemma-3n E4B: model 4B rodziny Gemma-3n.

Więcej informacji znajdziesz w dokumentacji Gemma-3n.

Aby podać obrazy w promptach, przed przekazaniem ich do interfejsu API LLM Inference przekształcaj obrazy wejściowe lub klatki w obiekt com.google.mediapipe.framework.image.MPImage:

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

Aby włączyć obsługę funkcji wzrokowych w przypadku interfejsu LLM Inference API, w opcjach grafu ustaw opcję EnableVisionModality na true:

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

Gemma-3n akceptuje maksymalnie 1 obraz na sesję, więc ustaw wartość MaxNumImages na 1.

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

Oto przykładowa implementacja interfejsu LLM Inference API skonfigurowanego do obsługi danych wejściowych dotyczących obrazu i tekstu:

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

Dostosowywanie LoRa

Interfejs LLM Inference API obsługuje dostrajanie LoRA (Low-Rank Adaptation) za pomocą biblioteki PEFT (Parameter-Efficient Fine-Tuning). Dostrajanie LoRA dostosowuje zachowanie LLM za pomocą opłacalnego procesu trenowania, tworząc mały zestaw trenowanych wag na podstawie nowych danych treningowych, a nie trenując ponownie całego modelu.

Interfejs LLM Inference API umożliwia dodawanie wag LoRA do warstw uwagi w modelach Gemma-2 2B, Gemma 2B i Phi-2. Pobierz model w formacie safetensors.

Aby utworzyć wagi LoRA, model podstawowy musi być w formacie safetensors. Po wytrenowaniu modelu LoRA możesz przekonwertować modele do formatu FlatBuffers, aby można było je uruchamiać w MediaPipe.

Przygotuj wagi LoRA

Aby wytrenować dopracowany model LoRA na podstawie własnego zbioru danych, skorzystaj z przewodnika LoRA Methods (w języku angielskim) opracowanego przez PEFT.

Interfejs LLM Inference API obsługuje tylko LoRA na warstwach uwagi, więc w pliku LoraConfig należy określić tylko warstwy uwagi:

# 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"],
)

Po wytrenowaniu modelu na przygotowanym zbiorze danych i zapisaniu go domyślnie dopasowane wagi modelu LoRA są dostępne w adapter_model.safetensors. Plik safetensorsto punkt kontrolny LoRA używany podczas konwertowania modelu.

Konwersja modelu

Użyj pakietu Python MediaPipe, aby przekonwertować wagi modelu na format Flatbuffer. W polu ConversionConfig są określone opcje modelu podstawowego wraz z dodatkowymi opcjami LoRa.

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)

Konwerter wygeneruje 2 pliki Flatbuffer: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie modelu LoRA

Android obsługuje statyczny LoRA podczas inicjowania. Aby wczytać model LoRA, określ ścieżkę modelu LoRA oraz model LLM podstawowy.

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

Aby uruchomić wnioskowanie LLM za pomocą LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.