Présentation de LiteRT: l'environnement d'exécution Google hautes performances pour l'IA sur l'appareil, anciennement connu sous le nom de TensorFlow Lite.

Cette page a été traduite par l'API Cloud Translation.

Guide d'inférence LLM pour le Web

L'API Inference LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil pour les applications Web. Vous pouvez les utiliser pour effectuer un large éventail de tâches, telles que la génération de texte, la récupération d'informations sous forme de langage naturel et la synthèse de documents. La tâche est compatible avec plusieurs grands modèles de langage de texte à texte, ce qui vous permet d'appliquer les derniers modèles d'IA générative sur l'appareil à vos applications Web.

Pour ajouter rapidement l'API LLM Inference à votre application Web, suivez le guide de démarrage rapide. Pour obtenir un exemple de base d'application Web exécutant l'API d'inférence LLM, consultez l'exemple d'application. Pour en savoir plus sur le fonctionnement de l'API d'inférence LLM, consultez les sections Options de configuration, Conversion de modèle et Réglage de LORA.

Vous pouvez voir cette tâche en action avec la démo MediaPipe Studio. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la section Présentation.

Guide de démarrage rapide

Pour ajouter l'API d'inférence LLM à votre application Web, procédez comme suit : L'API d'inférence LLM nécessite un navigateur Web compatible avec WebGPU. Pour obtenir la liste complète des navigateurs compatibles, consultez la section Compatibilité des navigateurs avec les GPU.

Ajouter des dépendances

L'API Inference LLM utilise le package @mediapipe/tasks-genai.

Installez les packages requis pour le préproduction local:

npm install @mediapipe/tasks-genai

Pour déployer sur un serveur, utilisez un service de réseau de diffusion de contenu (CDN) tel que jsDelivr pour ajouter du code directement à votre page HTML:

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

Télécharger un modèle

Téléchargez Gemma-2 2B au format quantifié 8 bits à partir de Kaggle Models. Pour en savoir plus sur les modèles disponibles, consultez la documentation sur les modèles.

Stockez le modèle dans le répertoire de votre projet:

<dev-project-root>/assets/gemma-2b-it-gpu-int8.bin

Spécifiez le chemin d'accès du modèle avec le paramètre modelAssetPath de l'objet baseOptions:

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

Initialiser la tâche

Initialisez la tâche avec des options de configuration de base:

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-int8.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Exécuter la tâche

Utilisez la fonction generateResponse() pour déclencher des inférences.

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

Pour diffuser la réponse, utilisez ce qui suit:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Exemple d'application

L'application exemple est un exemple d'application de génération de texte de base pour le Web, qui utilise l'API d'inférence LLM. Vous pouvez utiliser l'application comme point de départ pour votre propre application Web ou vous y référer lorsque vous modifiez une application existante. L'exemple de code est hébergé sur GitHub.

Clonez le dépôt Git à l'aide de la commande suivante:

git clone https://github.com/google-ai-edge/mediapipe-samples

Pour en savoir plus, consultez le guide de configuration pour le Web.

Options de configuration

Utilisez les options de configuration suivantes pour configurer une application Web:

Nom de l'option	Description	Plage de valeurs	Valeur par défaut
`modelPath`	Chemin d'accès au répertoire du projet dans lequel le modèle est stocké.	CHEMIN	N/A
`maxTokens`	Nombre maximal de jetons (jetons d'entrée + jetons de sortie) gérés par le modèle.	Entier	512
`topK`	Nombre de jetons que le modèle prend en compte à chaque étape de génération. Limite les prédictions aux k jetons les plus probables.	Entier	40
`temperature`	Quantité de hasard introduite lors de la génération. Une température plus élevée génère un texte plus créatif, tandis qu'une température plus basse génère un texte plus prévisible.	Float	0,8
`randomSeed`	Graine aléatoire utilisée lors de la génération de texte.	Entier	0
`loraRanks`	Classements LoRA à utiliser par les modèles LoRA au moment de l'exécution. Remarque: Cette option n'est compatible qu'avec les modèles de GPU.	Tableau d'entiers	N/A

Conversion de modèles

L'API d'inférence LLM est compatible avec les types de modèles suivants, dont certains nécessitent une conversion de modèle. Utilisez le tableau pour identifier la méthode d'étapes requise pour votre modèle.

Modèles	Méthode de conversion	Plates-formes compatibles	Type de fichier
Gemma-3 1B	Aucune conversion requise	Android, Web	.task
Gemma 2B, Gemma 7B, Gemma-2 2B	Aucune conversion requise	Android, iOS, Web	.bin
Phi-2, StableLM, Falcon	Script de conversion MediaPipe	Android, iOS, Web	.bin
Tous les modèles LLM PyTorch	Bibliothèque générative AI Edge Torch	Android, iOS	.task

Pour savoir comment convertir d'autres modèles, consultez la section Conversion de modèles.

Personnalisation LoRA

L'API Inference LLM est compatible avec le réglage LoRA (Low-Rank Adaptation) à l'aide de la bibliothèque PEFT (Parameter-Efficient Fine-Tuning). Le réglage LoRA personnalise le comportement des LLM via un processus d'entraînement rentable, en créant un petit ensemble de poids enregistrables en fonction de nouvelles données d'entraînement plutôt que de réentraîner l'ensemble du modèle.

L'API d'inférence LLM permet d'ajouter des poids LoRA aux couches d'attention des modèles Gemma-2 2B, Gemma 2B et Phi-2. Téléchargez le modèle au format safetensors.

Le modèle de base doit être au format safetensors pour créer des poids LoRA. Après l'entraînement LoRA, vous pouvez convertir les modèles au format FlatBuffers pour les exécuter sur MediaPipe.

Préparer les pondérations LoRA

Utilisez le guide Méthodes LoRA de PEFT pour entraîner un modèle LoRA affiné sur votre propre ensemble de données.

L'API LLM Inference n'est compatible qu'avec LoRA sur les couches d'attention. Par conséquent, ne spécifiez que les couches d'attention dans LoraConfig:

# For Gemma
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"],
)

Après avoir entraîné le modèle sur l'ensemble de données préparé et enregistré le modèle, les poids du modèle LoRA affinés sont disponibles dans adapter_model.safetensors. Le fichier safetensors est le point de contrôle LoRA utilisé lors de la conversion du modèle.

Conversion de modèles

Utilisez le package Python MediaPipe pour convertir les poids du modèle au format Flatbuffer. ConversionConfig spécifie les options de modèle de base ainsi que les options LoRA supplémentaires.

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_FILE,
)

converter.convert_checkpoint(config)

Le convertisseur produit deux fichiers compatibles avec MediaPipe, l'un pour le modèle de base et l'autre pour le modèle LoRA.

Inférence de modèle LoRA

Le Web est compatible avec le LoRA dynamique pendant l'exécution, ce qui signifie que les utilisateurs déclarent les classements LoRA lors de l'initialisation. Cela signifie que vous pouvez remplacer différents modèles LoRA pendant l'exécution.

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]
});

Chargez les modèles LoRA au moment de l'exécution, après avoir initialisé le modèle de base. Déclenchez le modèle LoRA en transmettant la référence du modèle lors de la génération de la réponse 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;
});