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 d'inférence LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement dans le navigateur 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.

La tâche est compatible avec les variantes suivantes de Gemma: Gemma-2 2B, Gemma 2B et Gemma 7B. Gemma est une famille de modèles ouverts, légers et à la pointe de la technologie, basés sur les mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Il est également compatible avec les modèles externes suivants: Phi-2, Falcon-RW-1B et StableLM-3B.

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.

Exemple de code

L'exemple d'application de l'API d'inférence LLM fournit une implémentation de base de cette tâche en JavaScript pour référence. Vous pouvez utiliser cet exemple d'application pour commencer à créer votre propre application de génération de texte.

Vous pouvez accéder à l'exemple d'application de l'API d'inférence LLM sur GitHub.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement et vos projets de code spécifiquement pour utiliser l'API d'inférence LLM. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour utiliser MediaPipe Tasks, y compris les exigences concernant les versions de plate-forme, consultez le guide de configuration pour le Web.

Compatibilité du navigateur

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.

Packages JavaScript

Le code de l'API d'inférence LLM est disponible via le package @mediapipe/tasks-genai. Vous pouvez trouver et télécharger ces bibliothèques à partir des liens fournis dans le guide de configuration de la plate-forme.

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>

Modèle

L'API d'inférence LLM MediaPipe nécessite un modèle entraîné compatible avec cette tâche. Pour les applications Web, le modèle doit être compatible avec le GPU.

Pour en savoir plus sur les modèles entraînés disponibles pour l'API d'inférence LLM, consultez la section Modèles de la présentation de la tâche.

Télécharger un modèle

Avant d'initialiser l'API d'inférence LLM, téléchargez l'un des modèles compatibles et stockez le fichier dans le répertoire de votre projet:

Gemma-2B : dernière version de la famille de modèles Gemma. Fait partie d'une famille de modèles ouverts, légers et à la pointe de la technologie, basés sur la recherche et la technologie utilisées pour créer les modèles Gemini.
Gemma 2B : fait partie d'une famille de modèles ouverts, légers et de pointe conçus à partir des mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Convient à diverses tâches de génération de texte, y compris la réponse à des questions, la synthèse et le raisonnement.
Phi-2: modèle Transformer à 2, 7 milliards de paramètres, le plus adapté aux formats question-réponse, chat et code.
Falcon-RW-1B: modèle de décodeur causal à un milliard de paramètres entraîné sur 350 milliards de jetons de RefinedWeb.
StableLM-3B: modèle de langage avec 3 milliards de paramètres, uniquement pour le décodeur, pré-entraîné sur 1 billion de jetons provenant de divers ensembles de données en anglais et en code.

En plus des modèles compatibles, vous pouvez utiliser AI Edge Torch de Google pour exporter des modèles PyTorch vers des modèles LiteRT (tflite) à signature multiple. Pour en savoir plus, consultez Convertisseur génératif Torch pour les modèles PyTorch.

Nous vous recommandons d'utiliser Gemma-2 2B, qui est disponible sur Kaggle Models. Pour en savoir plus sur les autres modèles disponibles, consultez la section Modèles de la présentation des tâches.

Convertir le modèle au format MediaPipe

L'API d'inférence LLM est compatible avec deux types de modèles, 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	File type
Modèles compatibles	Gemma 2B, Gemma 7B, Gemma-2 2B, Phi-2, StableLM, Falcon	MediaPipe	Android, iOS, Web	.bin
Autres modèles PyTorch	Tous les modèles LLM PyTorch	Bibliothèque générative AI Edge Torch	Android, iOS	.task

Nous hébergeons les fichiers .bin convertis pour Gemma 2B, Gemma 7B et Gemma-2 2B sur Kaggle. Ces modèles peuvent être déployés directement à l'aide de notre API d'inférence LLM. Pour savoir comment convertir d'autres modèles, consultez la section Convertir des modèles.

Ajouter un modèle au répertoire du projet

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

<dev-project-root>/assets/gemma-2b-it-gpu-int4.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-int4.bin`}

Créer la tâche

Utilisez l'une des fonctions createFrom...() de l'API d'inférence LLM pour préparer la tâche à l'exécution d'inférences. Vous pouvez utiliser la fonction createFromModelPath() avec un chemin d'accès relatif ou absolu au fichier de modèle entraîné. L'exemple de code utilise la fonction createFromOptions(). Pour en savoir plus sur les options de configuration disponibles, consultez la section Options de configuration.

Le code suivant montre comment créer et configurer cette tâche:

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

Options de configuration

Cette tâche propose les options de configuration suivantes pour les applications Web et JavaScript:

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

Préparer les données

L'API LLM Inference accepte les données textuelles (string). La tâche gère le prétraitement de l'entrée de données, y compris la tokenisation et le prétraitement des tenseurs.

Tout le prétraitement est géré dans la fonction generateResponse(). Aucun prétraitement supplémentaire du texte saisi n'est nécessaire.

const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";

Exécuter la tâche

L'API d'inférence LLM utilise la fonction generateResponse() pour déclencher des inférences. Pour la classification de texte, cela signifie renvoyer les catégories possibles pour le texte d'entrée.

Le code suivant montre comment exécuter le traitement avec le modèle de tâche.

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

Gérer et afficher les résultats

L'API d'inférence LLM renvoie une chaîne, qui inclut le texte de réponse généré.

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]

Personnalisation du modèle LoRA

L'API d'inférence LLM Mediapipe peut être configurée pour prendre en charge l'adaptation faible (LoRA) pour les grands modèles de langage. Grâce à des modèles LoRA optimisés, les développeurs peuvent personnaliser le comportement des LLM via un processus d'entraînement rentable.

La prise en charge de LoRA par l'API d'inférence LLM fonctionne pour toutes les variantes Gemma et les modèles Phi-2 pour le backend GPU, avec des poids LoRA applicables uniquement aux couches d'attention. Cette implémentation initiale sert d'API expérimentale pour les futurs développements. Nous prévoyons de prendre en charge davantage de modèles et différents types de calques dans les prochaines mises à jour.

Préparer des modèles LoRA

Suivez les instructions sur HuggingFace pour entraîner un modèle LoRA affiné sur votre propre ensemble de données avec les types de modèles compatibles, Gemma ou Phi-2. Les modèles Gemma-2 2B, Gemma 2B et Phi-2 sont tous disponibles sur HuggingFace au format safetensors. Étant donné que l'API d'inférence LLM n'est compatible qu'avec LORA sur les couches d'attention, ne spécifiez que les couches d'attention lors de la création de LoraConfig comme suit:

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

Pour les tests, des modèles LoRA affinés accessibles au public qui correspondent à l'API d'inférence LLM sont disponibles sur HuggingFace. Par exemple, monsterapi/gemma-2b-lora-maths-orca-200k pour Gemma-2B et lole25/phi-2-sft-ultrachat-lora pour Phi-2.

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

L'étape suivante consiste à convertir les poids du modèle en Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. ConversionConfig doit spécifier les options de modèle de base ainsi que les options LoRA supplémentaires. Notez que, comme l'API n'est compatible qu'avec l'inférence LoRA avec GPU, le backend doit être défini sur '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)

Le convertisseur génère deux fichiers FlatBuffer TFLite, l'un pour le modèle de base et l'autre pour le modèle LoRA.

Inférence de modèle LoRA

L'API d'inférence LLM pour le Web, Android et iOS est mise à jour pour prendre en charge l'inférence de modèle LoRA.

Le Web est compatible avec le LoRA dynamique lors de l'exécution. Autrement dit, les utilisateurs déclarent les rangs LoRA qui seront utilisés lors de l'initialisation et peuvent échanger 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]
});

Lors de l'exécution, une fois le modèle de base initialisé, chargez les modèles LoRA à utiliser. Déclenchez également le modèle LoRA en transmettant la référence du modèle LoRA 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;
});