Guida all'inferenza LLM

L'API LLM Inference consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente sul dispositivo, utilizzabili per eseguire un'ampia gamma di attività, come 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 e ai tuoi prodotti.

Prova!

L'attività supporta Gemma 2B e 7B, che fa parte di una famiglia di modelli aperti leggeri e all'avanguardia creati con la stessa ricerca e la stessa tecnologia utilizzata per creare i modelli Gemini. Supporta inoltre i seguenti modelli esterni: Phi-2, Falcon-RW-1B e StableLM-3B.

Oltre ai modelli supportati in modo nativo, gli utenti possono mappare altri modelli utilizzando le offerte AI Edge di Google (inclusa la mappatura dei modelli PyTorch). In questo modo gli utenti possono esportare un modello mappato in modelli TensorFlow Lite multi-firma, che sono in bundle con parametri del tokenizzatore per creare un Task Bundle.

Inizia

Inizia a utilizzare questa attività seguendo una di queste guide all'implementazione per la tua piattaforma di destinazione. Queste guide specifiche per piattaforma illustrano l'implementazione di base di questa attività, con esempi di codice che utilizzano un modello disponibile e le opzioni di configurazione consigliate:

Dettagli attività

Questa sezione descrive le funzionalità, gli input, gli output e le opzioni di configurazione di questa attività.

Funzionalità

L'API LLM Inference contiene le seguenti funzionalità chiave:

  1. Generazione da testo a testo - Genera testo in base a un prompt di testo di input.
  2. Selezione LLM: applica più modelli per personalizzare l'app in base ai tuoi casi d'uso specifici. Puoi anche riaddestrare e applicare ponderazioni personalizzate al modello.
  3. Supporto LoRA - Estendi e personalizza la funzionalità LLM con il modello LoRA mediante l'addestramento su tutti i set di dati o prendendo modelli LoRA predefiniti preparati dalla community open source (solo modelli nativi).
Input attività Output attività
L'API LLM Inference accetta i seguenti input:
  • Prompt di testo (ad es. una domanda, l'oggetto di un'email, un documento da riassumere)
 L'API LLM Inference restituisce i seguenti risultati:
  • Testo generato in base al prompt di input (ad es. una risposta alla domanda, una bozza di email, un riepilogo del documento)

Opzioni di configurazione

Questa attività prevede le seguenti opzioni di configurazione:

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. Numero intero 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. Numero intero 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. Numero intero 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

ottimizzabili

L'API LLM Inference contiene il supporto integrato per i modelli linguistici di grandi dimensioni da testo a testo separabili, ottimizzati per l'esecuzione su browser e dispositivi mobili. Questi modelli leggeri possono essere scaricati per eseguire le inferenze completamente sul dispositivo.

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

Gemma 2B

Gemma 2B fa parte di una famiglia di modelli aperti leggeri e all'avanguardia creati dalla stessa ricerca e tecnologia utilizzati per creare i modelli Gemini. Il modello contiene 2 miliardi di parametri e ponderazioni aperte. Questo modello è adatto a una serie di attività di generazione di testo, tra cui la risposta alle domande, il riassunto e il ragionamento.

Scarica Gemma 2B

I modelli Gemma 2B sono disponibili in quattro varianti:

Puoi anche ottimizzare il modello e aggiungere nuove ponderazioni prima di aggiungerlo all'app. Per ulteriori informazioni sull'ottimizzazione e sulla personalizzazione di Gemma, vedi Ottimizzazione di Gemma. Dopo aver scaricato Gemma da Modelli Kaggle, il modello è già nel formato appropriato per l'utilizzo con MediaPipe.

Se scarichi Gemma 2B da Hugging Face, devi convertire il modello in un formato compatibile con MediaPipe. L'API LLM Inference richiede il download e la conversione dei seguenti file:

  • model-00001-of-00002.safetensors
  • model-00002-of-00002.safetensors
  • tokenizer.json
  • tokenizer_config.json

Gemma 7B

Gemma 7B è un modello Gemma più grande con 7 miliardi di parametri e pesi aperti. Il modello è più potente per una serie di attività di generazione di testo, tra cui la risposta alle domande, il riassunto e il ragionamento. Gemma 7B è supportata solo sul web.

Scarica Gemma 7B

Il modello Gemma 7B è disponibile in una variante:

Se scarichi Gemma 7B da Hugging Face, devi convertire il modello in un formato compatibile con MediaPipe. L'API LLM Inference richiede il download e la conversione dei seguenti file:

  • model-00001-of-00004.safetensors
  • model-00002-of-00004.safetensors
  • model-00003-of-00004.safetensors
  • model-00004-of-00004.safetensors
  • tokenizer.json
  • tokenizer_config.json

Falcon 1B

Falcon-1B è un modello solo decoder causale con 1 miliardo di parametri addestrato su 350 miliardi di token di RefinedWeb.

Scarica Falcon 1B

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati a livello locale:

  • tokenizer.json
  • tokenizer_config.json
  • pytorch_model.bin

Dopo aver scaricato i file del modello Falcon, il modello è pronto per essere convertito nel formato MediaPipe. Segui la procedura descritta in Convertire il modello in formato MediaPipe.

StableLM 3B

StableLM-3B è un modello linguistico solo decoder con 3 miliardi di parametri preaddestrato su 1 trilione di token di diversi set di dati inglesi e di codice per 4 epoche.

Scarica StableLM 3B

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati a livello locale:

  • tokenizer.json
  • tokenizer_config.json
  • model.safetensors

Dopo aver scaricato i file del modello StableLM, il modello è pronto per essere convertito nel formato MediaPipe. Segui la procedura descritta in Convertire il modello in formato MediaPipe.

Phi-2

Phi-2 è un modello Transformer con 2,7 miliardi di parametri. È stato addestrato utilizzando vari testi sintetici NLP e siti web filtrati. Il modello è più adatto per i prompt con formato domanda-risposta, chat e codice.

Scarica Phi-2

L'API LLM Inference richiede che i seguenti file vengano scaricati e archiviati a livello locale:

  • tokenizer.json
  • tokenizer_config.json
  • model-00001-of-00002.safetensors
  • model-00002-of-00002.safetensors

Dopo aver scaricato i file del modello Phi-2, il modello è pronto per essere convertito nel formato MediaPipe. Segui la procedura descritta in Convertire il modello in formato MediaPipe.

Modelli esportati da AI Edge

AI Edge è un'offerta di Google che consente di convertire i modelli mappati dagli utenti in modelli TensorFlow Lite multi-firma. Per maggiori dettagli su mappatura ed esportazione dei modelli, visita la pagina GitHub di AI Edge Torch.

Dopo aver esportato il modello nel formato TFLite, il modello è pronto per essere convertito nel formato MediaPipe. Per saperne di più, consulta Convertire il modello in formato MediaPipe.

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. Numero intero
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

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