Guide d'inférence LLM

L'API LLM Inference vous permet d'exécuter de grands modèles de langage (LLM) sur l'appareil, que vous pouvez utiliser pour effectuer un large éventail de tâches, comme générer du texte, récupérer des informations en langage naturel résumer des 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 et produits.

<ph type="x-smartling-placeholder"></ph> Essayez !arrow_forward

La tâche est compatible avec Gemma 2B et 7B, qui font partie de une famille de modèles ouverts, légers et de pointe, construits à partir du même les recherches et les technologies utilisées pour créer Gemini des modèles de ML. Il est également compatible avec les modèles externes suivants: Phi-2 Falcon-RW-1B et StableLM-3B.

Outre les modèles compatibles en mode natif, les utilisateurs peuvent mapper d'autres grâce à la technologie AI Edge de Google (y compris mappage des modèles PyTorch). Cela permet aux utilisateurs d'exporter un modèle mappé dans des modèles de signatures multiples Les modèles TensorFlow Lite, fournis avec des paramètres de tokenisation créer un groupe de tâches.

Premiers pas

Commencez à effectuer cette tâche en suivant l'un de ces guides d'implémentation pour votre la plate-forme cible. Ces guides spécifiques à chaque plate-forme vous guident à travers un la mise en œuvre de cette tâche, avec des exemples de code qui utilisent un modèle disponible et les options de configuration recommandées:

• Web:

  • Guide
  • Code exemple

• Android :

  • Guide
  • Code exemple

• iOS

  • Guide
  • Code exemple

Détails de la tâche

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

Fonctionnalités

L'API d'inférence LLM contient les fonctionnalités clés suivantes:

1. Génération de texte en texte : générez du texte à partir d'une requête textuelle d'entrée.
2. Sélection de LLM : appliquez plusieurs modèles pour adapter l'application à votre pour des cas d'utilisation spécifiques. Vous pouvez également réentraîner et appliquer des pondérations personnalisées dans un modèle de ML.
3. Compatibilité avec LoRA : étendez et personnalisez la capacité LLM avec le modèle LoRA soit en effectuant l'entraînement sur l'ensemble de données complet, soit en prenant des tests LoRA préparés et prédéfinis de la communauté Open Source (modèles natifs uniquement).

Options de configuration

Cette tâche comporte les options de configuration suivantes:

Modèles

L'API d'inférence LLM est compatible avec les grands caractères texte-vers-texte divisibles optimisés pour s'exécuter dans les navigateurs et les appareils mobiles. Ces des 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 d'inférence LLM, téléchargez l'un des modèles compatibles et stocker le fichier dans le répertoire de votre projet.

Gemma 2B

Gemma 2B fait partie d'une famille de légers et de pointe, conçus à partir des mêmes recherches et la technologie utilisée pour créer les modèles Gemini. La contient 2 milliards de paramètres et des pondérations ouvertes. Ce modèle est adapté une grande variété de tâches de génération de texte, notamment les réponses à des questions, la synthèse, et le raisonnement.

<ph type="x-smartling-placeholder"></ph> Télécharger Gemma 2B

Les modèles Gemma 2B sont disponibles 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 2B 8 bits avec compatibilité CPU.
• 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 Gemma, consultez la page Régler Gemma. Après avoir téléchargé Gemma à partir de modèles Kaggle, le modèle est déjà dans le format approprié pour une utilisation avec MediaPipe.

Si vous téléchargez Gemma 2B sur Hugging "Visage", vous devez effectuer une conversion le modèle dans un format compatible avec MediaPipe. 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 7B et les pondérations ouvertes. Le modèle est plus puissant pour des textes variés. tâches de génération, notamment la réponse aux questions, la synthèse et le raisonnement. Gemma 7B n'est compatible qu'avec le Web.

<ph type="x-smartling-placeholder"></ph> Télécharger Gemma 7B

Le modèle Gemma 7B se décline 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 sur Hugging Face : vous devez convertir le modèle dans un format compatible avec MediaPipe. La 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 exclusivement basé sur des paramètres d'un milliard de paramètres, entraîné sur 350 octets. jetons de RefinedWeb ;

<ph type="x-smartling-placeholder"></ph> Télécharger Falcon 1B

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

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

StableLM 3B

StableLM-3B est un modèle de langage pré-entraîné sur 3 milliards de paramètres, 1 000 milliards de jetons pour différents ensembles de données anglais et de code pendant quatre époques.

<ph type="x-smartling-placeholder"></ph> Télécharger StableLM 3B

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

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

Une fois les fichiers du modèle StableLM téléchargés, 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 de sortie.

Phi-2

Phi-2 est un modèle Transformer de 2,7 milliards de paramètres. Il a été entraîné à l'aide de diverses les textes synthétiques TLN et les sites Web filtrés ; Le modèle est le mieux adapté aux requêtes en utilisant le format questions-réponses, le chat et le format de code.

<ph type="x-smartling-placeholder"></ph> Télécharger Phi-2

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

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

Modèles exportés vers AI Edge

AI Edge est une offre Google qui vous permet de convertir des modèles mappés par l'utilisateur. dans des modèles TensorFlow Lite à signatures multiples. Pour plus de détails sur le mappage et pour exporter des modèles, visitez le site Page GitHub

Une fois le modèle exporté 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 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.

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)

Personnalisation LoRA

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.

// 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 une inférence LLM avec LoRA, utilisez les mêmes méthodes generateResponse() ou generateResponseAsync() que le modèle de base.