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.
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:
Web:
Android :
iOS
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:
- Génération de texte en texte : générez du texte en fonction d'une requête textuelle d'entrée.
- 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.
- 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:
|
L'API LLM Inference renvoie les résultats suivants:
|
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.
Les modèles Gemma 2B se déclinent en quatre variantes:
- gemma-2b-it-cpu-int4 : modèle Gemma 2b 4 bits compatible avec les processeurs.
- gemma-2b-it-cpu-int8 : modèle Gemma 2 B 8 bits compatible avec les processeurs.
- gemma-2b-it-gpu-int4 : modèle Gemma 2B 4 bits compatible avec les GPU.
- gemma-2b-it-gpu-int8 : modèle Gemma 2B 8 bits compatible avec les GPU.
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.
Le modèle Gemma 7B est disponible en une variante:
- gemma-1.1-7b-it-gpu-int8 : modèle Gemma 7B 8 bits compatible avec les GPU.
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.
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.
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.
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.