Guida all'inferenza LLM per Android

L'API LLM Inference consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente sul dispositivo per le applicazioni Android, che puoi utilizzare per svolgere un'ampia gamma di attività, come generare testo, recuperare informazioni in linguaggio naturale e riassumere documenti. L'attività fornisce supporto integrato per più modelli linguistici di grandi dimensioni da testo a testo, in modo da poter applicare i più recenti modelli di AI generativa sul dispositivo 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 comprensione più approfondita del funzionamento dell'API LLM Inference, consulta le sezioni Opzioni di configurazione, Conversione del modello e Ottimizzazione LoRA.

Puoi vedere questa attività in azione nella 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 questi passaggi 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.27'
}

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 sui 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. In questo modo viene generata una singola risposta.

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

Per trasmettere in streaming la risposta, 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

Per vedere le API LLM Inference in azione ed esplorare una gamma completa di funzionalità di AI generativa sul dispositivo, dai un'occhiata all'app Google AI Edge Gallery.

La galleria Google AI Edge è un'applicazione Android open source che funge da playground interattivo per gli sviluppatori. Mostra:

• Esempi pratici di utilizzo dell'API LLM Inference per varie attività, tra cui:
  • Chiedi all'immagine: carica un'immagine e poni domande al riguardo. Ricevi descrizioni, risolvi problemi o identifica oggetti.
  • Prompt Lab: riassumi, riscrivi, genera codice o utilizza prompt in formato libero per esplorare i casi d'uso degli LLM in un solo turno.
  • Chat AI: partecipa a conversazioni multi-turno.
• La possibilità di scoprire, scaricare e sperimentare una serie di modelli ottimizzati per LiteRT dalla community Hugging Face LiteRT e dalle versioni ufficiali di Google (ad es. Gemma 3N).
• Benchmark delle prestazioni in tempo reale sul dispositivo per diversi modelli (tempo al primo token, velocità di decodifica e così via).
• Come importare e testare i tuoi modelli .litertlm o .task personalizzati.

Questa app è una risorsa per comprendere l'implementazione pratica dell'API LLM Inference e il potenziale dell'AI generativa sul dispositivo. Esplora il codice sorgente e scarica l'app dal repository GitHub di Google AI Edge Gallery.

Opzioni di configurazione

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

Prompt multimodali

Le API Android dell'API LLM Inference supportano i prompt multimodali con modelli che accettano input di testo, immagini e audio. Con la multimodalità attivata, gli utenti possono includere una combinazione di immagini e testo o audio e testo nei prompt.Il LLM fornisce quindi una risposta di testo.

Per iniziare, utilizza una variante di Gemma 3n compatibile con MediaPipe:

• Gemma-3n E2B: un modello 2B efficace della famiglia Gemma-3n.
• Gemma-3n E4B: un modello efficace da 4 miliardi di parametri della famiglia Gemma-3n.

Per ulteriori informazioni, consulta la documentazione di Gemma-3n.

Segui i passaggi riportati di seguito per attivare l'input di immagini o audio per l'API LLM Inference.

Input immagine

Per fornire immagini all'interno di un prompt, converti le immagini o i frame di input in un oggetto com.google.mediapipe.framework.image.MPImage prima di passarlo all'API LLM Inference:

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

Per attivare il supporto della visione per l'API LLM Inference, imposta l'opzione di configurazione EnableVisionModality su true all'interno delle opzioni del grafico:

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

Imposta un massimo di 10 immagini per sessione.

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

Di seguito è riportato un esempio di implementazione dell'API LLM Inference configurata per gestire input di testo e visione:

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

Input audio

Attiva il supporto audio in LlmInferenceOptions

val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()

Attiva il supporto audio in sessionOptions

    val sessionOptions =  LlmInferenceSessionOptions.builder()
      ...
      .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
      .build()

Inviare dati audio durante l'inferenza. Nota: l'audio deve essere in formato mono canale .wav

val audioData: ByteArray = ...
inferenceEngine.llmInferenceSession.addAudio(audioData)

Di seguito è riportato un esempio di implementazione dell'API LLM Inference configurata per gestire input audio e di testo:

val audioData: ByteArray = ...
val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()
val sessionOptions =  LlmInferenceSessionOptions.builder()
  ...
  .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
  .build()

LlmInference.createFromOptions(context, inferenceOptions).use { llmInference ->
  LlmInferenceSession.createFromOptions(llmInference, sessionOptions).use { session ->
    session.addQueryChunk("Transcribe the following speech segment:")
    session.addAudio(audioData)
    val result = session.generateResponse()
  }
}

Personalizzazione LoRA

L'API LLM Inference supporta l'ottimizzazione LoRA (Low-Rank Adaptation) utilizzando la libreria PEFT (Parameter-Efficient Fine-Tuning). La messa a punto LoRA personalizza il comportamento degli LLM tramite un processo di addestramento conveniente, creando un piccolo insieme di pesi addestrabili basati su nuovi dati di addestramento anziché riaddestrare 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 in formato safetensors.

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

Prepara i pesi LoRA

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

L'API LLM Inference supporta solo LoRA sui 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.