L'API LLM Inference consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente browser per applicazioni web, che puoi usare per eseguire una vasta gamma 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 app web.
Puoi vedere questa attività in azione con MediaPipe Studio una demo. Per ulteriori informazioni su funzionalità, modelli e opzioni di configurazione di questa attività, consulta la Panoramica.
Esempio di codice
L'applicazione di esempio per l'API Inference LLM fornisce un'implementazione di base questa attività in JavaScript come riferimento. Puoi utilizzare questa app di esempio per hai iniziato a creare la tua app per la generazione di testo.
Puoi accedere all'app di esempio dell'API LLM Inference su GitHub.
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 l'impostazione dell'ambiente di sviluppo per l'utilizzo di Attività di MediaPipe, tra cui: i requisiti di versione della piattaforma, consulta la Guida alla configurazione per Web.
Compatibilità del browser
L'API LLM Inference richiede un browser web con compatibilità con WebGPU. Per un elenco di browser compatibili, vedi Browser GPU compatibilità.
Pacchetti JavaScript
Il codice dell'API LLM Inference è disponibile tramite
@mediapipe/tasks-genai
pacchetto. Puoi trovare e scaricare queste librerie dai link forniti nei
guida alla configurazione della piattaforma.
Installa i pacchetti richiesti per la gestione temporanea locale:
npm install @mediapipe/tasks-genai
Per eseguire il deployment su un server, utilizza un servizio di rete CDN (Content Delivery Network) come jsDelivr per aggiungere il codice direttamente alla pagina HTML:
<head>
<script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
crossorigin="anonymous"></script>
</head>
Modello
L'API MediaPipe LLM Inference richiede un modello addestrato compatibile con dell'attività. Per le applicazioni web, il modello deve essere compatibile con la GPU.
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: 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. Scarica la variante Gemma 2B o Gemma 7B.
- 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.
Ti consigliamo di usare Gemma 2B o Gemma 7B, disponibili su Kaggle di grandi dimensioni e vengono 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, vedi Sito di Gemma. Per ulteriori informazioni sul altri modelli 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.
| Parametro | Descrizione | Valori accettati |
|---|---|---|
input_ckpt |
Il percorso del file model.safetensors o pytorch.bin. Nota che a volte il formato dei tensori di sicurezza del modello viene suddiviso in più file, ad esempio model-00001-of-00003.safetensors e model-00001-of-00003.safetensors. Puoi specificare un pattern di file, ad esempio model*.safetensors. |
PERCORSO |
ckpt_format |
Il formato file del modello. | {"safetensors", "pytorch"} |
model_type |
L'LLM da convertire. | {"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 di peso per livello. | PERCORSO |
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 Inference LLM e non può essere utilizzato come file "tflite" generale. | PERCORSO |
vocab_model_file |
Il percorso della directory in cui sono archiviati i file tokenizer.json e
tokenizer_config.json file. Per Gemma, posiziona il puntatore del mouse sul singolo file tokenizer.model. |
PERCORSO |
lora_ckpt |
Il percorso del ckpt LoRA del file securetensors in cui è archiviato il peso dell'adattatore LoRA. | PERCORSO |
lora_rank |
Un numero intero che rappresenta il rango di LoRA ckpt. Obbligatorio per convertire i pesi Lora. Se non viene specificato, il convertitore presuppone che non siano presenti pesi LoRA. Nota: solo il backend della GPU supporta LoRA. | Numero intero |
lora_output_tflite_file |
Il nome file tflite di output per i pesi LoRA. | PERCORSO |
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)
| Parametro | Descrizione | Valori accettati |
|---|---|---|
tflite_model |
Il percorso del modello TFLite esportato da AI Edge. | PERCORSO |
tokenizer_model |
Il percorso del modello tokenizzatore SentencePiece. | PERCORSO |
start_token |
Token iniziale specifico per il modello. Il token iniziale deve essere presente nella fornito dal modello di tokenizzatore. | STRINGA |
stop_tokens |
Token di interruzione specifici del modello. I token di interruzione devono essere presenti nel fornito dal modello di tokenizzatore. | ELENCO[STRING] |
output_filename |
Il nome del file del bundle di attività di output. | PERCORSO |
Aggiungi modello alla directory del progetto
Archivia il modello nella directory del progetto:
<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin
Specifica il percorso del modello con l'oggetto baseOptions modelAssetPath
:
baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}
Crea l'attività
Utilizza una delle funzioni createFrom...() dell'API LLM Inference per preparare l'attività per
delle inferenze in esecuzione. Puoi utilizzare la funzione createFromModelPath() con una
relativo o assoluto al file del modello addestrato. L'esempio di codice utilizza la proprietà
Funzione createFromOptions(). Per ulteriori informazioni sulle
di configurazione, vedi Opzioni di configurazione.
Il codice seguente illustra come creare e configurare questa attività:
const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
baseOptions: {
modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
},
maxTokens: 1000,
topK: 40,
temperature: 0.8,
randomSeed: 101
});
Opzioni di configurazione
Questa attività include le seguenti opzioni di configurazione per le app web e JavaScript:
| Nome opzione | Descrizione | Intervallo di valori | Valore predefinito |
|---|---|---|---|
modelPath |
Il percorso di archiviazione del modello all'interno della directory del progetto. | PERCORSO | N/D |
maxTokens |
Il numero massimo di token (token di input + token di output) gestiti dal modello. | Numero intero | 512 |
topK |
Il numero di token presi in considerazione dal modello in ogni passaggio della generazione. Limita le previsioni ai token top-k più probabili. | Numero intero | 40 |
temperature |
La quantità di casualità introdotta durante la generazione. Un della temperatura aumenta la creatività del testo generato, mentre una temperatura più bassa genera una generazione più prevedibile. | Float | 0,8 |
randomSeed |
Il seed casuale utilizzato durante la generazione del testo. | Numero intero | 0 |
loraRanks |
Ranking LoRA che devono essere utilizzati dai modelli LoRA durante il runtime. Nota: è compatibile solo con i modelli di GPU. | Array intero | N/D |
Preparazione dei dati
L'API LLM Inference accetta dati di testo (string). L'attività gestisce l'input dei dati
pre-elaborazione, tra cui la tokenizzazione e la pre-elaborazione dei tensori.
Tutte le pre-elaborazioni vengono gestite all'interno della funzione generateResponse(). C'è
senza bisogno di ulteriore pre-elaborazione del testo di input.
const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";
Esegui l'attività
L'API LLM Inference utilizza la funzione generateResponse() per attivare le inferenze.
Per la classificazione del testo, questo significa restituire le possibili categorie per il
del testo di input.
Il codice seguente mostra come eseguire l'elaborazione con l'attività un modello di machine learning.
const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;
Per trasmettere la risposta in modalità flusso, utilizza quanto segue:
llmInference.generateResponse(
inputPrompt,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});
Gestire e visualizzare i risultati
L'API LLM Inference restituisce una stringa 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 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à.
Il web supporta LoRA dinamica durante il runtime. In altre parole, gli utenti dichiarano che i livelli LoRA verranno utilizzati durante l'inizializzazione e possono scambiare modelli LoRA diversi durante il runtime.const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
// options for the base model
...
// LoRA ranks to be used by the LoRA models during runtime
loraRanks: [4, 8, 16]
});
Durante il runtime, dopo l'inizializzazione del modello di base, carica i modelli LoRA da utilizzare. Inoltre, puoi attivare il modello LoRA passando il riferimento del modello LoRA durante la generazione della risposta LLM.
// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);
// Specify LoRA model to be used during inference
llmInference.generateResponse(
inputPrompt,
loraModelRank4,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});