Guide d'inférence LLM

L'API LLM Inference vous permet d'exécuter de 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 en langage naturel et la synthèse de documents. Cette tâche est compatible avec plusieurs grands modèles de langage texte-vers-texte, ce qui vous permet d'appliquer les derniers modèles d'IA générative sur l'appareil à vos applications et produits.

Essayer

La tâche est compatible avec Gemma 2B et 7B, qui font partie d'une famille de modèles ouverts légers et de pointe, construits à partir des 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 de manière native, les utilisateurs peuvent mapper d'autres modèles à l'aide des offres AI Edge de Google (y compris le mappage des modèles PyTorch). Cela permet aux utilisateurs d'exporter un modèle mappé dans des modèles TensorFlow Lite à signatures multiples, qui sont associés à des paramètres de tokenisation pour créer un groupe de tâches.

Commencer

Commencez à utiliser cette tâche en suivant l'un de ces guides d'implémentation pour votre plate-forme cible. Ces guides spécifiques à la plate-forme vous guident tout au long de l'implémentation de base de cette tâche, avec des exemples de code utilisant un modèle disponible et les options de configuration recommandées:

Détails de la tâche

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

Caractéristiques

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

  1. Génération de texte en texte : générez du texte en fonction d'une requête textuelle d'entrée.
  2. Sélection 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 lui appliquer des pondérations personnalisées.
  3. Prise en charge de LoRA : étendez et personnalisez la fonctionnalité LLM avec un modèle LoRA soit en l'entraînant sur l'intégralité de votre ensemble de données, soit en utilisant des modèles LoRA prédéfinis préparés par la communauté Open Source (modèles natifs uniquement).
Entrées des tâches Sorties de tâches
L'API LLM Inference accepte les entrées suivantes:
  • Requête textuelle (par exemple, une question, l'objet d'un e-mail, un document à résumer)
 L'API LLM Inference renvoie les résultats suivants:
  • Texte généré en fonction de l'invite d'entrée (par exemple, une réponse à la question, un brouillon d'e-mail, un résumé du document)

Options de configuration

Cette tâche comporte les options de configuration suivantes:

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. PATH 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 que le modèle considère à chaque étape de génération. Limite les prédictions aux k jetons les plus probables. Lorsque vous définissez topK, vous devez également définir une valeur pour randomSeed. Entier 40
temperature Quantité de hasard introduit lors de la génération. Une température plus élevée accroît la créativité dans le texte généré, tandis qu'une température plus basse produit une génération plus prévisible. Lorsque vous définissez temperature, vous devez également définir une valeur pour randomSeed. Nombre à virgule flottante 0,8
randomSeed Valeur initiale aléatoire utilisée lors de la génération de texte. Entier 0
loraPath Chemin absolu vers le modèle LoRA localement sur l'appareil. Remarque: Ceci n'est compatible qu'avec les modèles de GPU. PATH N/A
resultListener Définit l'écouteur de résultats pour recevoir les résultats de manière asynchrone. Ne s'applique que lors de l'utilisation de la méthode de génération asynchrone. N/A N/A
errorListener Définit un écouteur d'erreurs facultatif. N/A N/A

Modèles

L'API LLM Inference est compatible avec les grands modèles de langage texte-vers-texte diffusables, optimisés pour s'exécuter dans des navigateurs et des appareils mobiles. Ces modèles légers peuvent être téléchargés pour exécuter des inférences entièrement sur l'appareil.

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

Gemma 2B

Gemma 2B fait partie d'une famille de modèles ouverts légers et de pointe, construits à partir des 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 des pondérations ouvertes. Ce modèle est adapté à diverses tâches de génération de texte, y compris la réponse à des questions, la synthèse et le raisonnement.

Télécharger Gemma 2B

Les modèles Gemma 2B se déclinent en quatre variantes:

Vous pouvez également régler le modèle et ajouter de nouvelles pondérations avant de l'ajouter à l'application. Pour plus d'informations sur le réglage et la personnalisation de la gemma, consultez la page Régler la gemma. Après avoir téléchargé Gemma à partir des modèles Kaggle, le modèle est déjà au format approprié pour une utilisation avec MediaPipe.

Si vous téléchargez Gemma 2B depuis Hugging Face, vous devez convertir le modèle dans un format compatible avec MediaPipe. L'API LLM Inference nécessite le téléchargement et la conversion des fichiers suivants:

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

Gemma 7B

Gemma 7B est un modèle Gemma plus grand avec 7 milliards de paramètres et des pondérations ouvertes. Le modèle est plus performant pour diverses tâches de génération de texte, telles que la réponse à des questions, la synthèse et le raisonnement. Gemma 7B n'est disponible que sur le Web.

Télécharger Gemma 7B

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

Si vous téléchargez Gemma 7B depuis Hugging Face, vous devez convertir le modèle dans un format compatible avec MediaPipe. L'API LLM Inference nécessite le téléchargement et la conversion des fichiers suivants:

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

Falcon 1B

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

Télécharger Falcon 1B

L'API LLM Inference nécessite le téléchargement et le stockage local des fichiers suivants:

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

Après avoir téléchargé les fichiers du modèle Falcon, le modèle est prêt à être converti au format MediaPipe. Suivez la procédure décrite dans Convertir le modèle au format MediaPipe.

StableLM 3B

StableLM-3B est un modèle de langage composé de trois milliards de paramètres, uniquement basé sur un décodeur, pré-entraîné sur 1 000 milliards de jetons d'ensembles de données de code et d'anglais variés pendant quatre époques.

Télécharger StableLM 3B

L'API LLM Inference nécessite le téléchargement et le stockage local des fichiers suivants:

  • 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. Suivez la procédure décrite dans Convertir le modèle au format MediaPipe.

Phi-2

Phi-2 est un modèle Transformer de 2,7 milliards de paramètres. Il a été entraîné à l'aide de divers textes synthétiques TLN et de sites Web filtrés. Il est particulièrement adapté aux requêtes utilisant le format de question/réponse, de chat ou de code.

Télécharger Phi-2

L'API LLM Inference nécessite le téléchargement et le stockage local des fichiers suivants:

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

Après avoir téléchargé les fichiers du modèle Phi-2, le modèle est prêt à être converti au format MediaPipe. Suivez la procédure décrite dans Convertir le modèle au format MediaPipe.

Modèles AI Edge exportés

AI Edge est une offre Google qui vous permet de convertir des modèles mappés par l'utilisateur en modèles TensorFlow Lite à plusieurs signatures. Pour en savoir plus sur le mappage et l'exportation de modèles, consultez la page GitHub d'AI Edge Torch.

Après avoir exporté le modèle au format TFLite, il est prêt à être converti au format MediaPipe. Pour en savoir plus, consultez Convertir le modèle au format MediaPipe.

Convertir le modèle au format MediaPipe

Conversion par modèle natif

Si vous utilisez un LLM externe (Phi-2, Falcon ou StableLM) ou une version de Gemma autre que Kaggle, servez-vous de nos scripts de conversion pour mettre en forme le modèle afin qu'il soit compatible avec MediaPipe.

Le processus de conversion du modèle nécessite le package PyPI MediaPipe. 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 de LoRA, ConversionConfig doit spécifier les options du modèle de base ainsi que des options de 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 affiche deux fichiers de tampon plat TFLite, l'un pour le modèle de base et l'autre pour le modèle LoRA.

Paramètres Description Valeurs acceptées
input_ckpt Chemin d'accès au fichier model.safetensors ou pytorch.bin. Notez que parfois, le format safetensors du modèle est segmenté en plusieurs fichiers, par exemple model-00001-of-00003.safetensors ou model-00001-of-00003.safetensors. Vous pouvez spécifier un format de fichier, par exemple model*.safetensors. PATH
ckpt_format Format de fichier du modèle. {"safetensors", "pytorch"}
model_type Le 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. PATH
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 LLM Inference et ne peut pas être utilisé comme fichier "tflite" général. PATH
vocab_model_file Chemin d'accès au répertoire qui stocke les fichiers tokenizer.json et tokenizer_config.json. Pour Gemma, pointez sur le seul fichier tokenizer.model. PATH
lora_ckpt Chemin d'accès au ckpt LoRA des safetensors qui stocke le poids de l'adaptateur LoRA. PATH
lora_rank Entier représentant le rang de ckpt LoRA. Obligatoire pour convertir les pondérations Lora. S'il n'est pas fourni, le convertisseur suppose qu'il n'y a pas de pondérations LoRA. Remarque: Seul le backend de GPU est compatible avec la fonctionnalité LoRA. Entier
lora_output_tflite_file Nom de fichier tflite de sortie pour les pondérations LoRA. PATH

Conversion de modèles AI Edge

Si vous utilisez un LLM mappé sur un modèle TFLite via AI Edge, créez un groupe de tâches à l'aide de notre script de regroupement. Le processus de regroupement empaquette le modèle mappé avec des métadonnées supplémentaires Tokenizer) nécessaires à l'exécution de l'inférence de bout en bout.

Le processus de regroupement des 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)
Paramètres Description Valeurs acceptées
tflite_model Chemin d'accès au modèle TFLite exporté par AI Edge. PATH
tokenizer_model Chemin d'accès au modèle de tokenisation SentencePiece. PATH
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élisez des jetons d'arrêt spécifiques. Les jetons d'arrêt doivent être présents dans le modèle de tokenisation fourni. LISTE[CHAÎNE]
output_filename Nom du fichier du groupe de tâches en sortie. PATH

Personnalisation de LoRA

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

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

Préparer des modèles de 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-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 LLM Inference n'est compatible qu'avec les couches d'attention (LLM Inference), vous ne devez spécifier que les couches d'attention lors de la création d'une 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 réglés et affinés accessibles publiquement, qui s'adaptent à l'API LLM Inference disponible 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 l'entraînement sur l'ensemble de données préparé et l'enregistrement du modèle, vous obtenez un fichier adapter_model.safetensors contenant les pondérations du modèle LoRA affinées. Le fichier safetensors correspond au point de contrôle LoRA utilisé dans la conversion du modèle.

À l'étape suivante, vous devez convertir les pondérations du modèle en un Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. L'élément ConversionConfig doit spécifier les options du modèle de base ainsi que d'autres options de LoRA. Notez que, 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 affiche deux fichiers de tampon plat 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 LLM Inference Web, Android et iOS a été mise à jour pour assurer la compatibilité avec l'inférence de modèle LoRA. Le Web prend en charge des modèles de LoRA dynamiques, qui peuvent changer de modèle de LoRA pendant l'exécution. Android et iOS prennent en charge la fonctionnalité LoRA statique, qui utilise les mêmes pondérations LoRA pendant la durée de vie de la tâche.

Android prend en charge la fonctionnalité LoRA statique pendant l'initialisation. Pour charger un modèle LoRA, les utilisateurs doivent spécifier le chemin d'accès au modèle LoRA ainsi que le LLM de base.

// 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.