Tutoriel torchchat de PyTorch : configuration locale avec Python

Capacités de Torchchat

Torchchat propose quatre fonctionnalités principales :

1. Exécuter des LLM en Python avec PyTorch.
2. Faire tourner des modèles autonomes sur une application de bureau ou un serveur, sans Python.
3. Exécuter des modèles sur un appareil mobile.
4. Évaluer les performances d’un modèle.

Exécuter des LLM en Python avec PyTorch

Ce mode permet d’exécuter un LLM sur une machine où Python et PyTorch sont installés. Vous pouvez interagir avec le modèle directement dans le terminal ou en configurant un serveur avec une API REST. C’est ce que nous allons mettre en place dans cet article.

Exploiter des modèles autonomes

Torchchat utilise AOT Inductor (Ahead-of-Time Inductor) pour créer un exécutable autonome et distribuable pour les programmes d’inférence PyTorch, sous la forme d’une bibliothèque dynamique sans dépendance à Python ni à PyTorch.

Cette approche répond au besoin de déployer des modèles en production avec une stabilité du runtime à travers les mises à jour et changements de l’environnement de service, en garantissant que les modèles restent opérationnels sans recompilation.

AOT Inductor vise à optimiser le déploiement en permettant des formats binaires distribuables, rapides à charger et prêts à exécuter, tout en contournant les limites et surcoûts des formats texte comme TorchScript. Il s’appuie sur la génération de code et des optimisations pour CPU et GPU afin de réduire les surcharges et améliorer la vitesse d’exécution.

Exécution sur mobile

Pour l’exécution sur appareils mobiles, Torchchat s’appuie sur ExecuTorch. À l’instar d’AOT Inductor, ExecuTorch optimise le modèle pour une exécution sur mobile ou systèmes embarqués. Il produit un artefact PTE qui pourra ensuite être utilisé pour exécuter le modèle.

Évaluer un modèle

Le mode d’évaluation de Torchchat permet de mesurer les performances d’un LLM sur diverses tâches disponibles dans lm_eval. C’est une fonctionnalité clé pour les chercheurs souhaitant évaluer leurs nouveaux modèles sur des benchmarks courants.

Pourquoi utiliser Torchchat

Exécuter un LLM en local plutôt que de s’appuyer sur une API cloud tierce comme l’API d’OpenAI ouvre de nombreux cas d’usage et avantages, selon les besoins et contextes.

• Applications sensibles à la confidentialité : pour les secteurs manipulant des données sensibles (santé, finance, juridique), l’exécution locale garantit que les informations confidentielles ne sortent pas de l’infrastructure de l’organisation, en conformité avec les réglementations de protection des données.
• Applications en temps réel : pour des réponses à très faible latence (chatbots interactifs, génération de contenu en direct, systèmes de supervision), le local évite la latence réseau induite par les allers-retours vers une API cloud.
• Scénarios hors ligne ou à faible connectivité : en environnement à connectivité limitée ou inexistante, le déploiement local permet d’utiliser des applications LLM (recherche de terrain, éducation à distance, divertissement en vol).
• Maîtrise et optimisation des coûts : pour des usages intensifs ou continus, le local peut revenir moins cher, en évitant la tarification à la requête des API cloud et en tirant parti de ressources de calcul existantes.

Si vous souhaitez approfondir l’exécution d’un modèle d’IA sur un appareil plutôt que dans le cloud, nous vous recommandons ce billet sur l’Edge AI.

Configuration locale avec Python

Passons à la configuration pas à pas de Torchchat en local. Commençons par cloner le dépôt Torchchat.

Cloner ou télécharger le code

La première étape consiste à cloner le dépôt Torchchat. Avec Git installé, ouvrez un terminal et exécutez :

git clone [email protected]:pytorch/torchchat.gitPropulsé par

Vous pouvez aussi télécharger le dépôt via l’interface GitHub.

Installation

Nous partons du principe que Python 3.10 est déjà installé. Pour un guide d’installation de Python, consultez cet article.

Pour installer Torchchat, ouvrez un terminal dans le dossier Torchchat. Commencez par créer un environnement virtuel :

python -m venv .venvPropulsé par

En bref, un environnement virtuel est un répertoire autonome pour un projet, contenant ses dossiers d’installation pour les bibliothèques et paquets Python, et parfois même une version spécifique de Python. Chaque projet dispose ainsi exactement des versions nécessaires, sans interférence avec d’autres projets et leurs dépendances.

Une fois l’environnement virtuel créé, il faut l’activer avec la commande :

source .venv/bin/activatePropulsé par

Enfin, installez toutes les dépendances requises par Torchchat. Un script d’installation, install_requirements.sh, est fourni :

./install_requirements.shPropulsé par

Torchchat devrait maintenant être prêt à l’emploi. Vous pouvez vérifier l’installation en listant les commandes disponibles, comme suit :

python torchchat.py --helpPropulsé par

Utiliser Torchchat en local avec Python

Avec Torchchat installé, vous pouvez exécuter des LLM sur votre machine locale.

Lister tous les modèles pris en charge

Torchchat prend en charge un large éventail de LLM. Vous pouvez lister les modèles supportés avec la commande list :

python torchchat.py listPropulsé par

La liste complète des modèles est disponible sur leur dépôt GitHub.

La section « Notes » fournit des informations utiles sur chaque modèle, comme le meilleur cas d’usage et l’alias à utiliser dans les commandes Torchchat.

Télécharger un modèle

Torchchat utilise Hugging Face comme canal de distribution des modèles. Hugging Face est une plateforme collaborative qui fournit des outils pour créer, entraîner et déployer des modèles de NLP et de ML en open source. Pour en savoir plus, consultez cet article : Qu’est-ce que Hugging Face ?.

Avant de télécharger un modèle, il faut :

1. Installer l’interface en ligne de commande de Hugging Face
2. Créer un compte sur Hugging Face
3. Créer un jeton d’accès
4. Se connecter via l’interface en ligne de commande de Hugging Face

Pour installer l’interface en ligne de commande, utilisez pip :

pip install huggingface_hubPropulsé par

Ensuite, rendez-vous sur le site Hugging Face pour créer un compte. Une fois le compte créé, générez un jeton d’accès depuis les paramètres de votre profil :

Dans votre profil, ouvrez le menu « Access Tokens » pour créer un nouveau jeton :

Pour les permissions du jeton, les droits en lecture suffisent pour cet article. Notez qu’au moment de la création, il faut copier le jeton dans le presse-papiers, car vous ne pourrez plus l’afficher ensuite.

Avec ce jeton, connectez-vous via la commande suivante :

huggingface-cli loginPropulsé par

Une fois connecté, vous pouvez télécharger un modèle avec la commande download. Certains modèles étant volumineux, vérifiez que vous disposez d’assez d’espace disque. À titre d’exemple, nous utiliserons le modèle stories15M, un petit générateur d’histoires, rapide à télécharger et ne nécessitant pas d’autorisations particulières.

Pour le télécharger :

python torchchat.py download stories15MPropulsé par

Exécuter un modèle

Après le téléchargement, vous pouvez utiliser les commandes chat ou generate. Pour générer du texte, fournissez un prompt avec l’argument --prompt. Exemple :

python torchchat.py generate stories15M --prompt “Once upon a time”Propulsé par

Cette commande demande à Torchchat de générer du texte avec le modèle stories15M à partir du prompt ”Once upon a time”.

Pour exécuter le modèle en mode conversation, utilisez la commande chat sans prompt.

python torchchat.py chat stories15M Propulsé par

La commande chat lance un échange interactif dans le terminal pour converser avec le LLM. Notez que certains modèles se prêtent mieux au mode generate, tandis que d’autres sont plus adaptés au mode chat. Cette information figure dans la section « Notes » de la documentation des modèles.

Demander l’accès à un modèle

Certains modèles comme llama3 requièrent une autorisation spécifique pour être téléchargés. Si vous tentez de télécharger un tel modèle, vous obtiendrez un message d’erreur :

Access to model meta-llama/Meta-Llama-3-8B-Instruct is restricted and you are not in the authorized list. Visit https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct to ask for access.Propulsé par

Vous pouvez demander l’accès en suivant l’URL fournie dans le message d’erreur. Il suffit de remplir un court formulaire avec vos informations et d’accepter les conditions d’utilisation. Vous recevrez un e‑mail dès que l’accès sera accordé.

Utilisation avancée

Torchchat offre plusieurs options supplémentaires pour l’exécution locale des LLM, afin d’adapter le fonctionnement à vos besoins et à votre matériel. Passons-en quelques-unes en revue.

Maîtriser la précision

Les LLM reposent fortement sur les multiplications de matrices, impliquant de nombreux nombres à virgule flottante. Plusieurs types de données existent pour représenter ces nombres avec des précisions variables.

Une précision plus élevée peut mieux restituer les nuances apprises pendant l’entraînement, notamment pour des tâches complexes ou subtiles. En contrepartie, elle peut ralentir fortement l’inférence. Le bon compromis dépendra de l’équilibre recherché entre vitesse et précision.

Pour définir le type de données à l’exécution, utilisez le paramètre --dtype, par exemple :

python torchchat.py chat --dtype fast stories15MPropulsé par

Compilation Just-In-Time

L’option --compile active la compilation Just-In-Time (JIT) du modèle. La JIT optimise les performances d’inférence en compilant dynamiquement, à l’exécution, certaines parties du modèle en code machine plutôt que de les interpréter à chaque fois. Cette approche peut améliorer sensiblement l’efficacité et la vitesse sur différents matériels.

La JIT augmente le temps de démarrage en raison de l’étape de compilation supplémentaire, mais accélère ensuite l’inférence. Voici comment l’utiliser avec chat :

python torchchat.py chat --compile stories15MPropulsé par

Notez que cette option peut ne pas être prise en charge par tous les matériels. Dans ce cas, Torchchat ignore la compilation et exécute le LLM sans celle-ci.

Quantification

La quantification est une technique qui réduit la taille du modèle et accélère l’inférence sans dégrader significativement les performances. Elle est particulièrement utile pour déployer des LLM en périphérie ou dans des environnements contraints en calcul, mémoire et bande passante.

En résumé, la quantification convertit les poids et activations d’un réseau de la représentation en virgule flottante (généralement float32) vers des représentations à plus faible précision, comme des entiers 16 bits, 8 bits, voire binaires dans certains cas.

Cela diffère du réglage de précision via --dtype. La quantification agit directement sur les poids du modèle pour en créer une version plus compacte, alors que le type de données spécifie la précision utilisée lors des calculs d’inférence.

Avec Torchchat, la quantification nécessite un fichier de configuration JSON et s’utilise ainsi :

python torchchat.py chat --quantize config.json stories15MPropulsé par

Pour plus de détails sur le format de config.json et le fonctionnement de la quantification dans Torchchat, consultez la page de documentation dédiée.

Spécifier le périphérique

Vous pouvez préciser le périphérique d’exécution du LLM via l’option --device. Par exemple, pour utiliser CUDA :

python torchchat.py chat --device cuda stories15MPropulsé par

Conclusion

Torchchat constitue une avancée majeure pour démocratiser l’inférence des LLM. Il simplifie l’exécution efficace de ces modèles sur une large gamme d’appareils.

Torchchat offre bien plus de possibilités que ce que nous avons présenté ici. Nous avons fourni l’essentiel pour démarrer l’exécution locale de LLM sur votre ordinateur avec Python et PyTorch. Nous vous encourageons vivement à explorer Torchchat plus en profondeur.