Présentation de Google AI Edge Portal: évaluez l'IA Edge à grande échelle. Inscrivez-vous pour demander l'accès pendant l'aperçu privé.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Convertir des modèles d'IA générative PyTorch pour l'inférence sur l'appareil

L'API LiteRT Torch Generative est une bibliothèque hautes performances conçue pour créer et convertir des modèles PyTorch basés sur des transformateurs au format LiteRT/LiteRT-LM. Les développeurs peuvent ainsi déployer facilement des modèles d'IA générative, en particulier des grands modèles de langage (LLM), pour la génération de texte et d'images sur l'appareil.

L'API Torch Generative est compatible avec la conversion de modèles pour les CPU, les GPU et les NPU. En associant l'API Torch Generative à LiteRT-LM, vous pouvez créer des applications réactives et respectueuses de la confidentialité qui exécutent des modèles génératifs entièrement sur l'appareil.

Convertir à partir de la bibliothèque Hugging Face Transformers

L'extension Hugging Face Export de LiteRT Torch permet de convertir facilement des modèles d'IA générative directement depuis la bibliothèque Hugging Face Transformers au format LiteRT-LM. Contrairement aux API LiteRT Torch Generative qui vous fournissent des blocs de construction PyTorch pour créer et optimiser des modèles personnalisés, cet outil gère les complexités liées au téléchargement des poids, à la traduction des architectures de modèles PyTorch et à l'application de techniques d'optimisation telles que les optimisations de graphiques et la quantification dans un seul workflow. Il génère un fichier .litertlm, qui est optimisé pour l'inférence sur l'appareil sur le CPU, le GPU et le NPU à l'aide de l'environnement d'exécution LiteRT-LM.

Prérequis

Avant d'utiliser l'extension d'exportation, assurez-vous d'avoir effectué la configuration suivante :

Installez le package Python LiteRT Torch. L'extension Hugging Face Export est intégrée directement au package litert-torch.
(Facultatif) Pour la compilation NPU, installez les extensions du SDK LiteRT NPU à l'aide de pip install ai-edge-litert[npu-sdk]. Pour en savoir plus, consultez LiteRT NPU AOT Compilation Colab.
L'environnement Hugging Face est configuré si vous prévoyez de charger directement depuis le hub Hugging Face. L'outil export_hf utilise les mécanismes d'authentification des transformers standards, comme HF_TOKEN ou la CLI. Voici un exemple :

Pour télécharger des modèles fermés (tels que Gemma ou Llama), vous devez vous authentifier auprès de Hugging Face à l'aide de la CLI ou d'une variable d'environnement :

# Set your Hugging Face token as an environment variable
export HF_TOKEN="your_hugging_face_token"

# Or use the Hugging Face CLI login
hf auth login

Utilisation de base

Vous pouvez utiliser export_hf à l'aide de la ligne de commande ou de l'API Python. L'outil téléchargera automatiquement le modèle depuis Hugging Face ou le chargera à partir du chemin d'accès local fourni, le tracera, appliquera les optimisations par défaut et le convertira en fichier .litertlm compatible avec l'inférence CPU et GPU.

Interface de ligne de commande (CLI)

Exécutez la commande litert-torch export_hf. Vous devez fournir l'ID du modèle Hugging Face et le répertoire de sortie choisi.

litert-torch export_hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-it-litertlm

Pour exporter un modèle local ou personnalisé, vous pouvez également transmettre le chemin d'accès au point de contrôle safetensor :

litert-torch export_hf \
  --model=/path/to/safetensor/dir \
  --output_dir=/my_custom_litertlm

API Python

Pour l'intégration dans des scripts ou notebooks Python, importez le module export depuis litert_torch.generative.export_hf.

from litert_torch.generative.export_hf import export

export.export(
    model='google/gemma-3-270m-it',
    output_dir='/tmp/gemma3-270m-it-litertlm',
)

Déploiement sur l'appareil avec LiteRT-LM

Une fois que vous avez exporté votre modèle dans un fichier .litertlm, vous pouvez le déployer directement sur l'appareil à l'aide de LiteRT-LM pour une exécution hautes performances sur le CPU et le GPU. Pour en savoir plus, consultez Utiliser l'API LiteRT-LM. Pour l'accélération NPU, consultez le guide de compilation AOT NPU.

Architectures compatibles

L'outil export_hf vérifie les architectures de modèle Transformers suivantes. Vous pouvez le vérifier en consultant le champ model_type dans config.json.

Gemma 3 (Gemma3ForCausalLM)
Gemma 3n (Gemma3nForCausalLM)
Gemma 4 (Gemma4ForCausalLM)
Llama (LlamaForCausalLM)
Mistral (MistralForCausalLM)
Qwen 2/2.5 (Qwen2ForCausalLM)
Qwen 3 (Qwen3ForCausalLM)
SmolLM 3 (SmolLM3ForCausalLM)

Paramètres avancés

Vous pouvez explorer les options avancées disponibles dans les indicateurs d'extension, mais voici quelques paramètres courants que vous pouvez essayer.

Modèles de langage et de vision

Pour les modèles compatibles, vous pouvez définir --task=image_text_to_text et --export_vision_encoder pour charger et exporter le modèle d'encodeur de vision.

Architectures compatibles :

Gemma 3 (Gemma3ForConditionalGeneration)
Gemma 4 (Gemma4ForConditionalGeneration)

Configuration de la quantification

Les modèles d'IA générative sont souvent trop volumineux pour s'exécuter efficacement sur des appareils périphériques sans optimisation. Par défaut, export_hf applique la recette de quantification dynamic_wi8_afp32 à l'aide de AI Edge Quantizer, qui quantifie les poids en INT8 par canal tout en conservant les activations en FP32.

Vous pouvez remplacer ce comportement par défaut à l'aide de l'indicateur --quantization_recipe (ou du paramètre quantization_recipe en Python). Vous pouvez fournir le nom d'une recette intégrée à partir de AI Edge Quantizer ou spécifier le chemin d'accès à une recette JSON personnalisée.

Exemple :

litert-torch export_hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-it-litertlm \
  --quantization_recipe=/path/to/my/quantization_recipe.json

Remplacement du modèle Jinja

Il est possible que le modèle Jinja fourni avec le modèle Transformers ne soit pas compatible avec LiteRT-LM (par exemple, les modèles Gemma4). Vous pouvez définir l'indicateur use_jinja_template sur False ou utiliser l'option jinja_chat_template_override pour remplacer le modèle.

Exemple :

 litert-torch export_hf \
   --model=google/gemma-4-E2B-it \
  --output_dir=/tmp/gemma4_2b_litertlm \
  --externalize_embedder \
  --jinja_chat_template_override=litert-community/gemma-4-E2B-it-litert-lm

Compilation AOT du NPU

En plus du CPU et du GPU, vous pouvez également cibler les accélérateurs NPU compatibles lorsque vous exportez vos modèles en fournissant les options spécifiques au NPU.

Google Tensor

Prérequis : suivez les instructions de la page SDK Google Tensor pour configurer l'environnement de développement.

Pour exporter des LLM ciblant les TPU Google Tensor, suivez l'exemple des indicateurs supplémentaires requis pour la compilation des TPU.

Exemple :

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --prefill_lengths=128, \
  --cache_length=1280 \
  --quantization_recipe="weight_only_wi8_afp32"
  --aot_backend=GOOGLE \
  --aot_soc_model=Tensor_G5 \
  --aot_compilation_config_dict='{"google_tensor_enable_large_model_support": True}'

Pour en savoir plus, consultez Compiler des modèles avec le SDK Google Tensor.

Qualcomm AI Runtime :

Conditions préalables : suivez les instructions de Intégration LiteRT Qualcomm pour la configuration du SDK et les appareils compatibles.

Exemple :

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --quantization_recipe='' \
  --aot_backend=qualcomm \
  --aot_soc_model=SM8750

MediaTek NeuroPilot :

Conditions préalables : suivez les instructions de Intégration LiteRT MediaTek pour la configuration du SDK et les appareils compatibles.

Exemple :

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --aot_backend=mediatek \
  --aot_soc_model=MT8189

Intel OpenVINO

Prérequis : suivez Intégration LiteRT Intel OpenVINO pour obtenir des instructions de configuration du SDK et connaître les appareils compatibles.

Exemple :

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --aot_backend=intel_openvino \
  --aot_soc_model=PTL

Réécrire et convertir à l'aide de l'API LiteRT Torch Generative

L'API LiteRT Torch Generative fournit également des blocs de construction pour créer et optimiser des modèles PyTorch personnalisés, y compris, mais sans s'y limiter, les couches de normalisation, les attentions et d'autres modules de base. Si votre modèle n'est pas couvert par l'extension Hugging Face Export de LiteRT Torch, vous pouvez créer vos propres modèles pour qu'ils soient compatibles avec LiteRT et LiteRT-LM.

Vous trouverez des exemples de modèles, y compris des LLM, des modèles de diffusion et des modèles ASR. N'hésitez pas à les consulter et à déployer votre propre modèle.

Pour en savoir plus, consultez le dépôt GitHub de l'API Generative Torch.