Outils d’IA 101
Configurer un entraînement, un affinement et une inférence de LLM avec des GPU NVIDIA et CUDA
Ajouter Unite.AI à vos sources préférées sur Google
Le domaine de l’intelligence artificielle (IA) a connu des avancées remarquables ces dernières années, et au cœur de cela se trouve la puissante combinaison de unités de traitement graphique (GPU) et de plate-forme de calcul parallèle.
Des modèles tels que GPT, BERT, et plus récemment Llama, Mistral sont capables de comprendre et de générer du texte humain avec une fluidité et une cohérence sans précédent. Cependant, l’entraînement de ces modèles nécessite d’énormes quantités de données et de ressources computationnelles, ce qui rend les GPU et CUDA des outils indispensables dans cette entreprise.
Ce guide complet vous guidera à travers le processus de configuration d’un GPU NVIDIA (NVDA ) sur Ubuntu, en couvrant l’installation de composants logiciels essentiels tels que le pilote NVIDIA, le kit de développement CUDA, cuDNN, PyTorch et plus.
L’essor des frameworks d’IA accélérés par CUDA
L’apprentissage automatique accéléré par GPU a été alimenté par le développement de frameworks d’IA populaires qui exploitent CUDA pour un calcul efficace. Des frameworks tels que TensorFlow, PyTorch et MXNet ont une prise en charge intégrée de CUDA, permettant une intégration transparente de l’accélération GPU dans les pipelines d’apprentissage automatique.
Selon l’étude de performance des produits d’apprentissage automatique de NVIDIA Data Center, les modèles d’apprentissage automatique accélérés par CUDA peuvent atteindre des performances jusqu’à 100 fois plus rapides que les implémentations basées sur le processeur central (CPU).
La technologie Multi-Instance GPU (MIG) de NVIDIA, introduite avec l’architecture Ampere, permet à une seule GPU d’être partitionnée en plusieurs instances sécurisées, chacune avec ses propres ressources dédiées. Cette fonctionnalité permet un partage efficace des ressources GPU entre plusieurs utilisateurs ou charges de travail, maximisant l’utilisation et réduisant les coûts globaux.
Accélérer l’inférence de LLM avec NVIDIA TensorRT
Alors que les GPU ont été instrumentaux dans l’entraînement des LLM, une inférence efficace est également cruciale pour déployer ces modèles dans des environnements de production. NVIDIA TensorRT, un optimiseur et un runtime d’inférence d’apprentissage automatique haute performance, joue un rôle vital dans l’accélération de l’inférence de LLM sur les GPU compatibles CUDA.
Selon les benchmarks de NVIDIA, TensorRT peut fournir jusqu’à 8 fois de meilleures performances d’inférence et 5 fois de moins de coûts totaux de possession par rapport à l’inférence basée sur le processeur central (CPU) pour les grands modèles de langage comme GPT-3.
L’engagement de NVIDIA en faveur des initiatives open source a été un facteur clé de l’adoption généralisée de CUDA dans la communauté de recherche en IA. Des projets tels que cuDNN, cuBLAS et NCCL sont disponibles en tant que bibliothèques open source, permettant aux chercheurs et aux développeurs d’exploiter pleinement le potentiel de CUDA pour leur apprentissage automatique.
Installation
Lors de la configuration d’un environnement de développement d’IA, utiliser les derniers pilotes et bibliothèques n’est pas toujours le meilleur choix. Par exemple, bien que le dernier pilote NVIDIA (545.xx) prenne en charge CUDA 12.3, PyTorch et d’autres bibliothèques peuvent ne pas prendre en charge cette version. Par conséquent, nous allons utiliser la version du pilote 535.146.02 avec CUDA 12.2 pour assurer la compatibilité.
Étapes d’installation
1. Installer le pilote NVIDIA
Tout d’abord, identifiez votre modèle de GPU. Pour ce guide, nous utilisons le GPU NVIDIA. Visitez la page de téléchargement du pilote NVIDIA, sélectionnez le pilote approprié pour votre GPU et notez la version du pilote.
Pour vérifier les packages GPU préconstruits sur Ubuntu, exécutez:
sudo ubuntu-drivers list --gpgpu
Redémarrez votre ordinateur et vérifiez l’installation:
nvidia-smi
2. Installer le kit de développement CUDA
Le kit de développement CUDA fournit l’environnement de développement pour la création d’applications accélérées par GPU à haute performance.
Pour un environnement non-LLM/apprentissage automatique, vous pouvez utiliser:
sudo apt install nvidia-cuda-toolkit <p>Cependant, pour assurer la compatibilité avec BitsAndBytes, nous allons suivre ces étapes:</p> [code language=&quot;BASH&quot;] <p>git clone https://github.com/TimDettmers/bitsandbytes.git cd bitsandbytes/ bash install_cuda.sh 122 ~/local 1</p>
Vérifiez l’installation:
~/local/cuda-12.2/bin/nvcc --version
Définissez les variables d’environnement:
<p>export CUDA_HOME=/home/roguser/local/cuda-12.2/ export LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64 export BNB_CUDA_VERSION=122 export CUDA_VERSION=122</p>
3. Installer cuDNN
Téléchargez le package cuDNN à partir du site Web des développeurs NVIDIA. Installez-le avec:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Suivez les instructions pour ajouter la clé de confiance:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Installez les bibliothèques cuDNN:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Configurer l’environnement virtuel Python
Ubuntu 22.04 est livré avec Python 3.10. Installez venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Créez et activez l’environnement virtuel:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Installer BitsAndBytes à partir de la source
Accédez au répertoire BitsAndBytes et construisez à partir de la source:
<p>cd ~/bitsandbytes CUDA_HOME=/home/roguser/local/cuda-12.2/ \ LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64 \ BNB_CUDA_VERSION=122 \ CUDA_VERSION=122 \ make cuda12x</p> <p>CUDA_HOME=/home/roguser/local/cuda-12.2/ \ LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64 \ BNB_CUDA_VERSION=122 \ CUDA_VERSION=122 \ python setup.py install</p>
6. Installer PyTorch
Installez PyTorch avec la commande suivante:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Installer Hugging et Transformers
Installez les bibliothèques transformers et accelerate:
<p>pip install transformers pip install accelerate</p>
Le pouvoir du traitement parallèle
Au cœur, les GPU sont des processeurs parallèles conçus pour gérer des milliers de threads concurrents de manière efficace. Cette architecture les rend bien adaptés aux tâches computationnelles intensives impliquées dans l’entraînement des modèles d’apprentissage automatique, y compris les LLM. La plate-forme CUDA, développée par NVIDIA, fournit un environnement logiciel qui permet aux développeurs d’exploiter pleinement le potentiel de ces GPU, leur permettant d’écrire du code qui peut exploiter les capacités de traitement parallèle du matériel.
Accélérer l’entraînement de LLM avec des GPU et CUDA.
L’entraînement de grands modèles de langage est une tâche computationnellement exigeante qui nécessite le traitement de grandes quantités de données textuelles et la réalisation de nombreuses opérations matricielles. Les GPU, avec leurs milliers de cœurs et leur grande bande passante mémoire, sont idéalement adaptés à ces tâches. En exploitant CUDA, les développeurs peuvent optimiser leur code pour profiter des capacités de traitement parallèle des GPU, réduisant ainsi considérablement le temps nécessaire pour entraîner les LLM.
Par exemple, l’entraînement de GPT-3, l’un des plus grands modèles de langage à ce jour, a été rendu possible grâce à l’utilisation de milliers de GPU NVIDIA exécutant du code optimisé pour CUDA. Cela a permis au modèle d’être entraîné sur une quantité sans précédent de données, conduisant à ses performances impressionnantes dans les tâches de langage naturel.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Chargez le modèle GPT-2 pré-entraîné et le tokenizer
model = GPT2LMHeadModel.from_pretrained(&#039;gpt2&#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&#039;gpt2&#039;)</p>
<p># Déplacez le modèle vers le GPU si disponible
device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
model = model.to(device)</p>
<p># Définissez les données d'entraînement et les hyperparamètres
train_data = [...] # Vos données d'entraînement
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Définissez la fonction de perte et l'optimiseur
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># Boucle d'entraînement
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Préparez les séquences d'entrée et de sortie
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors=&quot;pt&quot;, padding=True)
inputs = inputs.to(device)
targets = targets.to(device)</p>
<p># Passe avant
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Passe arrière et optimisation
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f&#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&#039;)</p>
Dans cet exemple de code, nous démontrons l’entraînement d’un modèle de langage GPT-2 à l’aide de PyTorch et de GPU compatibles CUDA. Le modèle est chargé sur le GPU (si disponible), et la boucle d’entraînement exploite le parallélisme des GPU pour effectuer des passes avant et arrière efficaces, accélérant ainsi l’entraînement.
Bibliothèques d’apprentissage automatique accélérées par CUDA
En plus de la plate-forme CUDA elle-même, NVIDIA et la communauté open source ont développé une gamme de bibliothèques accélérées par CUDA qui permettent une mise en œuvre efficace de modèles d’apprentissage automatique, y compris les LLM. Ces bibliothèques fournissent des implémentations optimisées d’opérations courantes, telles que des multiplications matricielles, des convolutions et des fonctions d’activation, permettant aux développeurs de se concentrer sur l’architecture du modèle et le processus d’entraînement plutôt que sur l’optimisation de bas niveau.
L’une de ces bibliothèques est cuDNN (bibliothèque de réseaux de neurones profonds CUDA), qui fournit des implémentations hautement optimisées de routines standard utilisées dans les réseaux de neurones profonds. En exploitant cuDNN, les développeurs peuvent accélérer considérablement l’entraînement et l’inférence de leurs modèles, atteignant des gains de performance de plusieurs ordres de grandeur par rapport aux implémentations basées sur le processeur central (CPU).
<p>import torch import torch.nn as nn import torch.nn.functional as F from torch.cuda.amp import autocast</p> <p>class ResidualBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels))</p> <p>def forward(self, x): with autocast(): out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) out = F.relu(out) return out</p>
Dans cet exemple de code, nous définissons un bloc résiduel pour un réseau de neurones convolutionnel (CNN) à l’aide de PyTorch. Le gestionnaire de contexte autocast de PyTorch est utilisé pour activer l’entraînement à précision mixte, qui peut fournir des gains de performance importants sur les GPU compatibles CUDA tout en maintenant une grande précision. La fonction F.relu est optimisée par cuDNN, garantissant une exécution efficace sur les GPU.
Formation multi-GPU et distribuée pour la scalabilité
Alors que les LLM et les modèles d’apprentissage automatique continuent de grandir en taille et en complexité, les exigences computationnelles pour l’entraînement de ces modèles augmentent également. Pour relever ce défi, les chercheurs et les développeurs ont recours à des techniques de formation multi-GPU et distribuée, qui leur permettent d’exploiter la puissance de traitement combinée de plusieurs GPU sur plusieurs machines.
CUDA et les bibliothèques associées, telles que NCCL (bibliothèque de communications collectives NVIDIA), fournissent des primitives de communication efficaces qui permettent une transmission de données et une synchronisation transparentes entre plusieurs GPU, permettant une formation distribuée à une échelle sans précédent.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Initialisez la formation distribuée dist.init_process_group(backend=&#039;nccl&#039;, init_method=&#039;...&#039;) local_rank = dist.get_rank() torch.cuda.set_device(local_rank)</p> <p># Créez le modèle et déplacez-le sur le GPU model = MyModel().cuda()</p> <p># Emballez le modèle avec DDP model = DDP(model, device_ids=[local_rank])</p> <p># Boucle d'entraînement (distribuée) for epoch in range(num_epochs): for data in train_loader: inputs, targets = data inputs = inputs.cuda(non_blocking=True) targets = targets.cuda(non_blocking=True)</p> <p>outputs = model(inputs) loss = criterion(outputs, targets)</p> <p>optimizer.zero_grad() loss.backward() optimizer.step()</p>
Dans cet exemple, nous démontrons la formation distribuée à l’aide du module DistributedDataParallel (DDP) de PyTorch. Le modèle est emballé avec DDP, qui gère automatiquement la parallélisation des données, la synchronisation des gradients et la communication entre plusieurs GPU à l’aide de NCCL. Cette approche permet une mise à l’échelle efficace du processus d’entraînement sur plusieurs machines, permettant aux chercheurs et aux développeurs de former des modèles plus grands et plus complexes en un temps raisonnable.
Déployer des modèles d’apprentissage automatique avec CUDA
Alors que les GPU et CUDA ont été principalement utilisés pour l’entraînement des modèles d’apprentissage automatique, ils sont également cruciaux pour une inférence efficace et un déploiement. Alors que les modèles d’apprentissage automatique deviennent de plus en plus complexes et gourmands en ressources, l’accélération GPU est essentielle pour atteindre des performances en temps réel dans les environnements de production.
NVIDIA’s TensorRT est un optimiseur et un runtime d’inférence d’apprentissage automatique haute performance qui fournit une inférence à faible latence et à haut débit sur les GPU compatibles CUDA. TensorRT peut optimiser et accélérer les modèles formés dans des frameworks tels que TensorFlow, PyTorch et MXNet, permettant un déploiement efficace sur diverses plateformes, des systèmes embarqués aux centres de données.
import tensorrt as trt <p># Chargez le modèle pré-entraîné model = load_model(...)</p> <p># Créez le moteur TensorRT logger = trt.Logger(trt.Logger.INFO) builder = trt.Builder(logger) network = builder.create_network() parser = trt.OnnxParser(network, logger)</p> <p># Analysez et optimisez le modèle success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Exécutez l'inférence sur le GPU context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Définissez les données d'entrée et exécutez l'inférence set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Traitez la sortie # ...
Dans cet exemple, nous démontrons l’utilisation de TensorRT pour déployer un modèle d’apprentissage automatique pré-entraîné sur un GPU compatible CUDA. Le modèle est analysé et optimisé par TensorRT, qui génère un moteur d’inférence hautement optimisé adapté au modèle et au matériel spécifiques. Ce moteur peut ensuite être utilisé pour effectuer une inférence efficace sur le GPU, en exploitant CUDA pour un calcul accéléré.
Conclusion
La combinaison de GPU et de CUDA a été instrumentale dans les avancées des grands modèles de langage, de la vision par ordinateur, de la reconnaissance vocale et de divers autres domaines de l’apprentissage automatique. En exploitant les capacités de traitement parallèle des GPU et les bibliothèques optimisées fournies par CUDA, les chercheurs et les développeurs peuvent former et déployer des modèles de plus en plus complexes avec une grande efficacité.
À mesure que le domaine de l’IA continue d’évoluer, l’importance des GPU et de CUDA ne fera que grandir. Avec des matériel et des optimisations logicielles encore plus puissants, nous pouvons nous attendre à voir de nouvelles avancées dans le développement et le déploiement de systèmes d’IA, repoussant les limites de ce qui est possible.
