Configuration d’une formation, d’un affinement et d’une inférence de LLM avec les GPU NVIDIA et CUDA

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 combinaison puissante des unités de traitement graphique (GPU) et de la 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 similaire à celui des humains avec une fluidité et une cohérence sans précédent. Cependant, la formation 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 sur Ubuntu, en couvrant l’installation de composants logiciels essentiels tels que le pilote NVIDIA, le kit d’outils CUDA, cuDNN, PyTorch, et plus.

L’essor des frameworks d’IA accélérés par CUDA

L’apprentissage automatique profond accéléré par GPU a été alimenté par le développement de frameworks d’IA populaires qui utilisent 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 une performance jusqu’à 100 fois plus rapide 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 ainsi l’utilisation et réduisant les coûts globaux.

Accélération de l’inférence LLM avec NVIDIA TensorRT

Alors que les GPU ont été instrumentaux dans la formation de LLM, une inférence efficace est tout aussi cruciale pour déployer ces modèles dans des environnements de production. NVIDIA TensorRT, un optimiseur et un moteur d’inférence d’apprentissage automatique de haute performance, joue un rôle vital dans l’accélération de l’inférence LLM sur les GPU compatibles CUDA.

Selon les benchmarks de NVIDIA, TensorRT peut fournir une performance d’inférence jusqu’à 8 fois plus rapide et un coût total de possession 5 fois inférieur par rapport à l’inférence basée sur le processeur central (CPU) pour les grands modèles de langage tels que GPT-3.

L’engagement de NVIDIA en faveur des initiatives open source a été un facteur clé dans 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 de tirer parti du plein 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 ne constitue 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 le pilote 535.146.02 avec CUDA 12.2 pour assurer la compatibilité.

Étapes d’installation

1. Installer le pilote NVIDIA

Identifiez d’abord 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 d’outils CUDA

Le kit d’outils CUDA fournit l’environnement de développement pour la création d’applications accélérées par GPU à haute performance.

Pour une configuration non-LLM/apprentissage automatique, vous pouvez utiliser :

sudo apt install nvidia-cuda-toolkit

Cependant, pour assurer la compatibilité avec BitsAndBytes, nous allons suivre ces étapes :

[code language="BASH"]

git clone https://github.com/TimDettmers/bitsandbytes.git
cd bitsandbytes/
bash install_cuda.sh 122 ~/local 1

Vérifiez l’installation :

~/local/cuda-12.2/bin/nvcc --version

Définissez les variables d’environnement :

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

3. Installer cuDNN

Téléchargez le paquet cuDNN à partir du site Web des développeurs NVIDIA. Installez-le avec :

sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb

Suivez les instructions pour ajouter la clé de confiance :

sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/

Installez les bibliothèques cuDNN :

sudo apt update
sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples

4. Configurer l’environnement virtuel Python

Ubuntu 22.04 est livré avec Python 3.10. Installez venv :

sudo apt-get install python3-pip
sudo apt install python3.10-venv

Créez et activez l’environnement virtuel :

cd
mkdir test-gpu
cd test-gpu
python3 -m venv venv
source venv/bin/activate

5. Installer BitsAndBytes à partir du code source

Accédez au répertoire BitsAndBytes et construisez à partir du code source :

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

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

6. Installer PyTorch

Installez PyTorch avec la commande suivante :

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

7. Installer Hugging Face et Transformers

Installez les bibliothèques transformers et accelerate :

pip install transformers
pip install accelerate

Le pouvoir du traitement parallèle

Au cœur des GPU se trouvent des processeurs parallèles très puissants conçus pour gérer des milliers de threads simultanément de manière efficace. Cette architecture les rend bien adaptés aux tâches computationnelles intensives impliquées dans la formation de 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ération de la formation de LLM avec les GPU et CUDA.

La formation 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 large bande passante mémoire, sont idéalement adaptés à ces tâches. En exploitant CUDA, les développeurs peuvent optimiser leur code pour tirer parti des capacités de traitement parallèle des GPU, réduisant ainsi de manière significative le temps nécessaire à la formation des LLM.

Par exemple, la formation du GPT-3, l’un des plus grands modèles de langage à ce jour, a été rendue 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 formé sur une quantité de données sans précédent, conduisant à ses performances impressionnantes dans les tâches de langage naturel.

import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Chargez le modèle GPT-2 pré-entraîné et le tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Déplacez le modèle sur le GPU si disponible
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Définissez les données de formation et les hyperparamètres
train_data = [...] # Vos données de formation
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Définissez la fonction de perte et l'optimiseur
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 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="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Passe avant
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Passe arrière et optimisation
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f'Époque {epoch+1}/{num_epochs}, Perte : {loss.item()}')

Dans cet exemple de code, nous démontrons la formation d’un modèle de langage GPT-2 en utilisant PyTorch et les 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 le processus d’entraînement.

Bibliothèques accélérées par CUDA pour l’apprentissage automatique

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.

Une telle bibliothèque est cuDNN (bibliothèque de réseau neuronal profond CUDA), qui fournit des implémentations très optimisées des 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).

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.cuda.amp import autocast

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))

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

Dans cet exemple de code, nous définissons un bloc résiduel pour un réseau de neurones convolutionnel (CNN) en utilisant PyTorch. Le gestionnaire de contexte autocast de PyTorch’s Automatic Mixed Precision (AMP) est utilisé pour activer l’entraînement à précision mixte, ce 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 former ces modèles augmentent également. Pour relever ce défi, les chercheurs et les développeurs se sont tournés vers les techniques de formation multi-GPU et distribuée, qui leur permettent d’exploiter la puissance de calcul combinée de plusieurs GPU sur plusieurs machines.

CUDA et les bibliothèques associées, telles que NCCL (NVIDIA Collective Communications Library), fournissent des primitives de communication efficaces qui permettent une synchronisation transparente des données et des calculs entre plusieurs GPU, permettant ainsi une formation distribuée à une échelle sans précédent.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialisation de la formation distribuée
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Créez le modèle et déplacez-le sur le GPU
model = MyModel().cuda()

# Emballez le modèle avec DDP
model = DDP(model, device_ids=[local_rank])

# 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)

outputs = model(inputs)
loss = criterion(outputs, targets)

optimizer.zero_grad()
loss.backward()
optimizer.step()

Dans cet exemple, nous démontrons la formation distribuée en utilisant le module DistributedDataParallel (DDP) de PyTorch. Le modèle est emballé avec DDP, qui gère automatiquement le parallélisme des données, la synchronisation des gradients et la communication entre plusieurs GPU en utilisant NCCL. Cette approche permet d’augmenter efficacement le 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éploiement de modèles d’apprentissage automatique avec CUDA

Alors que les GPU et CUDA ont été principalement utilisés pour former des modèles d’apprentissage automatique, ils sont également cruciaux pour une inférence efficace et un déploiement. À mesure que les modèles d’apprentissage automatique deviennent de plus en plus complexes et gourmands en ressources, l’accélération par GPU est essentielle pour atteindre des performances en temps réel dans les environnements de production.

NVIDIA’s TensorRT est un optimiseur et un moteur d’inférence d’apprentissage automatique de 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 ainsi un déploiement efficace sur diverses plateformes, des systèmes embarqués aux centres de données.

import tensorrt as trt

# Chargez le modèle pré-entraîné
model = load_model(...)

# Créez le moteur TensorRT
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Analysez et optimisez le modèle
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Exécutez l'inférence sur le GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# 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)

# 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 d’abord 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 alors ê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 un matériel et des logiciels 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.