Configuración de capacitación, ajuste e inferencia de LLM con GPU NVIDIA y CUDA

El campo de la inteligencia artificial (IA) ha sido testigo de avances notables en los últimos años, y en su núcleo se encuentra la poderosa combinación de unidades de procesamiento de gráficos (GPU) y una plataforma informática paralela.

Modelos como GPT, BERT, y más recientemente Llama, Mistral son capaces de comprender y generar textos similares a los humanos con una fluidez y coherencia sin precedentes. Sin embargo, entrenar estos modelos requiere grandes cantidades de datos y recursos computacionales, lo que hace que las GPU y CUDA sean herramientas indispensables en este esfuerzo.

Esta guía completa lo guiará a través del proceso de configuración de una GPU NVIDIA en Ubuntu y cubrirá la instalación de componentes de software esenciales como el controlador NVIDIA, CUDA Toolkit, cuDNN, PyTorch y más.

El auge de los marcos de IA acelerados por CUDA

El aprendizaje profundo acelerado por GPU se ha visto impulsado por el desarrollo de marcos de IA populares que aprovechan CUDA para una computación eficiente. Marcos como TensorFlow, PyTorch y MXNet tienen soporte integrado para CUDA, lo que permite una integración perfecta de la aceleración de GPU en canales de aprendizaje profundo.

Según el Estudio de rendimiento del producto de aprendizaje profundo del centro de datos de NVIDIA, los modelos de aprendizaje profundo acelerados por CUDA pueden lograr un rendimiento hasta cientos de veces más rápido en comparación con las implementaciones basadas en CPU.

La tecnología de GPU multiinstancia (MIG) de NVIDIA, introducida con la arquitectura Ampere, permite dividir una sola GPU en varias instancias seguras, cada una con sus propios recursos dedicados. Esta función permite compartir eficientemente los recursos de la GPU entre múltiples usuarios o cargas de trabajo, maximizando su utilización y reduciendo los costes generales.

Acelerando la inferencia LLM con NVIDIA TensorRT

Si bien las GPU han sido fundamentales en la formación de LLM, la inferencia eficiente es igualmente crucial para implementar estos modelos en entornos de producción. TensorRT de NVIDIA, un tiempo de ejecución y optimizador de inferencia de aprendizaje profundo de alto rendimiento, desempeña un papel vital en la aceleración de la inferencia de LLM en GPU habilitadas para CUDA.

Según los puntos de referencia de NVIDIA, TensorRT puede proporcionar un rendimiento de inferencia hasta 8 veces más rápido y un costo total de propiedad 5 veces menor en comparación con la inferencia basada en CPU para modelos de lenguaje grandes como GPT-3.

El compromiso de NVIDIA con las iniciativas de código abierto ha sido un factor impulsor de la adopción generalizada de CUDA en la comunidad de investigación de IA. Proyectos como cuDNN, CUBLAS y NCCL están disponibles como bibliotecas de código abierto, lo que permite a los investigadores y desarrolladores aprovechar todo el potencial de CUDA para su aprendizaje profundo.

Instalación

Al configurar el desarrollo de IA, es posible que utilizar los controladores y bibliotecas más recientes no siempre sea la mejor opción. Por ejemplo, si bien el controlador NVIDIA más reciente (545.xx) es compatible con CUDA 12.3, es posible que PyTorch y otras bibliotecas aún no admitan esta versión. Por lo tanto, usaremos versión del controlador 535.146.02 con CUDA 12.2 para asegurar la compatibilidad.

Pasos de la instalación

1. Instale el controlador NVIDIA

Primero, identifique su modelo de GPU. Para esta guía, utilizamos la GPU NVIDIA. Visita el Página de descarga del controlador NVIDIA, seleccione el controlador apropiado para su GPU y anote la versión del controlador.

Para buscar paquetes de GPU prediseñados en Ubuntu, ejecute:

sudo ubuntu-drivers list --gpgpu

Reinicie su computadora y verifique la instalación:

nvidia-smi

2. Instale el kit de herramientas CUDA

CUDA Toolkit proporciona el entorno de desarrollo para crear aplicaciones aceleradas por GPU de alto rendimiento.

Para una configuración que no sea LLM/aprendizaje profundo, puede usar:

sudo apt install nvidia-cuda-toolkit

However, to ensure compatibility with BitsAndBytes, we will follow these steps:

[code language="BASH"]

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

Verifique la instalación:

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

Establezca las variables de entorno:

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. Instale cuDNN

Descargue nuestra paquete cuDNN de la Sitio web para desarrolladores de NVIDIA. Instálalo con:

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

Siga las instrucciones para agregar el llavero:

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

Instale las bibliotecas cuDNN:

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

4. Configurar el entorno virtual Python

Ubuntu 22.04 viene con Python 3.10. Instalar venv:

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

Crear y activar el entorno virtual:

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

5. Instale BitsAndBytes desde la fuente

Navegue hasta el directorio BitsAndBytes y cree desde la fuente:

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. Instale PyTorch

Instale PyTorch con el siguiente comando:

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

7. Instale Hugging Face y Transformers

Instale los transformadores y acelere las bibliotecas:

pip install transformers
pip install accelerate

El poder del procesamiento paralelo

En esencia, las GPU son procesadores altamente paralelos diseñados para manejar miles de subprocesos simultáneos de manera eficiente. Esta arquitectura los hace adecuados para las tareas computacionalmente intensivas involucradas en el entrenamiento de modelos de aprendizaje profundo, incluidos los LLM. La plataforma CUDA, desarrollada por NVIDIA, proporciona un entorno de software que permite a los desarrolladores aprovechar todo el potencial de estas GPU, permitiéndoles escribir código que pueda aprovechar las capacidades de procesamiento paralelo del hardware.
Acelerando LLM Entrenamiento con GPUs y CUDA.

Entrenar grandes modelos de lenguaje es una tarea computacionalmente exigente que requiere procesar grandes cantidades de datos de texto y realizar numerosas operaciones matriciales. Las GPU, con sus miles de núcleos y su gran ancho de banda de memoria, son ideales para estas tareas. Al aprovechar CUDA, los desarrolladores pueden optimizar su código para aprovechar las capacidades de procesamiento paralelo de las GPU, lo que reduce significativamente el tiempo necesario para capacitar a los LLM.

Por ejemplo, la formación de GPT-3, uno de los modelos de lenguaje más grandes hasta la fecha, fue posible gracias al uso de miles de GPU NVIDIA que ejecutan código optimizado para CUDA. Esto permitió entrenar el modelo con una cantidad de datos sin precedentes, lo que llevó a su rendimiento impresionante en tareas de lenguaje natural.

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

# Load pre-trained GPT-2 model and tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Move model to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Define training data and hyperparameters
train_data = [...] # Your training data
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Training loop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Prepare input and target sequences
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Forward pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward pass and optimization
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')

En este fragmento de código de ejemplo, demostramos el entrenamiento de un GPT-2 modelo de lenguaje utilizando PyTorch y las GPU habilitadas para CUDA. El modelo se carga en la GPU (si está disponible) y el bucle de entrenamiento aprovecha el paralelismo de las GPU para realizar pases eficientes hacia adelante y hacia atrás, acelerando el proceso de entrenamiento.

Bibliotecas aceleradas por CUDA para aprendizaje profundo

Además de la propia plataforma CUDA, NVIDIA y la comunidad de código abierto han desarrollado una gama de bibliotecas aceleradas por CUDA que permiten la implementación eficiente de modelos de aprendizaje profundo, incluidos los LLM. Estas bibliotecas proporcionan implementaciones optimizadas de operaciones comunes, como multiplicaciones de matrices, convoluciones y funciones de activación, lo que permite a los desarrolladores centrarse en la arquitectura del modelo y el proceso de capacitación en lugar de la optimización de bajo nivel.

Una de esas bibliotecas es cuDNN (biblioteca CUDA Deep Neural Network), que proporciona implementaciones altamente ajustadas de rutinas estándar utilizadas en redes neuronales profundas. Al aprovechar cuDNN, los desarrolladores pueden acelerar significativamente el entrenamiento y la inferencia de sus modelos, logrando ganancias de rendimiento de hasta varios órdenes de magnitud en comparación con las implementaciones basadas en 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

En este fragmento de código, definimos un bloque residual para una red neuronal convolucional (CNN) con PyTorch. El gestor de contexto de autocast de Precisión Mixta Automática (AMP) de PyTorch se utiliza para habilitar el entrenamiento de precisión mixta, lo que puede proporcionar mejoras significativas de rendimiento en GPU con CUDA, manteniendo una alta precisión. La función F.relu está optimizada por cuDNN, lo que garantiza una ejecución eficiente en GPU.

Multi-GPU y capacitación distribuida para escalabilidad

A medida que los LLM y los modelos de aprendizaje profundo continúan creciendo en tamaño y complejidad, también aumentan los requisitos computacionales para entrenar estos modelos. Para abordar este desafío, los investigadores y desarrolladores han recurrido a múltiples GPU y técnicas de capacitación distribuida, que les permiten aprovechar la potencia de procesamiento combinada de múltiples GPU en múltiples máquinas.

CUDA y las bibliotecas asociadas, como NCCL (NVIDIA Collective Communications Library), proporcionan primitivas de comunicación eficientes que permiten la transferencia y sincronización de datos sin problemas entre múltiples GPU, lo que permite la capacitación distribuida a una escala sin precedentes.

</pre>
import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialize distributed training
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Create model and move to GPU
model = MyModel().cuda()

# Wrap model with DDP
model = DDP(model, device_ids=[local_rank])

# Training loop (distributed)
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()

En este ejemplo, demostramos el entrenamiento distribuido con el módulo DistributedDataParallel (DDP) de PyTorch. El modelo está encapsulado en DDP, que gestiona automáticamente el paralelismo de datos, la sincronización de gradientes y la comunicación entre múltiples GPU mediante NCCL. Este enfoque permite un escalado eficiente del proceso de entrenamiento en múltiples máquinas, lo que permite a investigadores y desarrolladores entrenar modelos más grandes y complejos en un tiempo razonable.

Implementación de modelos de aprendizaje profundo con CUDA

Si bien las GPU y CUDA se han utilizado principalmente para entrenar modelos de aprendizaje profundo, también son cruciales para una implementación e inferencia eficientes. A medida que los modelos de aprendizaje profundo se vuelven cada vez más complejos y consumen más recursos, la aceleración de GPU es esencial para lograr rendimiento en tiempo real en entornos de producción.

TensorRT de NVIDIA es un optimizador de inferencia de aprendizaje profundo de alto rendimiento y un entorno de ejecución que proporciona baja latencia y alto rendimiento inferencia en GPU habilitadas para CUDA. TensorRT puede optimizar y acelerar modelos entrenados en marcos como TensorFlow, PyTorch y MXNet, lo que permite una implementación eficiente en varias plataformas, desde sistemas integrados hasta centros de datos.

import tensorrt as trt

# Load pre-trained model
model = load_model(...)

# Create TensorRT engine
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parse and optimize model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Run inference on GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Set input data and run inference
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Process output
# ...

En este ejemplo, demostramos el uso de TensorRT para implementar un modelo de aprendizaje profundo previamente entrenado en una GPU habilitada para CUDA. Primero, TensorRT analiza y optimiza el modelo, lo que genera un motor de inferencia altamente optimizado diseñado para el modelo y el hardware específicos. Luego, este motor se puede utilizar para realizar inferencias eficientes en la GPU, aprovechando CUDA para un cálculo acelerado.

Conclusión

La combinación de GPU y CUDA ha sido fundamental para impulsar los avances en grandes modelos de lenguaje, visión por computadora, reconocimiento de voz y varios otros dominios del aprendizaje profundo. Aprovechando las capacidades de procesamiento paralelo de las GPU y las bibliotecas optimizadas proporcionadas por CUDA, los investigadores y desarrolladores pueden entrenar e implementar modelos cada vez más complejos con alta eficiencia.

A medida que el campo de la IA siga evolucionando, la importancia de las GPU y CUDA no hará más que crecer. Con optimizaciones de hardware y software aún más potentes, podemos esperar ver más avances en el desarrollo y la implementación de sistemas de IA, superando los límites de lo que es posible.