Guida all'inferenza LLM per il web

di Gemini Advanced.

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. {&quot;PHI_2&quot;, &quot;FALCON_RW_1B&quot;, &quot;STABLELM_4E1T_3B&quot;, &quot;GEMMA_2B&quot;}
backend Il processore (delegato) utilizzato per eseguire il modello. {&quot;cpu&quot;, &quot;gpu&quot;}
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;
});