Guide d'inférence LLM

⚠️ Important : Mise à jour de l'API d'inférence LLM

Les implémentations Android et iOS de l'API d'inférence LLM sont désormais obsolètes. Le Web N'EST PAS obsolète

---

Migrez vos projets mobiles vers LiteRT-LM pour assurer la continuité de la compatibilité et des performances.

L'API d'inférence LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil. Vous pouvez l'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. La tâche fournit une compatibilité intégrée pour plusieurs grands modèles de langage de texte à texte. Vous pouvez ainsi appliquer les derniers modèles d'IA générative sur l'appareil à vos applications et produits.

Essayerarrow_forward

La tâche fournit une compatibilité intégrée pour différents LLM. Les modèles hébergés sur la page de la communauté LiteRT sont disponibles dans un format compatible avec MediaPipe et ne nécessitent aucune étape de conversion ou de compilation supplémentaire.

Vous pouvez utiliser LiteRT Torch pour exporter des modèles PyTorch vers des modèles LiteRT à signatures multiples (tflite), qui sont regroupés avec des paramètres de tokenisation pour créer des groupes de tâches. Les modèles convertis avec LiteRT Torch sont compatibles avec l'API d'inférence LLM et peuvent s'exécuter sur le backend du processeur, ce qui les rend adaptés aux applications Android et iOS.

Premiers pas

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 expliquent comment implémenter de base cette tâche, 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 d'inférence LLM contient les principales fonctionnalités suivantes :

1. Génération de texte à partir de texte : générez 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 lui appliquer des pondérations personnalisées.
3. Compatibilité avec LoRA : étendez et personnalisez la fonctionnalité LLM avec le modèle LoRA en l'entraînant sur l'ensemble de vos données ou en utilisant des modèles LoRA précompilés préparés par la communauté Open Source (non compatible avec les modèles convertis avec l'API générative LiteRT Torch).

Options de configuration

Cette tâche comporte 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 une compatibilité intégrée pour 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 à partir du dépôt LiteRT Community HuggingFace ou convertir un modèle dans un format compatible avec MediaPipe à l'aide du convertisseur génératif AI Edge Torch.

Si vous ne disposez pas encore d'un LLM à utiliser avec l'API d'inférence LLM, commencez par l'un des modèles suivants.

Gemma-3n

Gemma-3n E2B et E4B sont les derniers modèles de la famille Gemma 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 Gemini. Les modèles Gemma 3n sont conçus pour une exécution efficace sur les appareils à faibles ressources. Ils sont capables d'accepter des entrées multimodales, de gérer des entrées de texte, d'image et audio, et de générer des sorties de texte.

Les modèles Gemma 3n utilisent une technologie d'activation sélective des paramètres pour réduire les besoins en ressources. Cette technique permet aux modèles de fonctionner avec une taille effective de 2 milliards et 4 milliards de paramètres, ce qui est inférieur au nombre total de paramètres qu'ils contiennent.

Télécharger Gemma-3n E2B

Télécharger Gemma-3n E4B

Les modèles Gemma-3n E2B et E4B de HuggingFace sont disponibles au format .litertlm et sont prêts à être utilisés avec l'API d'inférence LLM pour Android et le Web.

Gemma-3 1B

Gemma-3 1B est le modèle le plus léger de la famille Gemma 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 1 milliard de paramètres et des pondérations ouvertes.

Télécharger Gemma-3 1B

Le modèle Gemma-3 1B de HuggingFace est disponible au format .task/.litertlm et est prêt à être utilisé avec l'API d'inférence LLM pour les applications Android et Web.

Lorsque vous exécutez Gemma-3 1B avec l'API d'inférence LLM, configurez les options suivantes en conséquence :

• preferredBackend: utilisez cette option pour choisir entre un backend CPU ou GPU. Cette option n'est disponible que pour Android.
• supportedLoraRanks: l'API d'inférence LLM ne peut pas être configurée pour prendre en charge l'adaptation à faible rang (LoRA) avec le modèle Gemma-3 1B. N'utilisez pas les options supportedLoraRanks ni loraRanks.
• maxTokens: la valeur de maxTokens doit correspondre à la taille du contexte intégrée au modèle. On parle également de cache clé-valeur (KV) ou de longueur de contexte.
• numResponses : doit toujours être 1. Cette option n'est disponible que pour le Web.

Lorsque vous exécutez Gemma-3 1B sur des applications Web, l'initialisation peut entraîner un blocage prolongé dans le thread actuel. Si possible, exécutez toujours le modèle à partir d'un thread de travail.

Gemma-2 2B

Gemma-2 2B est une variante 2B de Gemma-2 et fonctionne sur toutes les plates-formes.

Télécharger Gemma-2 2B

Le modèle contient 2 milliards de paramètres et des pondérations ouvertes. Gemma-2 2B est connu pour ses compétences de raisonnement de pointe pour les modèles de sa catégorie.

Conversion de modèle PyTorch

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

La conversion d'un modèle PyTorch avec l'API générative LiteRT Torch API implique les étapes suivantes :

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

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 créer un groupe de tâches, utilisez le script de regroupement pour créer un groupe de tâches. Le processus de regroupement regroupe le modèle mappé avec des métadonnées supplémentaires (par exemple, des paramètres de tokenisation) nécessaires pour exécuter une inférence de bout en bout.

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

Installez et importez les dépendances avec les éléments suivants :

$ 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 compatibilité LoRA de l'API d'inférence LLM fonctionne pour toutes les variantes Gemma et les modèles 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, avec l'intention de prendre en charge davantage de modèles et différents types de couches dans les prochaines 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 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 avec LoRA que 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 et adaptés à 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 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é. Le fichier safetensors est le point de contrôle LoRA utilisé dans la conversion du modèle.

L'étape suivante consiste à convertir les pondérations du modèle en Flatbuffer TensorFlow Lite à l'aide du package MediaPipe Python. ConversionConfig doit spécifier les options du modèle de base, ainsi que des options LoRA supplémentaires. Notez que comme l'API n'est compatible avec l'inférence LoRA qu'avec le 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

Les API d'inférence LLM Web, Android et iOS sont mises à 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.