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.
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:
Web:
Android:
iOS
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:
- Generazione da testo a testo - Genera testo in base a un prompt di testo di input.
- 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.
- 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:
|
L'API LLM Inference restituisce i seguenti risultati:
|
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.
I modelli Gemma 2B sono disponibili in quattro varianti:
- gemma-2b-it-cpu-int4: modello Gemma 2B a 4 bit con compatibilità CPU.
- gemma-2b-it-cpu-int8: modello Gemma 2B a 8 bit con compatibilità CPU.
- gemma-2b-it-gpu-int4: modello Gemma 2B a 4 bit con compatibilità GPU.
- gemma-2b-it-gpu-int8: modello Gemma 2B a 8 bit con compatibilità GPU.
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.
Il modello Gemma 7B è disponibile in una variante:
- gemma-1.1-7b-it-gpu-int8: modello Gemma 7B a 8 bit con compatibilità GPU.
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.
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.
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.
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.