Modèles et plateformes d’IA
Déploiement de grands modèles de langage sur Kubernetes : un guide complet
Ajouter Unite.AI à vos sources préférées sur Google
Les grands modèles de langage (LLM) sont capables de comprendre et de générer du texte similaire à celui des humains, ce qui les rend précieux pour une large gamme d’applications, telles que les chatbots, la génération de contenu et la traduction de langues.
Cependant, le déploiement de LLM peut être une tâche difficile en raison de leur taille immense et de leurs exigences computationnelles. Kubernetes, un système de gestion de conteneurs open source, offre une solution puissante pour déployer et gérer les LLM à grande échelle. Dans ce blog technique, nous allons explorer le processus de déploiement de LLM sur Kubernetes, en couvrant divers aspects tels que la conteneurisation, l’allocation de ressources et la scalabilité.
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 de langage et pourquoi ils attirent tant l’attention.
Les grands modèles de langage (LLM) sont un type de modèle de réseau neuronal formé sur d’énormes quantités de données textuelles. Ces modèles apprennent à comprendre et à générer du langage similaire à celui des humains en analysant les modèles et les relations au sein des données de formation. Des exemples populaires de LLM incluent GPT (Generative Pre-trained Transformer), BERT (Bidirectional Encoder Representations from Transformers) et XLNet.
Les LLM ont réalisé des performances remarquables dans diverses tâches de traitement du langage naturel, telles que la génération de texte, la traduction de langues et la réponse à des questions. Cependant, leur taille massive et leurs exigences computationnelles posent des défis importants pour le déploiement et l’inférence.
Pourquoi Kubernetes pour le déploiement de LLM ?
Kubernetes est une plate-forme de gestion 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 :
- Scalabilité : Kubernetes vous permet de mettre à l’échelle votre déploiement de LLM horizontalement en ajoutant ou en supprimant des ressources de calcul selon les besoins, garantissant ainsi une utilisation optimale des ressources et des performances.
- Gestion des ressources : Kubernetes permet une allocation efficace des ressources et une isolation, garantissant que votre déploiement de LLM a accès aux ressources de calcul, de mémoire et de GPU nécessaires.
- Haute disponibilité : Kubernetes offre des mécanismes intégrés pour l’auto-réparation, les mises à jour automatiques et les rétrogradations, garantissant que votre déploiement de LLM reste hautement disponible et résilient aux défaillances.
- Portabilité : Les déploiements de 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 nécessiter de reconfiguration extensive.
- Écosystème et support communautaire : Kubernetes a une grande et active communauté, offrant une richesse d’outils, de bibliothèques et de ressources pour déployer et gérer des applications complexes comme les LLM.
Préparation au déploiement de LLM sur Kubernetes :
Avant de déployer un LLM sur Kubernetes, il y a plusieurs prérequis à considérer :
- Cluster Kubernetes : Vous aurez besoin d’un cluster Kubernetes configuré et en cours d’exécution, soit sur site, soit sur une plate-forme cloud comme Amazon Elastic Kubernetes Service (EKS) , Google Kubernetes Engine (GKE) ou Azure Kubernetes Service (AKS).
- Prise en charge GPU : Les LLM sont intensifs en calcul et nécessitent souvent une accélération GPU pour une inférence efficace. Assurez-vous que votre cluster Kubernetes a accès à des ressources GPU, soit via des GPU physiques, soit via des instances GPU basées sur le cloud.
- Registre de conteneurs : Vous aurez besoin d’un registre de conteneurs pour stocker vos images Docker de LLM. Des options populaires incluent Docker Hub, Amazon Elastic Container Registry (ECR), Google Container Registry (GCR) ou Azure Container Registry (ACR).
- Fichiers de modèle LLM : Obtenez les fichiers de modèle LLM pré-formés (poids, configuration et tokeniseur) à partir de la source respective ou formez votre propre modèle.
- Conteneurisation : Conteneurisez votre application LLM à l’aide de Docker ou d’un runtime de conteneur similaire. Cela implique la création d’un fichier Docker qui package votre code LLM, les dépendances et les fichiers de modèle dans une image Docker.
Déploiement d’un LLM sur Kubernetes
Une fois que vous avez 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 :
Construction de l’image Docker
Construisez l’image Docker pour votre application LLM à l’aide du fichier Docker fourni et poussez-la vers votre registre de conteneurs.
Création de ressources Kubernetes
Définissez les ressources Kubernetes requises pour votre déploiement de LLM, telles que les déploiements, les services, les ConfigMaps et les Secrets. Ces ressources sont généralement définies à l’aide de manifests YAML ou JSON.
Configuration des exigences de ressources
Spécifiez les exigences de ressources pour votre déploiement de LLM, y compris 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’outil de ligne de commande kubectl ou un outil de gestion de Kubernetes (par exemple, Kubernetes Dashboard, Rancher ou Lens) pour appliquer les manifests Kubernetes et déployer votre application LLM.
Supervision et mise à l’échelle
Supervisez les performances et l’utilisation des ressources de votre déploiement de LLM à l’aide d’outils de supervision de Kubernetes tels que Prometheus et Grafana. Ajustez l’allocation des ressources ou mettez à l’échelle votre déploiement selon les besoins pour répondre à la demande.
Exemple de déploiement
Considérons un exemple de déploiement du modèle de langage GPT-3 sur Kubernetes à l’aide d’une image Docker pré-construite à partir de Hugging Face. Nous supposons que vous avez un cluster Kubernetes configuré et doté d’une prise en charge GPU.
Téléchargement de l’image Docker :
<p>docker pull huggingface/text-generation-inference:1.1.0</p>
Création d’un déploiement Kubernetes :
Créez un fichier nommé gpt3-deployment.yaml avec le contenu suivant :
<p>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</p>
Ce déploiement spécifie que nous voulons exécuter une réplique du conteneur gpt3 en utilisant 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éation d’un service Kubernetes :
Créez un fichier nommé gpt3-service.yaml avec le contenu suivant :
<p>apiVersion: v1 kind: Service metadata: name: gpt3-service spec: selector: app: gpt3 ports: - port: 80 targetPort: 8080 type: LoadBalancer</p>
Ce service expose le déploiement gpt3 sur le port 80 et crée un service LoadBalancer pour rendre le serveur d’inférence accessible depuis l’extérieur du cluster Kubernetes.
Déploiement sur Kubernetes :
Appliquez les manifests Kubernetes à l’aide de la commande kubectl :
<p>kubectl apply -f gpt3-deployment.yaml kubectl apply -f gpt3-service.yaml</p>
Supervision du déploiement :
Supervisez la progression du déploiement à l’aide des commandes suivantes :
<p>kubectl get pods kubectl logs <pod_name></p>
Une fois que le pod est en cours d’exécution et que les journaux 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
Test du déploiement :
Vous pouvez maintenant envoyer des requêtes au serveur d’inférence en utilisant l’adresse IP externe et le port obtenus à l’étape précédente. Par exemple, en utilisant curl :
<p>curl -X POST \
http://<external_ip>:80/generate \
-H 'Content-Type: application/json' \
-d '{"inputs": "The quick brown fox", "parameters": {"max_new_tokens": 50}}'</p>
Cette commande envoie une requête de génération de texte au serveur d’inférence GPT-3, lui demandant de continuer la phrase “The quick brown fox” pour jusqu’à 50 jetons supplémentaires.
Sujets avancés dont vous devriez être conscient
Bien que l’exemple ci-dessus démontre un déploiement de base d’un LLM sur Kubernetes, il existe plusieurs sujets avancés et considérations à explorer :
1. Autoscaling
Kubernetes prend en charge l’autoscaling horizontal et vertical, ce qui peut être bénéfique pour les déploiements de LLM en raison de leurs demandes de calcul variables. L’autoscaling horizontal permet de mettre à l’échelle automatiquement le nombre de répliques (pods) en fonction de métriques telles que l’utilisation du processeur ou de la mémoire. L’autoscaling vertical, quant à lui, permet d’ajuster dynamiquement les demandes de ressources et les limites pour vos conteneurs.
Pour activer l’autoscaling, vous pouvez utiliser l’ Horizontal Pod Autoscaler (HPA) de Kubernetes et le Vertical Pod Autoscaler (VPA). Ces composants surveillent votre déploiement et mettent à l’échelle les ressources automatiquement 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 de LLM ou d’autres charges de travail intensives en calcul sont exécutés sur le même cluster Kubernetes, une planification et un partage efficaces de GPU deviennent cruciaux. Kubernetes fournit plusieurs mécanismes pour garantir une utilisation équitable et efficace de GPU, tels que les plugins de périphériques GPU, les sélecteurs de nœud et les limites de ressources.
Vous pouvez également utiliser des techniques de planification de GPU avancées telles que NVIDIA Multi-Instance GPU (MIG) (NVDA ) ou AMD Memory Pool Remapping (MPR) pour virtualiser les GPU et les partager entre plusieurs charges de travail.
3. Parallélisme de modèle et partitionnement
Certains LLM, en particulier ceux avec des milliards ou des trillions 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 de modèle et de partitionnement pour distribuer le modèle sur plusieurs GPU ou nœuds.
Le parallélisme de modèle 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 partitionnement, quant à lui, implique de diviser les paramètres du modèle et de les distribuer sur plusieurs appareils ou nœuds.
Kubernetes fournit des mécanismes tels que les StatefulSets et les définitions de ressources personnalisées (CRD) pour gérer et orchestrer les déploiements de LLM distribués avec parallélisme de modèle et partitionnement.
4. Affinage et apprentissage continu
Dans de nombreux cas, les LLM pré-formés peuvent nécessiter un affinage ou un apprentissage continu sur des données spécifiques au domaine pour améliorer leurs performances pour des tâches ou des domaines spécifiques. Kubernetes peut faciliter ce processus en fournissant une plate-forme scalable et résiliente pour exécuter des charges de travail d’affinage ou d’apprentissage continu.
Vous pouvez utiliser des frameworks de traitement par lots de Kubernetes tels que Apache Spark ou Kubeflow pour exécuter des tâches de formation ou d’affinage distribuées sur vos modèles LLM. De plus, vous pouvez intégrer vos modèles affinés ou formés de manière continue avec vos déploiements d’inférence en utilisant des mécanismes de Kubernetes tels que les mises à jour progressives ou les déploiements bleu/vert.
5. Supervision et observabilité
La supervision et l’observabilité sont des aspects cruciaux de tout déploiement de production, y compris les déploiements de LLM sur Kubernetes. Kubernetes fournit des solutions de supervision intégrées telles que Prometheus et des intégrations avec des plateformes d’observabilité populaires telles que Grafana, Elasticsearch et Jaeger.
Vous pouvez surveiller diverses métriques liées à vos déploiements de LLM, telles que l’utilisation du processeur et de la mémoire, l’utilisation de GPU, la latence d’inférence et le débit. De plus, vous pouvez collecter et analyser des journaux et des traces d’application pour obtenir des informations sur le comportement et les performances de vos modèles LLM.
6. Sécurité et conformité
Selon votre cas d’utilisation et la sensibilité des données impliquées, vous pouvez devoir considérer 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 de 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 HashiCorp Vault (HCP ) ou AWS Secrets Manager.
De plus, si vous déployez des LLM dans des industries réglementées ou traitez des données sensibles, vous devrez peut-être vous assurer de la conformité avec les normes et réglementations pertinentes, telles que le RGPD, le HIPAA ou le PCI-DSS.
7. Déploiements multi-cloud et hybrides
Bien que cet article se concentre sur le déploiement de LLM sur un cluster Kubernetes unique, vous pouvez devoir considérer 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 sur des centres de données sur site.
Vous pouvez utiliser des outils de fédération de Kubernetes ou de gestion de cluster multiple tels que KubeFed ou GKE Hub pour gérer et orchestrer les déploiements de LLM sur plusieurs clusters Kubernetes s’étendant sur différents fournisseurs de cloud ou environnements hybrides.
Ces sujets avancés mettent en évidence la flexibilité et la scalabilité de Kubernetes pour déployer et gérer des LLM.
Conclusion
Le déploiement de grands modèles de langage (LLM) sur Kubernetes offre de nombreux avantages, notamment la scalabilité, 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 les 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 grandit et que vos besoins évoluent, vous devrez peut-être explorer des sujets avancés tels que l’autoscaling, la planification de GPU, le parallélisme de modèle, l’affinage, la supervision, la sécurité et les déploiements multi-cloud.
Kubernetes fournit une plate-forme robuste et extensible pour déployer et gérer des LLM, vous permettant de créer des applications fiables, scalable et sécurisées.
