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 LLM Inference vous permet d'exécuter de grands modèles de langage (LLM) entièrement sur le pour les applications Web, que vous pouvez utiliser pour exécuter de nombreuses telles que la génération de texte, l'extraction d'informations en langage naturel, et la synthèse de documents. Cette tâche intègre la prise en charge de plusieurs de grands modèles de langage texte-vers-texte, ce qui vous permet d'appliquer des modèles d'IA générative à vos applications Web.

Vous pouvez voir concrètement cette tâche à l'aide de MediaPipe Studio une démonstration. 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 cette tâche en JavaScript pour référence. Vous pouvez utiliser cette application exemple pour obtenir avez commencé à créer votre propre application de génération de texte.

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

Configuration

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

Compatibilité du navigateur

L'API LLM Inference nécessite un navigateur Web compatible avec WebGPU. Pour liste des navigateurs compatibles, consultez la page Navigateur GPU compatibilité.

Packages JavaScript

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

Installez les packages requis pour la préproduction locale:

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é et compatible avec tâche. Pour les applications Web, le modèle doit être compatible avec les GPU.

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

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: Cet outil fait partie d'une famille de modèles ouverts, légers et de pointe, construits à partir de les mêmes recherches et technologies utilisées pour créer modèles Gemini. Parfaitement adapté à une grande variété les tâches de génération de texte, y compris les réponses à des questions, la synthèse et le raisonnement. Téléchargez la variante de modèle Gemma 2B ou Gemma 7B.
Phi-2: 2,7 milliards de paramètres Modèle Transformer, parfaitement adapté aux questions-réponses, au chat et au code .
Falcon-RW-1B: 1 milliard modèle causal décodeur uniquement, entraîné sur 350 milliards de jetons de RefinedWeb :
StableLM-3B: 3 milliard de paramètres de modèle de langage décodeur uniquement, pré-entraîné sur 1 000 milliards de divers ensembles de données en anglais et en code.

Nous vous recommandons d'utiliser Gemma 2B ou Gemma 7B, qui sont disponibles sur Kaggle modèles et viennent dans un format déjà compatible avec l'API LLM Inference. Si vous utilisez un autre LLM, vous devez convertir le modèle en Format compatible avec MediaPipe. Pour plus d'informations sur Gemma, consultez les Site Gemma : 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

Conversion par modèle natif

Si vous utilisez un LLM externe (Phi-2, Falcon ou StableLM) ou un modèle autre que Kaggle de Gemma, utilisez nos scripts de conversion pour formater le modèle compatible avec MediaPipe.

Le processus de conversion du modèle nécessite le package PyPI MediaPipe. La conversion est disponible dans tous les packages MediaPipe après 0.10.11.

Installez et importez les dépendances à l'aide de la commande suivante:

$ python3 -m pip install mediapipe

Utilisez la bibliothèque genai.converter pour convertir le modèle:

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)

Pour convertir le modèle LoRA, ConversionConfig doit spécifier le modèle de base ainsi que d'autres options LoRA. Notez que, puisque l'API prend en charge 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 TFLite Flatbuffer, un pour le modèle de base. et l'autre pour le modèle LoRA.

Paramètre	Description	Valeurs acceptées
`input_ckpt`	Chemin d'accès au fichier `model.safetensors` ou `pytorch.bin`. Notez que parfois le format des Tensors sécurisés du modèle est segmenté en plusieurs fichiers. Par exemple, `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors`. Vous pouvez spécifier un format de fichier, tel que `model*.safetensors`.	CHEMIN
`ckpt_format`	Format de fichier du modèle.	{"safetensors", "pytorch"}
`model_type`	LLM en cours de conversion.	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	Processeur (délégué) utilisé pour exécuter le modèle.	{"cpu", "gpu"}
`output_dir`	Chemin d'accès au répertoire de sortie qui héberge les fichiers de pondération par couche.	CHEMIN
`output_tflite_file`	Chemin d'accès au fichier de sortie. Par exemple, "model_cpu.bin" ou "model_gpu.bin". Ce fichier n'est compatible qu'avec l'API d'inférence LLM et ne peut pas être utilisé comme fichier "tflite" général.	CHEMIN
`vocab_model_file`	Le chemin d'accès au répertoire qui stocke les fichiers `tokenizer.json` et `tokenizer_config.json` fichiers. Pour Gemma, pointez vers le seul fichier `tokenizer.model`.	CHEMIN
`lora_ckpt`	Chemin d'accès au fichier LoRA de la valeur Safetensors qui stocke le poids de l'adaptateur LoRA.	CHEMIN
`lora_rank`	Nombre entier représentant le rang de la méthode LoRA ckpt. Obligatoire pour convertir les pondérations Lora. Si ce champ n'est pas fourni, le convertisseur suppose qu'il n'y a pas de pondérations LoRA. Remarque: Seul le backend GPU est compatible avec la LoRA.	Entier
`lora_output_tflite_file`	Nom de fichier tflite de sortie pour les pondérations LoRA.	CHEMIN

Conversion de modèles AI Edge

Si vous utilisez un LLM mappé à un modèle TFLite via AI Edge, utilisez notre d'un script de regroupement pour créer un groupe de tâches. Le processus de regroupement avec des métadonnées supplémentaires (par exemple, paramètres de tokenisation) nécessaires pour exécuter une inférence de bout en bout.

Le processus de regroupement des modèles nécessite le package MediaPipe PyPI. La conversion est disponible dans tous les packages MediaPipe après 0.10.14.

Installez et importez les dépendances à l'aide de la commande suivante:

$ python3 -m pip install mediapipe

Utilisez la bibliothèque genai.bundler pour grouper le modèle:

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)

Paramètre	Description	Valeurs acceptées
`tflite_model`	Chemin d'accès au modèle TFLite exporté par AI Edge.	CHEMIN
`tokenizer_model`	Chemin d'accès au modèle de tokenisation SentencePiece.	CHEMIN
`start_token`	Jeton de démarrage spécifique au modèle. Le jeton de début doit être présent dans le modèle de tokenisation fourni.	STRING
`stop_tokens`	Modéliser des jetons d'arrêt spécifiques. Les jetons d'arrêt doivent être présents le modèle de tokenisation fourni.	LISTE[STRING]
`output_filename`	Nom du fichier du groupe de tâches de sortie.	CHEMIN

Ajouter le 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 l'objet baseOptions modelAssetPath. :

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

Créer la tâche

Utilisez l'une des fonctions createFrom...() de l'API LLM Inference pour préparer la tâche pour exécuter des inférences. Vous pouvez utiliser la fonction createFromModelPath() avec une chemin relatif ou absolu du fichier de modèle entraîné. L'exemple de code utilise la fonction createFromOptions(). Pour en savoir plus sur les de configuration, 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 comporte 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 stockage du modèle dans le répertoire du projet.	CHEMIN	N/A
`maxTokens`	Nombre maximal de jetons (jetons d'entrée + jetons de sortie) traités par le modèle.	Entier	512
`topK`	Nombre de jetons pris en compte par le modèle à chaque étape de génération. Limite les prédictions aux k premiers jetons les plus probables.	Entier	40
`temperature`	Quantité de caractère aléatoire introduite lors de la génération. Une augmentation favorise la créativité dans le texte généré, tandis qu'un plus la température est basse, plus la génération est prévisible.	Float	0,8
`randomSeed`	Source aléatoire utilisée lors de la génération du texte.	Entier	0
`loraRanks`	Classements LoRA à utiliser par les modèles LoRA pendant 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 d'inférence LLM accepte les données textuelles (string). La tâche gère la saisie des données le prétraitement, y compris la tokenisation et le prétraitement des Tensors.

L'ensemble du prétraitement est géré dans la fonction generateResponse(). Il y a aucun prétraitement supplémentaire du texte d'entrée 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 texte d'entrée.

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

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

Pour diffuser la réponse, utilisez le code suivant:

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 LoRA (Low-Rank Adaptation) pour les grands modèles de langage. À l'aide de modèles LoRA affinés, les développeurs peuvent personnaliser le comportement des LLM grâce à un processus d'entraînement économique.

La compatibilité LoRA de l'API d'inférence LLM fonctionne avec les modèles Gemma-2B et Phi-2 pour le backend du GPU, avec les pondérations LoRA applicables uniquement aux couches d'attention. Ce l'implémentation initiale sert d'API expérimentale pour les développements futurs Nous prévoyons de prendre en charge d'autres modèles et différents types de couches mises à jour.

Préparer les modèles LoRA

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

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

Pour les tests, il existe des modèles LoRA affinés accessibles au public et adaptés à l'API d'inférence LLM 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é sur l'ensemble de données préparé et enregistré le modèle, vous obtenez un fichier adapter_model.safetensors contenant les pondérations affinées du modèle LoRA. Le fichier Safetensors est le point de contrôle LoRA utilisé lors de la conversion du modèle.

L'étape suivante consiste à convertir les pondérations du modèle en un Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. Le ConversionConfig doit spécifier les options du modèle de base ainsi que les options LoRA supplémentaires. Comme l'API n'accepte que 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 TFLite Flatbuffer, 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 Web, Android et iOS a été mise à jour pour prendre en charge l'inférence de modèles LoRA. Le Web est compatible avec la technologie LoRA dynamique, qui peut changer de modèle LoRA pendant l'exécution. Android et iOS sont compatibles avec la fonctionnalité LoRA statique, qui utilise les mêmes pondérations LoRA pendant toute la durée de vie de la tâche.

Le Web est compatible avec la fonctionnalité LoRA dynamique pendant l'exécution. Autrement dit, les utilisateurs déclarent que les rangs LoRA 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]
});

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