Scopri di più sui nostri annunci di Google AI Edge da I/O

Questa pagina è stata tradotta dall'API Cloud Translation.

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 eseguire un'ampia gamma di attività, ad esempio generare testo, recuperare informazioni in formato linguistico e riassumere i 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 IA generativa on-device alle tue app Android.

L'attività supporta Gemma 2B, una famiglia di modelli aperti leggeri e all'avanguardia creati sulla base della stessa ricerca e tecnologia utilizzata 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 sulle funzionalità, sui modelli e sulle opzioni di configurazione di questa attività, consulta la Panoramica.

Esempio di codice

Questa guida fa riferimento a un esempio di app di base per la generazione di testi per Android. Puoi utilizzare l'app come punto di partenza per la tua app per Android o farvi riferimento quando modifichi un'app esistente. Il codice di esempio è ospitato su GitHub.

Scarica il codice

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

Per scaricare il codice di esempio:

Clona il repository git utilizzando il seguente comando:

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

Facoltativamente, configura la tua istanza Git in modo da utilizzare il pagamento sparse, 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 le istruzioni, consulta la Guida alla configurazione per Android.

Imposta

Questa sezione descrive i passaggi chiave per configurare l'ambiente di sviluppo e codificare i progetti in modo specifico per l'utilizzo dell'API LLM Inference. Per informazioni generali sulla configurazione dell'ambiente di sviluppo per l'utilizzo delle attività di MediaPipe, inclusi 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 questa dipendenza al file build.gradle della tua app per Android:

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

Modello

L'API MediaPipe LLM Inference richiede un modello linguistico da testo a testo addestrato, compatibile con questa attività. Dopo aver scaricato un modello, installa le dipendenze necessarie ed esegui il push del modello sul dispositivo Android. Se utilizzi un modello diverso da Gemma, dovrai convertirlo in un formato compatibile con MediaPipe.

Per ulteriori informazioni sui modelli addestrati disponibili per l'API LLM Inference, consulta la sezione Modelli della panoramica delle attività.

Scarica un modello

Prima di inizializzare l'API LLM Inference, scarica uno dei modelli supportati e archivia il file nella directory del progetto:

Gemma 2B: parte di una famiglia di modelli aperti leggeri e all'avanguardia creati sulla base della stessa ricerca e tecnologia utilizzata per creare i modelli Gemini. Adatto per varie attività di generazione del testo, tra cui risposta alle domande, riepilogo e ragionamento.
Phi-2: modello Transformer da 2, 7 miliardi di parametri, ideale per i formati domanda-risposta, chat e codice.
Falcon-RW-1B: modello solo decoder causale con 1 miliardo di parametri addestrato su 350 miliardi di token di RefinedWeb.
StableLM-3B: modello linguistico solo decoder a 3 miliardi di parametri preaddestrato su 1 trilione di token di diversi set di dati di inglese e codice.

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

Consigliamo di utilizzare Gemma 2B, disponibile sui modelli Kaggle e in un formato già compatibile con l'API LLM Inference. Se utilizzi un altro LLM, dovrai convertire il modello in un formato compatibile con MediaPipe. Per maggiori informazioni su Gemma 2B, visita il sito di Gemma. Per ulteriori informazioni sugli altri modelli disponibili, consulta la sezione Modelli della panoramica delle attività.

Converti il modello nel formato MediaPipe

Conversione del modello nativo

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

Il processo di conversione del modello richiede il pacchetto MediaPipe PyPI. Lo script di conversione è 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

Usa 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, l'ConversionConfig deve specificare le opzioni del modello di base e altre 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à come output due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Parametro	Descrizione	Valori accettati
`input_ckpt`	Il percorso del file `model.safetensors` o `pytorch.bin`. Tieni presente che a volte il formato dei Safetensor di modello viene suddiviso in più file, ad esempio `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors`. Puoi specificare un pattern di file, ad esempio `model*.safetensors`.	PATH
`ckpt_format`	Il formato del file del modello.	{"safetensors", "pytorch"}
`model_type`	L'LLM in fase di conversione.	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	Il processore (delegato) utilizzato per eseguire il modello.	{"cpu", "gpu"}
`output_dir`	Il percorso della directory di output che ospita i file del peso per livello.	PATH
`output_tflite_file`	Il percorso del file di output. Ad esempio, "model_cpu.bin" o "model_gpu.bin". Questo file è compatibile solo con l'API LLM Inference e non può essere utilizzato come file "tflite" generale.	PATH
`vocab_model_file`	Il percorso della directory in cui sono archiviati i file `tokenizer.json` e `tokenizer_config.json`. Per Gemma, posiziona il cursore sul singolo file `tokenizer.model`.	PATH
`lora_ckpt`	Il percorso del file ckpt LoRA dei securetensors in cui è archiviato il peso dell'adattatore LoRA.	PATH
`lora_rank`	Un numero intero che rappresenta il ranking del ckpt LoRA. Obbligatorio per convertire le ponderazioni Lora. Se non viene specificato, il convertitore presuppone che non siano presenti pesi LoRA. Nota: solo il backend GPU supporta LoRA.	Integer
`lora_output_tflite_file`	Nome file tflite di output per i pesi LoRA.	PATH

Conversione del modello AI Edge

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

Il processo di raggruppamento dei modelli richiede il pacchetto MediaPipe PyPI. Lo script di conversione è 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

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

Parametro	Descrizione	Valori accettati
`tflite_model`	Il percorso del modello TFLite esportato da AI Edge.	PATH
`tokenizer_model`	Il percorso del modello tokenizzatore SentencePiece.	PATH
`start_token`	Token iniziale specifico del modello. Il token iniziale deve essere presente nel modello di tokenizzatore fornito.	STRING
`stop_tokens`	Token di arresto specifici del modello. I token di stop devono essere presenti nel modello di tokenizzatore fornito.	ELENCO[STRING]
`output_filename`	Il nome del file del bundle delle attività di output.	PATH

Esegui il push del modello al dispositivo

Esegui il push dei 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.bin

Creare l'attività

L'API MediaPipe LLM Inference utilizza la funzione createFromOptions() per configurare l'attività. La funzione createFromOptions() accetta i valori per le opzioni di configurazione. Per maggiori informazioni sulle opzioni di configurazione, consulta Opzioni di configurazione.

Il seguente codice 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:

Nome opzione	Descrizione	Intervallo di valori	Valore predefinito
`modelPath`	Il percorso in cui è archiviato il modello all'interno della directory del progetto.	PATH	N/A
`maxTokens`	Il numero massimo di token (token di input + token di output) gestiti dal modello.	Integer	512
`topK`	Il numero di token che il modello prende in considerazione in ogni passaggio della generazione. Limita le previsioni ai token più probabili con il valore top-k. Quando imposti `topK`, devi anche impostare un valore per `randomSeed`.	Integer	40
`temperature`	La quantità di casualità introdotta durante la generazione. Una temperatura più alta favorisce la creatività nel testo generato, mentre una temperatura più bassa produce una generazione più prevedibile. Quando imposti `temperature`, devi anche impostare un valore per `randomSeed`.	In virgola mobile	0,8
`randomSeed`	Il seed casuale utilizzato durante la generazione del testo.	Integer	0
`loraPath`	Il percorso assoluto al modello LoRA a livello locale sul dispositivo. Nota: è compatibile solo con i modelli GPU.	PATH	N/A
`resultListener`	Imposta il listener dei risultati per ricevere i risultati in modo asincrono. Applicabile solo quando si utilizza il metodo di generazione asincrono.	N/A	N/A
`errorListener`	Imposta un listener di errori facoltativo.	N/A	N/A

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 al testo di input fornito nella sezione precedente (inputPrompt). Questo produce un'unica risposta generata.

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

Per trasmettere la risposta in streaming, usa 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 codice LlmInferenceResult, che include il testo della risposta generato.

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 lo standard LLM (Low-Rank adeguamento) per i modelli linguistici di grandi dimensioni (LLM). Con modelli LoRA perfezionati, gli sviluppatori possono personalizzare il comportamento degli LLM tramite 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 ponderazioni LoRA applicabili solo ai livelli di attenzione. Questa implementazione iniziale funge da API sperimentale per gli sviluppi futuri, con l'obiettivo di supportare altri modelli e vari tipi di livelli nei prossimi 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 nel formato Safetensors. 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, sono disponibili su HuggingFace modelli LoRA perfezionati e accessibili pubblicamente, che si adattano all'API LLM Inference. 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 aver salvato il modello, ottieni un file adapter_model.safetensors contenente le ponderazioni del modello LoRA ottimizzate. Il file Safetensors è il checkpoint LoRA utilizzato nella conversione del modello.

Nel passaggio successivo, devi convertire le ponderazioni del modello in un Flatbuffer di TensorFlow Lite utilizzando il pacchetto Python MediaPipe. L'ConversionConfig deve specificare le opzioni del modello di base e altre 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à come output due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Inferenza del modello LoRA

Le API Web, Android e iOS Inference LLM sono aggiornate 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 le stesse ponderazioni LoRA per tutta la durata dell'attività.

Android supporta la LoRA statica durante l'inizializzazione. Per caricare un modello LoRA, gli utenti specificano il percorso del modello LoRA e il modello LLM di base.

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