Suivez nous sur

Intelligence artificielle

Déploiement de grands modèles de langage sur Kubernetes : un guide complet

mm
Le kit de préparation mis à jour on
Grands modèles de langage Kubernetes et GPU : un guide complet

Les grands modèles linguistiques (LLM) sont capables de comprendre et de générer du texte de type humain, ce qui les rend inestimables pour un large éventail d'applications, telles que les chatbots, la génération de contenu et la traduction linguistique.

Cependant, le déploiement de LLM peut s'avérer une tâche difficile en raison de leur immense taille et de leurs exigences informatiques. Kubernetes, un système d'orchestration de conteneurs open source, fournit une solution puissante pour déployer et gérer des LLM à grande échelle. Dans ce blog technique, nous explorerons le processus de déploiement des LLM sur Kubernetes, couvrant divers aspects tels que la conteneurisation, l'allocation des ressources et l'évolutivité.

Comprendre les grands modèles de langage

Avant de plonger dans le processus de déploiement, comprenons brièvement ce que sont les grands modèles linguistiques et pourquoi ils attirent autant l'attention.

Les grands modèles linguistiques (LLM) sont un type de modèle de réseau neuronal formé sur de grandes quantités de données textuelles. Ces modèles apprennent à comprendre et à générer un langage de type humain en analysant les modèles et les relations au sein des données d'entraînement. Voici quelques exemples populaires de LLM : GPT (Transformateur Génératif Pré-entraîné), BERT (Représentations d'encodeurs bidirectionnels à partir de transformateurs), et XLNet.

Les LLM ont atteint des performances remarquables dans diverses tâches de PNL, telles que la génération de texte, la traduction et la réponse aux questions. Cependant, leur taille massive et leurs exigences informatiques posent des défis importants en matière de déploiement et d’inférence.

Pourquoi Kubernetes pour le déploiement LLM ?

Kubernetes est une plateforme d'orchestration de conteneurs open source qui automatise le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Il offre plusieurs avantages pour le déploiement de LLM, notamment :

  • Évolutivité: Kubernetes vous permet de faire évoluer votre déploiement LLM horizontalement en ajoutant ou en supprimant des ressources de calcul selon vos besoins, garantissant ainsi une utilisation et des performances optimales des ressources.
  • Gestion des ressources: Kubernetes permet une allocation et une isolation efficaces des ressources, garantissant que votre déploiement LLM a accès aux ressources de calcul, de mémoire et de GPU requises.
  • Haute Disponibilité: Kubernetes fournit des mécanismes intégrés d'auto-réparation, de déploiements et de restaurations automatiques, garantissant que votre déploiement LLM reste hautement disponible et résilient aux pannes.
  • Portabilité: Les déploiements LLM conteneurisés peuvent être facilement déplacés entre différents environnements, tels que des centres de données sur site ou des plateformes cloud, sans avoir besoin d'une reconfiguration approfondie.
  • Soutien aux écosystèmes et aux communautés: Kubernetes dispose d'une communauté vaste et active, fournissant une multitude d'outils, de bibliothèques et de ressources pour déployer et gérer des applications complexes telles que les LLM.

Préparation du déploiement LLM sur Kubernetes :

Avant de déployer un LLM sur Kubernetes, plusieurs prérequis sont à considérer :

  1. Cluster Kubernetes : Vous aurez besoin d'un cluster Kubernetes configuré et exécuté, soit sur site, soit sur une plate-forme cloud comme Service Amazon Elastic Kubernetes (EKS), Google Kubernetes Engine (GKE)ou Service Azure Kubernetes (AKS).
  2. Prise en charge du GPU: Les LLM nécessitent beaucoup de calculs et nécessitent souvent une accélération GPU pour une inférence efficace. Assurez-vous que votre cluster Kubernetes a accès aux ressources GPU, via des GPU physiques ou des instances GPU basées sur le cloud.
  3. Registre des conteneurs: Vous aurez besoin d'un registre de conteneurs pour stocker vos images LLM Docker. Les options populaires incluent Docker Hub, Registre des conteneurs élastiques Amazon (ECR), Registre de conteneurs Google (GCR)ou Registre de conteneurs Azure (ACR).
  4. Fichiers de modèle LLM: Obtenez les fichiers de modèle LLM pré-entraînés (poids, configuration et tokenizer) à partir de la source respective ou entraînez votre propre modèle.
  5. La conteneurisation : Conteneurisez votre application LLM à l'aide de Docker ou d'un environnement d'exécution de conteneur similaire. Cela implique la création d'un Dockerfile qui regroupe votre code LLM, vos dépendances et vos fichiers de modèle dans une image Docker.

Déployer un LLM sur Kubernetes

Une fois les prérequis en place, vous pouvez procéder au déploiement de votre LLM sur Kubernetes. Le processus de déploiement implique généralement les étapes suivantes :

Construire l'image Docker

Créez l'image Docker pour votre application LLM à l'aide du Dockerfile fourni et transférez-la vers votre registre de conteneurs.

Création de ressources Kubernetes

Définissez les ressources Kubernetes requises pour votre déploiement LLM, telles que les déploiements, les services, les ConfigMaps et les secrets. Ces ressources sont généralement définies à l'aide de manifestes YAML ou JSON.

Configuration des besoins en ressources

Spécifiez les ressources requises pour votre déploiement LLM, notamment les ressources CPU, mémoire et GPU. Cela garantit que votre déploiement a accès aux ressources de calcul nécessaires pour une inférence efficace.

Déploiement sur Kubernetes

Utilisez l'option kubectl outil de ligne de commande ou un outil de gestion Kubernetes (par exemple, Tableau de bord Kubernetes, Rancherou Lens) pour appliquer les manifestes Kubernetes et déployer votre application LLM.

Surveillance et mise à l'échelle

Surveillez les performances et l'utilisation des ressources de votre déploiement LLM à l'aide d'outils de surveillance Kubernetes tels que Prométhée et grafana. Ajustez l’allocation des ressources ou faites évoluer votre déploiement selon vos besoins pour répondre à la demande.

Exemple de déploiement

Prenons un exemple de déploiement du modèle de langage GPT-3 sur Kubernetes à l'aide d'une image Docker prédéfinie de Hugging Face. Nous supposerons que vous disposez d'un cluster Kubernetes installé et configuré avec la prise en charge du GPU.

Extrayez l'image Docker :

docker pull huggingface/text-generation-inference:1.1.0

Créez un déploiement Kubernetes :

Créez un fichier nommé gpt3-deployment.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
name: gpt3-deployment
spec:
replicas: 1
selector:
matchLabels:
app: gpt3
template:
metadata:
labels:
app: gpt3
spec:
containers:
- name: gpt3
image: huggingface/text-generation-inference:1.1.0
resources:
limits:
nvidia.com/gpu: 1
env:
- name: MODEL_ID
value: gpt2
- name: NUM_SHARD
value: "1"
- name: PORT
value: "8080"
- name: QUANTIZE
value: bitsandbytes-nf4

Ce déploiement spécifie que nous souhaitons exécuter une réplique du conteneur gpt3 à l'aide de l'image Docker huggingface/text-generation-inference:1.1.0. Le déploiement définit également les variables d'environnement requises pour que le conteneur charge le modèle GPT-3 et configure le serveur d'inférence.

Créez un service Kubernetes :

Créez un fichier nommé gpt3-service.yaml avec le contenu suivant :

apiVersion: v1
kind: Service
metadata:
name: gpt3-service
spec:
selector:
app: gpt3
ports:
- port: 80
targetPort: 8080
type: LoadBalancer

Ce service expose le déploiement gpt3 sur le port 80 et crée un service de type LoadBalancer pour rendre le serveur d'inférence accessible depuis l'extérieur du cluster Kubernetes.

Déployer sur Kubernetes :

Appliquez les manifestes Kubernetes à l'aide de la commande kubectl :

kubectl apply -f gpt3-deployment.yaml
kubectl apply -f gpt3-service.yaml

Surveiller le déploiement :

Surveillez la progression du déploiement à l'aide des commandes suivantes :

kubectl get pods
kubectl logs <pod_name>

Une fois le pod exécuté et les logs indiquent que le modèle est chargé et prêt, vous pouvez obtenir l'adresse IP externe du service LoadBalancer :

kubectl get service gpt3-service

Testez le déploiement :

Vous pouvez désormais envoyer des requêtes au serveur d'inférence à l'aide de l'adresse IP externe et du port obtenus à l'étape précédente. Par exemple, en utilisant curl :

curl -X POST \
http://<external_ip>:80/generate \
-H 'Content-Type: application/json' \
-d '{"inputs": "The quick brown fox", "parameters": {"max_new_tokens": 50}}'

Cette commande envoie une requête de génération de texte au serveur d'inférence GPT-3, lui demandant de continuer l'invite « Le renard brun rapide » pour un maximum de 50 jetons supplémentaires.

Sujets avancés que vous devez connaître

Logo Kubernetes GPU LLM

Bien que l'exemple ci-dessus illustre un déploiement de base d'un LLM sur Kubernetes, il existe plusieurs sujets et considérations avancés à explorer :

1. Mise à l'échelle automatique

Kubernetes prend en charge la mise à l'échelle automatique horizontale et verticale, ce qui peut être bénéfique pour les déploiements LLM en raison de leurs exigences de calcul variables. La mise à l'échelle automatique horizontale vous permet de mettre automatiquement à l'échelle le nombre de réplicas (pods) en fonction de mesures telles que l'utilisation du processeur ou de la mémoire. La mise à l'échelle verticale, quant à elle, vous permet d'ajuster dynamiquement les demandes de ressources et les limites de vos conteneurs.

Pour activer la mise à l'échelle automatique, vous pouvez utiliser le Autoscaler horizontal de pods Kubernetes (HPA) et Autoscaler de pods verticaux (VPA). Ces composants surveillent votre déploiement et mettent automatiquement à l'échelle les ressources en fonction de règles et de seuils prédéfinis.

2. Planification et partage de GPU

Dans les scénarios où plusieurs déploiements LLM ou d’autres charges de travail gourmandes en GPU s’exécutent sur le même cluster Kubernetes, une planification et un partage efficaces du GPU deviennent cruciaux. Kubernetes fournit plusieurs mécanismes pour garantir une utilisation équitable et efficace du GPU, tels que des plugins de périphériques GPU, des sélecteurs de nœuds et des limites de ressources.

Vous pouvez également tirer parti de techniques avancées de planification GPU telles que GPU multi-instance NVIDIA (MIG) ou AMD Memory Pool Remapping (MPR) pour virtualiser les GPU et les partager entre plusieurs charges de travail.

3. Parallélisme et partage de modèles

Certains LLM, en particulier ceux comportant des milliards ou des milliards de paramètres, peuvent ne pas tenir entièrement dans la mémoire d'un seul GPU ou même d'un seul nœud. Dans de tels cas, vous pouvez utiliser des techniques de parallélisme et de partitionnement de modèle pour distribuer le modèle sur plusieurs GPU ou nœuds.

Le parallélisme des modèles implique de diviser l'architecture du modèle en différents composants (par exemple, encodeur, décodeur) et de les distribuer sur plusieurs appareils. Le partage, quant à lui, implique de partitionner les paramètres du modèle et de les distribuer sur plusieurs appareils ou nœuds.

Kubernetes fournit des mécanismes tels que StatefulSets et Custom Resource Definitions (CRD) pour gérer et orchestrer les déploiements LLM distribués avec le parallélisme et le partitionnement des modèles.

4. Mise au point et apprentissage continu

Dans de nombreux cas, les LLM pré-entraînés peuvent devoir être affinés ou formés en permanence sur des données spécifiques à un domaine afin d'améliorer leurs performances pour des tâches ou des domaines spécifiques. Kubernetes peut faciliter ce processus en fournissant une plate-forme évolutive et résiliente pour exécuter des charges de travail de réglage fin ou d'apprentissage continu.

Vous pouvez tirer parti des frameworks de traitement par lots Kubernetes tels que Apache Spark or Kubeflow pour exécuter des tâches distribuées de réglage fin ou de formation sur vos modèles LLM. De plus, vous pouvez intégrer vos modèles affinés ou formés en continu à vos déploiements d'inférence à l'aide de mécanismes Kubernetes tels que les mises à jour progressives ou les déploiements bleu/vert.

5. Surveillance et observabilité

La surveillance et l'observabilité sont des aspects cruciaux de tout déploiement de production, y compris les déploiements LLM sur Kubernetes. Kubernetes fournit des solutions de surveillance intégrées telles que Prométhée et des intégrations avec des plateformes d'observabilité populaires telles que grafana, ElasticSearch, Jaeger.

Vous pouvez surveiller diverses mesures liées à vos déploiements LLM, telles que l'utilisation du processeur et de la mémoire, l'utilisation du GPU, la latence d'inférence et le débit. De plus, vous pouvez collecter et analyser les journaux et les traces au niveau des applications pour obtenir des informations sur le comportement et les performances de vos modèles LLM.

6. Sécurité et conformité

En fonction de votre cas d'utilisation et de la sensibilité des données impliquées, vous devrez peut-être prendre en compte les aspects de sécurité et de conformité lors du déploiement de LLM sur Kubernetes. Kubernetes fournit plusieurs fonctionnalités et intégrations pour améliorer la sécurité, telles que les politiques réseau, le contrôle d'accès basé sur les rôles (RBAC), la gestion des secrets et l'intégration avec des solutions de sécurité externes telles que Caveau HashiCorp or AWS Secrets Manager.

De plus, si vous déployez des LLM dans des secteurs réglementés ou si vous manipulez des données sensibles, vous devrez peut-être garantir la conformité aux normes et réglementations pertinentes, telles que le RGPD, la HIPAA ou la PCI-DSS.

7. Déploiements multi-cloud et hybrides

Bien que cet article de blog se concentre sur le déploiement de LLM sur un seul cluster Kubernetes, vous devrez peut-être envisager des déploiements multi-cloud ou hybrides dans certains scénarios. Kubernetes fournit une plate-forme cohérente pour déployer et gérer des applications sur différents fournisseurs de cloud et centres de données sur site.

Vous pouvez tirer parti de la fédération Kubernetes ou d'outils de gestion multicluster tels que KubeFed or Hub GKE pour gérer et orchestrer les déploiements LLM sur plusieurs clusters Kubernetes couvrant différents fournisseurs de cloud ou environnements hybrides.

Ces sujets avancés mettent en évidence la flexibilité et l'évolutivité de Kubernetes pour le déploiement et la gestion des LLM.

Conclusion

Le déploiement de grands modèles linguistiques (LLM) sur Kubernetes offre de nombreux avantages, notamment l'évolutivité, la gestion des ressources, la haute disponibilité et la portabilité. En suivant les étapes décrites dans ce blog technique, vous pouvez conteneuriser votre application LLM, définir les ressources Kubernetes nécessaires et la déployer sur un cluster Kubernetes.

Cependant, le déploiement de LLM sur Kubernetes n'est que la première étape. À mesure que votre application se développe et que vos besoins évoluent, vous devrez peut-être explorer des sujets avancés tels que la mise à l'échelle automatique, la planification GPU, le parallélisme des modèles, le réglage fin, la surveillance, la sécurité et les déploiements multi-cloud.

Kubernetes fournit une plate-forme robuste et extensible pour le déploiement et la gestion des LLM, vous permettant de créer des applications fiables, évolutives et sécurisées.

J'ai passé les cinq dernières années à m'immerger dans le monde fascinant du Machine Learning et du Deep Learning. Ma passion et mon expertise m'ont amené à contribuer à plus de 50 projets de génie logiciel divers, avec un accent particulier sur l'IA/ML. Ma curiosité continue m'a également attiré vers le traitement automatique du langage naturel, un domaine que j'ai hâte d'explorer davantage.