Guide d'inférence LLM

L'API d'inférence LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil, que vous pouvez 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 conversion texte-texte, ce qui vous permet d'appliquer les derniers modèles d'IA générative sur l'appareil à vos applications et produits.

Essayez !arrow_forward

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.

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) multisignature, qui sont regroupés avec des paramètres de tokenizer pour créer des bundles de tâches compatibles avec l'API d'inférence LLM. Les modèles convertis avec AI Edge Torch ne peuvent s'exécuter que sur le backend du processeur et sont donc limités à Android et iOS.

Premiers pas

Pour commencer à utiliser cette tâche, suivez l'un de ces guides d'implémentation pour votre plate-forme cible. Ces guides spécifiques à la plate-forme vous expliquent comment implémenter cette tâche de manière basique, avec des exemples de code qui utilisent un modèle disponible et les options de configuration recommandées:

• Web:

  • Guide
  • Exemple de code

• Android :

  • Guide
  • Exemple de code

• iOS

  • Guide
  • Exemple de code

Détails de la tâche

Cette section décrit les fonctionnalités, les entrées, les sorties et les options de configuration de cette tâche.

Fonctionnalités

L'API LLM Inference contient les principales fonctionnalités suivantes:

1. Génération de texte à partir de texte : génère du texte à partir d'une requête textuelle.
2. Sélection de LLM : appliquez plusieurs modèles pour adapter l'application à vos cas d'utilisation spécifiques. Vous pouvez également réentraîner le modèle et appliquer des poids personnalisés.
3. Compatibilité avec LoRA : étendez et personnalisez les fonctionnalités du LLM avec le modèle LoRA en l'entraînant sur l'ensemble de données complet ou en utilisant des modèles LoRA prédéfinis préparés par la communauté Open Source (non compatibles avec les modèles convertis avec l'API générative Torch Edge AI).

Options de configuration

Cette tâche propose les options de configuration suivantes:

Modèles

L'API d'inférence LLM est compatible avec de nombreux grands modèles de langage de texte à texte, y compris la prise en charge intégrée de plusieurs modèles optimisés pour s'exécuter sur les navigateurs et les appareils mobiles. Ces modèles légers peuvent être utilisés pour exécuter des inférences entièrement sur l'appareil.

Avant d'initialiser l'API d'inférence LLM, téléchargez un modèle et stockez le fichier dans le répertoire de votre projet. Vous pouvez utiliser un modèle préconverti ou convertir un modèle dans un format compatible avec 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.

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.

Gemma-2 2B

Gemma-2 2B est le dernier modèle de la famille Gemma, une gamme de modèles ouverts, légers et de pointe basés sur les mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Le modèle contient 2 milliards de paramètres et de pondérations ouvertes. Gemma-2 2B est réputé pour ses compétences de raisonnement de pointe pour les modèles de sa catégorie.

Télécharger Gemma-2 2B

Les modèles Gemma-2 2B sont disponibles dans les variantes suivantes:

• gemma2-2b-it-cpu-int8 : modèle Gemma-2 2B 8 bits compatible avec le processeur.
• gemma2-2b-it-gpu-int8 : modèle Gemma-2 2B 8 bits avec compatibilité GPU.

Vous pouvez également ajuster le modèle et ajouter de nouveaux poids avant de l'ajouter à l'application. Pour en savoir plus sur l'ajustement et la personnalisation de Gemma, consultez Ajuster Gemma. Après avoir téléchargé Gemma-2B depuis Kaggle Models, le modèle est déjà au format approprié pour être utilisé avec MediaPipe Tasks.

Gemma 2B

Gemma 2B fait partie d'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. Le modèle contient 2 milliards de paramètres et de pondérations ouvertes. Ce modèle est adapté à diverses tâches de génération de texte, y compris les systèmes de questions-réponses, la synthèse et le raisonnement.

Télécharger Gemma 2B

Les modèles Gemma 2B sont disponibles dans les variantes suivantes:

• gemma-2b-it-cpu-int4 : modèle Gemma 2B 4 bits compatible avec le processeur.
• gemma-2b-it-cpu-int8 : modèle Gemma 2B 8 bits compatible avec le processeur.
• gemma-2b-it-gpu-int4 : modèle Gemma 2B 4 bits avec compatibilité GPU.
• gemma-2b-it-gpu-int8 : modèle Gemma 2B 8 bits avec compatibilité GPU.

Vous pouvez également ajuster le modèle et ajouter de nouveaux poids avant de l'ajouter à l'application. Pour en savoir plus sur l'ajustement et la personnalisation de Gemma, consultez Ajuster Gemma. Après avoir téléchargé Gemma 2B à partir de Kaggle Models, le modèle est déjà au format approprié pour être utilisé avec MediaPipe Tasks.

Gemma 7B

Gemma 7B est un modèle Gemma plus volumineux avec 7 milliards de paramètres et des poids ouverts. Le modèle est plus performant pour diverses tâches de génération de texte, y compris les réponses aux questions, la synthèse et le raisonnement. Gemma 7B n'est compatible qu'avec le Web.

Télécharger Gemma 7B

Le modèle Gemma 7B est disponible en une seule variante:

• gemma-1.1-7b-it-gpu-int8 : modèle 8 bits de Gemma 7B avec compatibilité GPU.

Après avoir téléchargé Gemma 7B à partir de Kaggle Models, le modèle est déjà au format approprié pour être utilisé avec MediaPipe.

Falcon 1B

Falcon-1B est un modèle de décodeur causal à 1 milliard de paramètres entraîné sur 350 milliards de jetons de RefinedWeb.

Télécharger Falcon 1B

L'API LLM Inference nécessite que les fichiers suivants soient téléchargés et stockés localement:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Après avoir téléchargé les fichiers de modèle Falcon, le modèle est prêt à être converti au format MediaPipe à l'aide d'un script de conversion. Suivez la procédure décrite dans la section Script de conversion pour les modèles compatibles.

StableLM 3B

StableLM-3B est un modèle de langage à 3 milliards de paramètres, uniquement décodeur, pré-entraîné sur 1 billion de jetons de divers ensembles de données en anglais et en code pendant quatre époques.

Télécharger StableLM 3B

L'API LLM Inference nécessite que les fichiers suivants soient téléchargés et stockés localement:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

Après avoir téléchargé les fichiers de modèle StableLM, le modèle est prêt à être converti au format MediaPipe à l'aide d'un script de conversion. Suivez la procédure décrite dans la section Script de conversion pour les modèles compatibles.

Phi-2

Phi-2 est un modèle Transformer à 2,7 milliards de paramètres. Elle a été entraînée à l'aide de divers textes synthétiques de NLP et de sites Web filtrés. Ce modèle est le plus adapté aux requêtes utilisant les formats Question-Réponse, Chat et Code.

Télécharger Phi-2

L'API LLM Inference nécessite que les fichiers suivants soient téléchargés et stockés localement:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Après avoir téléchargé les fichiers de modèle Phi-2, le modèle est prêt à être converti au format MediaPipe à l'aide d'un script de conversion. Suivez la procédure décrite dans la section Script de conversion pour les modèles compatibles.

Modèles génératifs PyTorch

Les modèles génératifs PyTorch peuvent être convertis en format compatible avec MediaPipe à l'aide de l'API générative AI Edge Torch. Vous pouvez utiliser l'API pour convertir des modèles PyTorch en modèles LiteRT (TensorFlow Lite) à signature multiple. Pour en savoir plus sur la cartographie et l'exportation de modèles, consultez la page GitHub d'AI Edge Torch.

Si vous souhaitez utiliser l'API AI Edge Torch Generative pour convertir un modèle PyTorch, suivez les étapes de la section Convertisseur Torch Generative pour les modèles PyTorch.

Conversion de modèles

L'API d'inférence LLM MediaPipe vous permet d'exécuter une grande variété de grands modèles de langage sur l'appareil. Cela inclut les modèles qui ont été préconvertis dans un format compatible avec MediaPipe, ainsi que d'autres modèles pouvant être convertis à l'aide d'un script de conversion ou de la bibliothèque AI Edge Torch.

L'API d'inférence LLM accepte les modèles aux formats de fichiers .bin et .task. Les modèles préconvertis et les modèles convertis avec le script de conversion seront des fichiers .bin, tandis que les modèles convertis avec la bibliothèque AI Edge Torch seront des fichiers .task. Ne modifiez pas manuellement les formats de fichier de vos modèles convertis.

L'API d'inférence LLM contient trois chemins de conversion de modèle:

• Modèles préconvertis (Gemma 2B, Gemma 7B, Gemma-2 2B): aucune conversion requise.
• Modèles compatibles (Phi-2, StableLM, Falcon): script de conversion MediaPipe.
• Autres modèles PyTorch (tous les modèles LLM PyTorch): API générative Torch d'IA Edge.

Modèles préconvertis

Les modèles Gemma-2 2B, Gemma 2B et Gemma 7B sont disponibles en tant que modèles préconvertis au format MediaPipe. Ces modèles ne nécessitent aucune étape de conversion supplémentaire de la part de l'utilisateur et peuvent être exécutés tels quels avec l'API d'inférence LLM.

Vous pouvez télécharger Gemma-2 2B à partir de Kaggle Models:

• gemma2-2b-it-cpu-int8 : modèle Gemma-2 2B 8 bits compatible avec le processeur.
• gemma2-2b-it-gpu-int8 : modèle Gemma-2 2B 8 bits avec compatibilité GPU.

Vous pouvez télécharger des variantes de Gemma 2B à partir de Kaggle Models:

• gemma-2b-it-cpu-int4 : modèle Gemma 2B 4 bits compatible avec le processeur.
• gemma-2b-it-cpu-int8 : modèle Gemma 2B 8 bits compatible avec le processeur.
• gemma-2b-it-gpu-int4 : modèle Gemma 2B 4 bits avec compatibilité GPU.
• gemma-2b-it-gpu-int8 : modèle Gemma 2B 8 bits avec compatibilité GPU.

Vous pouvez télécharger Gemma 7B à partir de Kaggle Models:

• gemma-1.1-7b-it-gpu-int8 : modèle 8 bits de Gemma 7B avec compatibilité GPU.

Pour en savoir plus sur les modèles Gemma, consultez la documentation sur Gemma-2 2B, Gemma 2B et Gemma 7B.

Script de conversion pour les modèles compatibles

Le package MediaPipe propose un script de conversion pour convertir les modèles externes suivants dans un format compatible avec MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

Pour en savoir plus sur les modèles externes compatibles, consultez la documentation sur Falcon 1B, StableLM 3B et Phi-2.

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

Installez et importez les dépendances avec 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 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.

Convertisseur génératif Torch pour les modèles PyTorch

Les modèles génératifs PyTorch peuvent être convertis en format compatible avec MediaPipe à l'aide de l'API générative AI Edge Torch. Vous pouvez utiliser l'API pour créer, convertir et quantizer des LLM PyTorch à utiliser avec l'API Inference LLM. Le convertisseur génératif Torch ne convertit que pour le processeur et nécessite une machine Linux avec au moins 64 Go de RAM.

Pour convertir un modèle PyTorch avec l'API AI Edge Torch Generative, procédez comme suit:

1. Télécharger les points de contrôle du modèle PyTorch
2. Utilisez l'API générative Torch AI Edge pour créer, convertir et quantizer le modèle dans un format de fichier compatible avec MediaPipe (.tflite).
3. Créez un bundle de tâches (.task) à partir du fichier tflite et du tokenizer du modèle.

Pour créer un groupe de tâches, utilisez le script de regroupement pour créer un groupe de tâches. Le processus de regroupement empaquette le modèle mappé avec des métadonnées supplémentaires (par exemple, Paramètres du tokenizer) nécessaires pour exécuter l'inférence de bout en bout.

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

Installez et importez les dépendances avec la commande suivante:

$ python3 -m pip install mediapipe

Utilisez la bibliothèque genai.bundler pour regrouper 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)

Personnalisation LoRA

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.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Pour exécuter l'inférence LLM avec LoRA, utilisez les mêmes méthodes generateResponse() ou generateResponseAsync() que le modèle de base.