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 il web

L'API LLM Inference consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente nel browser per le applicazioni web, utilizzabili per eseguire un'ampia gamma di attività, come la generazione di testo, il recupero di informazioni in linguaggio naturale e il riepilogo di 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 web.

Puoi vedere questa attività in azione con la demo di MediaPipe Studio. Per ulteriori informazioni sulle funzionalità, sui modelli e sulle opzioni di configurazione di questa attività, consulta la Panoramica.

Esempio di codice

L'applicazione di esempio per l'API LLM Inference fornisce un'implementazione di base di questa attività in JavaScript come riferimento. Puoi usare questa app di esempio per iniziare a creare la tua app per la generazione di testi.

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 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 di MediaPipe Tasks, inclusi i requisiti di versione della piattaforma, consulta la Guida alla configurazione per il web.

Compatibilità del browser

L'API LLM Inference richiede un browser web con compatibilità WebGPU. Per un elenco completo dei browser compatibili, consulta l'articolo sulla compatibilità dei browser GPU.

Pacchetti JavaScript

Il codice dell'API LLM Inference è disponibile tramite il pacchetto @mediapipe/tasks-genai. Puoi trovare e scaricare queste librerie dai link forniti nella Guida alla configurazione per la 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 questa attività. Per le applicazioni web, il modello deve essere compatibile con GPU.

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: 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. Scarica la variante di modello Gemma 2B o Gemma 7B.
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.

Ti consigliamo di utilizzare Gemma 2B o Gemma 7B, che sono disponibili sui modelli Kaggle e sono disponibili 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, 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.	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

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 il parametro baseOptions oggetto modelAssetPath:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

Creare l'attività

Utilizza una delle funzioni createFrom...() dell'API LLM Inference per preparare l'attività all'esecuzione delle inferenze. Puoi utilizzare la funzione createFromModelPath() con un percorso relativo o assoluto al file del modello addestrato. L'esempio di codice utilizza la funzione createFromOptions(). Per saperne di più sulle opzioni di configurazione disponibili, consulta Opzioni di configurazione.

Il codice seguente mostra 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à prevede le seguenti opzioni di configurazione per le app web e JavaScript:

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
`loraRanks`	Il ranking LoRA deve essere utilizzato dai modelli LoRA durante il runtime. Nota: è compatibile solo con i modelli GPU.	Array numero intero	N/A

Preparazione dei dati

L'API LLM Inference accetta dati di testo (string). L'attività gestisce la pre-elaborazione dell'input dei dati, tra cui la tokenizzazione e la pre-elaborazione tensor.

L'intera pre-elaborazione viene gestita all'interno della funzione generateResponse(). Non è necessaria 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 testo di input.

Il seguente codice mostra come eseguire l'elaborazione con il modello di attività.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

Per visualizzare la risposta in streaming, usa 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 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à.

Il web supporta LoRA dinamico durante il runtime. In altre parole, gli utenti dichiarano i ranking LoRA che verranno utilizzati durante l'inizializzazione e possono scambiare diversi modelli LoRA 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, attiva il modello LoRA passando il riferimento al 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;
});