Guida all'inferenza LLM per Android

L'API LLM Inference ti consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente on-device per le applicazioni Android, che puoi utilizzare per svolgere un'ampia gamma di attività, come la generazione di testo, il recupero di informazioni in forma di linguaggio naturale e il riepilogo dei documenti. L'attività fornisce il supporto integrato per più modelli linguistici di grandi dimensioni text-to-text, in modo da poter applicare i modelli di IA generativa on-device più recenti alle tue app per Android.

Per aggiungere rapidamente l'API LLM Inference alla tua applicazione Android, segui la guida rapida. Per un esempio di base di un'applicazione Android che esegue l'API LLM Inference, consulta l'applicazione di esempio. Per una conoscenza più approfondita del funzionamento dell'API LLM Inference, consulta le sezioni Opzioni di configurazione, Conversione del modello e Tuning LoRa.

Puoi vedere questa operazione in azione con la demo di MediaPipe Studio. Per saperne di più sulle funzionalità, sui modelli e sulle opzioni di configurazione di questa attività, consulta la Panoramica.

Guida rapida

Segui questa procedura per aggiungere l'API LLM Inference alla tua applicazione Android. L'API LLM Inference è ottimizzata per i dispositivi Android di fascia alta, come Pixel 8 e Samsung S23 o modelli successivi, e non supporta in modo affidabile gli emulatori di dispositivi.

Aggiungi dipendenze

L'API LLM Inference utilizza la libreria com.google.mediapipe:tasks-genai. Aggiungi questa dipendenza al file build.gradle della tua app per Android:

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

Per i dispositivi con Android 12 (API 31) o versioni successive, aggiungi la dipendenza dalla libreria OpenCL nativa. Per ulteriori informazioni, consulta la documentazione relativa al tag uses-native-library.

Aggiungi i seguenti tag uses-native-library al file AndroidManifest.xml:

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

Scaricare un modello

Scarica Gemma-3 1B in un formato quantizzato a 4 bit da Hugging Face. Per ulteriori informazioni sui modelli disponibili, consulta la documentazione relativa ai modelli.

Invia i contenuti della cartella output_path al dispositivo Android.

$ 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

Inizializza l'attività

Inizializza l'attività con le opzioni di configurazione di base:

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

Esegui l'attività

Utilizza il metodo generateResponse() per generare una risposta di testo. Viene generata una singola risposta.

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

Per trasmettere la risposta in streaming, utilizza il metodo generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Applicazione di esempio

L'applicazione di esempio è un esempio di app di generazione di testo di base per Android che utilizza l'API LLM Inference. Puoi utilizzare l'app come punto di partenza per la tua app Android o farvi riferimento quando modifichi un'app esistente. Il codice di esempio è ospitato su GitHub.

Clona il repository git utilizzando il seguente comando:

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

Dopo aver creato una versione locale del codice di esempio, puoi importare il progetto in Android Studio ed eseguire l'app. Per ulteriori informazioni, consulta la Guida alla configurazione per Android.

Opzioni di configurazione

Utilizza le seguenti opzioni di configurazione per configurare un'app per Android:

Conversione del modello

L'API LLM Inference è compatibile con i seguenti tipi di modelli, alcuni dei quali richiedono la conversione del modello. Utilizza la tabella per identificare il metodo di procedura richiesto per il tuo modello.

Per scoprire come convertire altri modelli, consulta la sezione Conversione del modello.

Personalizzazione LoRA

L'API Inference LLM supporta l'ottimizzazione LoRA (Low-Rank Adaptation) utilizzando la libreria PEFT (Parameter-Efficient Fine-Tuning). La regolazione LoRA personalizza il comportamento degli LLM tramite un procedura di addestramento economica, creando un piccolo insieme di pesi addestrabili basati su nuovi dati di addestramento anziché addestrare nuovamente l'intero modello.

L'API LLM Inference supporta l'aggiunta di pesi LoRA ai livelli di attenzione dei modelli Gemma-2 2B, Gemma 2B e Phi-2. Scarica il modello nel formato safetensors.

Il modello di base deve essere in formato safetensors per creare i pesi LoRA. Dopo l'addestramento LoRA, puoi convertire i modelli nel formato FlatBuffers per eseguirli su MediaPipe.

Prepara i pesi LoRA

Utilizza la guida Metodi LoRA di PEFT per addestrare un modello LoRA ottimizzato sul tuo set di dati.

L'API LLM Inference supporta LoRA solo nei livelli di attenzione, quindi specifica solo i livelli di attenzione in LoraConfig:

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

Dopo l'addestramento sul set di dati preparato e il salvataggio del modello, i pesi del modello LoRA ottimizzato sono disponibili in adapter_model.safetensors. Il file safetensors è il checkpoint LoRA utilizzato durante la conversione del modello.

Conversione del modello

Utilizza il pacchetto Python MediaPipe per convertire i pesi del modello nel formato Flatbuffer. ConversionConfig specifica le opzioni del modello di base insieme alle opzioni LoRa aggiuntive.

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)

Il convertitore produrrà due file Flatbuffer, uno per il modello di base e un altro per il modello LoRA.

Inferenza del modello LoRA

Android supporta LoRa statico durante l'inizializzazione. Per caricare un modello LoRA, specifica il percorso del modello LoRA e l'LLM di base.

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

Per eseguire l'inferenza LLM con LoRA, utilizza gli stessi metodi generateResponse() o generateResponseAsync() del modello di base.