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 aplikacji przykładowej. Więcej informacji o tym, jak działa interfejs LLM Inference API, znajdziesz w sekcjach Opcje konfiguracji, Konwersja modelu i Dostosowywanie 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.22'
}

W przypadku urządzeń z Androidem 12 (poziom API 31) lub nowszym dodaj zależność od natywnej biblioteki OpenCL. Więcej informacji znajdziesz w dokumentacji dotyczącej tagu uses-native-library.

Dodaj do pliku AndroidManifest.xml te tagi uses-native-library:

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

Pobieranie modelu

Pobierz Gemma-3 1B w 4-bitowym formacie kwantowanym 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

Inicjowanie zadania za pomocą podstawowych opcji 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

Przykładowa aplikacja to przykład podstawowej aplikacji do generowania tekstu na Androida, która korzysta z interfejsu LLM Inference API. Możesz użyć tej aplikacji jako punktu wyjścia do utworzenia własnej aplikacji na Androida lub skorzystać z niej podczas modyfikowania istniejącej aplikacji. Przykładowy kod jest hostowany na GitHub.

Sklonuj repozytorium Git za pomocą tego polecenia:

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

Po utworzeniu lokalnej wersji przykładowego kodu możesz zaimportować projekt do Android Studio i uruchomić aplikację. Więcej informacji znajdziesz w przewodniku konfiguracji na Androida.

Opcje konfiguracji

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

Konwersja modelu

Interfejs API wnioskowania LLM jest zgodny z tymi typami modeli, z których niektóre wymagają konwersji. Korzystając z tabeli, określ wymagane kroki i metodę dla swojego modelu.

Więcej informacji o konwertowaniu innych modeli znajdziesz w sekcji Model konwersji.

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 uruchomić 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 safetensors to 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 określasz opcje modelu podstawowego oraz dodatkowe opcje 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 wykonać wnioskowanie LLM za pomocą LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.