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 usare per svolgere un'ampia gamma di attività, come generare testo, recuperare informazioni in formato linguaggio naturale e riassumere documenti. L'attività fornisce supporto integrato per modelli linguistici di grandi dimensioni (LLM) da testo a testo, in modo da poter applicare i più recenti modelli di IA generativa alle tue app per Android.

L'attività supporta Gemma 2B, una parte di un famiglia di modelli aperti, leggeri e all'avanguardia, basati sulla stessa ricerca e la tecnologia usata per creare i modelli Gemini. Supporta inoltre i seguenti modelli esterni: Phi-2 Falcon-RW-1B e StableLM-3B, insieme a tutti i modelli esportati tramite AI Edge.

Per ulteriori informazioni su funzionalità, modelli e opzioni di configurazione di questa attività, consulta la Panoramica.

Esempio di codice

Questa guida fa riferimento a un esempio di app di generazione di testo di base per Android. Tu puoi utilizzare l'app come punto di partenza per la tua app per Android oppure fare riferimento ad essa quando modifichi un'app esistente. Il codice di esempio è ospitato su GitHub.

Scarica il codice

Le seguenti istruzioni mostrano come creare una copia locale dell'esempio utilizzando lo strumento a riga di comando git.

Per scaricare il codice di esempio:

1. Clona il repository git utilizzando il comando seguente:

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

2. Facoltativamente, configura la tua istanza Git per l'utilizzo di un pagamento sparso, in modo da avere solo i file dell'app di esempio dell'API LLM Inference:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/android
   

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

Configurazione

Questa sezione descrive i passaggi chiave per configurare l'ambiente di sviluppo e di codice per usare in modo specifico l'API LLM Inference. Per informazioni generali su configurare l'ambiente di sviluppo per l'utilizzo delle attività di MediaPipe, tra cui: i requisiti di versione della piattaforma, consulta la Guida alla configurazione per Android.

Dipendenze

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

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

Modello

L'API Inference LLM MediaPipe richiede un modello linguistico da testo a testo addestrato che sia compatibili con questa attività. Dopo aver scaricato un modello, installa il necessario delle dipendenze ed eseguire il push del modello al dispositivo Android. Se utilizzi un modello diverso da Gemma, dovrai convertire il modello in un formato compatibile MediaPipe.

Per saperne di più sui modelli addestrati disponibili per l'API Inference LLM, consulta l'attività Panoramica, sezione Modelli.

Scarica un modello

Prima di inizializzare l'API LLM Inference, scarica uno dei modelli supportati e archiviare il file all'interno della directory del progetto:

• Gemma 2B: Parte di una famiglia di modelli aperti, leggeri e all'avanguardia, realizzati la stessa ricerca e tecnologia utilizzate per creare Gemini. Adatto a una varietà di attività di generazione di testi, tra cui la risposta alle domande, il riassunto e ragionare.
• Phi-2: parametro 2,7 miliardi Modello Transformer, ideale per domande-risposta, chat e codice formato.
• Falcon-RW-1B: 1 miliardo modello solo decoder causale dei parametri addestrato su 350 miliardi di token di RefinedWeb.
• StableLM-3B: 3 miliardi di modelli linguistici di solo decoder di parametri preaddestrato su 1 trilione di diversi set di dati in inglese e di codice.

In alternativa, puoi utilizzare modelli mappati ed esportati tramite AI Edge Troch.

Ti consigliamo di utilizzare Gemma 2B, disponibile su Kaggle Modelli e viene fornito in un formato già compatibile con l'API Inference LLM. Se utilizzi a un altro LLM, dovrai convertire il modello in un Formato compatibile con MediaPipe. Per ulteriori informazioni su Gemma 2B, vedi Gemma 2B sito. Per ulteriori informazioni sull'altro disponibili, consulta la sezione Modelli della panoramica delle attività.

Converti il modello in formato MediaPipe

Conversione del modello nativo

Se utilizzi un LLM esterno (Phi-2, Falcon o StableLM) o uno non Kaggle di Gemma, utilizza i nostri script di conversione per formattare il modello compatibile con MediaPipe.

Il processo di conversione del modello richiede il pacchetto MediaPipe PyPI. La conversione lo script è disponibile in tutti i pacchetti MediaPipe dopo il giorno 0.10.11.

Installa e importa le dipendenze con quanto segue:

$ python3 -m pip install mediapipe

Utilizza la libreria genai.converter per convertire il modello:

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)

Per convertire il modello LoRA, ConversionConfig deve specificare il modello di base oltre a opzioni LoRA aggiuntive. Nota che, poiché solo l'API supporta l'inferenza LoRA con GPU. Il backend deve essere impostato su 'gpu'.

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)

Il convertitore restituirà due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Conversione del modello AI Edge

Se utilizzi un LLM mappato a un modello TFLite tramite AI Edge, utilizza la nostra dello script di raggruppamento per creare un pacchetto di attività. Il processo di raggruppamento accorpa un modello mappato con metadati aggiuntivi (ad es. parametri del tokenizzatore) necessari per eseguire l'inferenza end-to-end.

Il processo di raggruppamento dei modelli richiede il pacchetto MediaPipe PyPI. La conversione lo script è disponibile in tutti i pacchetti MediaPipe dopo il giorno 0.10.14.

Installa e importa le dipendenze con quanto segue:

$ python3 -m pip install mediapipe

Utilizza la libreria genai.bundler per raggruppare il modello:

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)

Esegui il push del modello al dispositivo

Esegui il push dei contenuti della cartella output_path in Android dispositivo.

$ 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

Crea l'attività

L'API MediaPipe LLM Inference utilizza la funzione createFromOptions() per configurare dell'attività. La funzione createFromOptions() accetta i valori per la configurazione le opzioni di CPU e memoria disponibili. Per ulteriori informazioni sulle opzioni di configurazione, vedi Configurazione opzioni.

Il codice seguente inizializza l'attività utilizzando le opzioni di configurazione di base:

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

Opzioni di configurazione

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

Preparazione dei dati

L'API LLM Inference accetta i seguenti input:

• prompt (stringa): una domanda o un prompt.

val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Esegui l'attività

Utilizza il metodo generateResponse() per generare una risposta testuale all'input testo fornito nella sezione precedente (inputPrompt). Questo produce un singolo generata.

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

Per trasmettere la risposta in modalità flusso, utilizza il metodo generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Gestire e visualizzare i risultati

L'API LLM Inference restituisce un valore LlmInferenceResult, che include i valori generati testo della risposta.

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]

Personalizzazione del modello LoRA

L'API di inferenza LLM Mediapipe può essere configurata per supportare l'adattamento basso ranking (LoRA) per gli LLM. Utilizzando modelli LoRA perfezionati, gli sviluppatori possono personalizzare il comportamento degli LLM attraverso un processo di addestramento conveniente.

Il supporto LoRA dell'API LLM Inference funziona per i modelli Gemma-2B e Phi-2 per il backend GPU, con pesi LoRA applicabili solo ai livelli di attenzione. Questo l'implementazione iniziale funge da API sperimentale per gli sviluppi futuri e prevediamo di supportare più modelli e vari tipi di strati nel prossimo aggiornamenti.

prepara i modelli LoRA

Segui le istruzioni su HuggingFace per addestrare un modello LoRA ottimizzato sul tuo set di dati con tipi di modelli supportati, Gemma-2B o Phi-2. I modelli Gemma-2B e Phi-2 sono entrambi disponibili su HuggingFace in formato securetensors. Poiché l'API LLM Inference supporta solo LoRA sui livelli di attenzione, specifica solo i livelli di attenzione durante la creazione di LoraConfig come segue:

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

Per i test, su HuggingFace sono disponibili modelli LoRA ottimizzati e accessibili pubblicamente che si adattano all'API Inference LLM. Ad esempio, monsterapi/gemma-2b-lora-maths-orca-200k per Gemma-2B e lole25/phi-2-sft-ultrachat-lora per Phi-2.

Dopo l'addestramento sul set di dati preparato e il salvataggio del modello, ottieni un file adapter_model.safetensors contenente i pesi del modello LoRA ottimizzati. Il file securetensors è il checkpoint LoRA utilizzato nella conversione del modello.

Come passaggio successivo, devi convertire i pesi del modello in un Flatbuffer TensorFlow Lite utilizzando il pacchetto Python MediaPipe. ConversionConfig deve specificare le opzioni del modello di base e ulteriori opzioni LoRA. Tieni presente che poiché l'API supporta solo l'inferenza LoRA con GPU, il backend deve essere impostato su 'gpu'.

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)

Il convertitore restituirà due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Inferenza del modello LoRA

L'API di inferenza LLM per web, Android e iOS viene aggiornata per supportare l'inferenza del modello LoRA. Il web supporta LoRA dinamico, che può cambiare modelli LoRA diversi durante il runtime. Android e iOS supportano LoRA statico, che utilizza gli stessi pesi LoRA per tutta la durata dell'attività.

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

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