Herramientas de IA 101
Configuración de entrenamiento, ajuste fino y inferencia de LLM con GPUs y CUDA de NVIDIA
Añade Unite.AI a tus fuentes preferidas en Google
El campo de la inteligencia artificial (IA) ha experimentado avances notables en los últimos años, y en su núcleo se encuentra la poderosa combinación de unidades de procesamiento gráfico (GPUs) y la plataforma de computación paralela.
Modelos como GPT, BERT, y más recientemente Llama, Mistral son capaces de comprender y generar texto similar al humano 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 GPUs y CUDA sean herramientas indispensables en esta tarea.
Esta guía integral lo llevará a través del proceso de configuración de una GPU de NVIDIA (NVDA ) en Ubuntu, cubriendo la instalación de componentes de software esenciales como el controlador de NVIDIA, la herramienta de desarrollo de CUDA, cuDNN, PyTorch y más.
El auge de los marcos de IA acelerados por CUDA
El aprendizaje profundo acelerado por GPU ha sido impulsado por el desarrollo de marcos de IA populares que aprovechan CUDA para la computación eficiente. Marcos como TensorFlow, PyTorch y MXNet tienen soporte integrado para CUDA, lo que permite una integración sin problemas de la aceleración de GPU en las tuberías de aprendizaje profundo.
Según el Estudio de rendimiento de productos de aprendizaje profundo de NVIDIA Data Center, los modelos de aprendizaje profundo acelerados por CUDA pueden lograr un rendimiento hasta 100 veces más rápido en comparación con las implementaciones basadas en CPU.
La tecnología de GPU de instancia múltiple (MIG) de NVIDIA, introducida con la arquitectura Ampere, permite que una sola GPU se divida en varias instancias seguras, cada una con sus propios recursos dedicados. Esta característica permite un uso eficiente de los recursos de GPU entre varios usuarios o cargas de trabajo, maximizando la utilización y reduciendo los costos generales.
Acelerando la inferencia de LLM con NVIDIA TensorRT
Si bien las GPUs han sido fundamentales para entrenar LLM, la inferencia eficiente es igualmente crucial para implementar estos modelos en entornos de producción. NVIDIA TensorRT, un optimizador y tiempo de ejecución de inferencia de aprendizaje profundo de alto rendimiento, desempeña un papel vital en la aceleración de la inferencia de LLM en GPUs compatibles con CUDA.
Según las pruebas 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 grande como GPT-3.
El compromiso de NVIDIA con las iniciativas de código abierto ha sido una fuerza impulsora detrás 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 investigadores y desarrolladores aprovechar al máximo el potencial de CUDA para su aprendizaje profundo.
Instalación
Al configurar el desarrollo de IA, usar los controladores y bibliotecas más recientes no siempre es la mejor opción. Por ejemplo, aunque el controlador de NVIDIA más reciente (545.xx) admite CUDA 12.3, PyTorch y otras bibliotecas pueden no admitir aún esta versión. Por lo tanto, usaremos la versión del controlador 535.146.02 con CUDA 12.2 para garantizar la compatibilidad.
Pasos de instalación
1. Instalar controlador de NVIDIA
Primero, identifique su modelo de GPU. Para esta guía, usamos la GPU de NVIDIA. Visite la página de descarga de controladores de NVIDIA, seleccione el controlador adecuado para su GPU y anote la versión del controlador.
Para verificar los paquetes de GPU precompilados en Ubuntu, ejecute:
sudo ubuntu-drivers list --gpgpu
Reinicie su computadora y verifique la instalación:
nvidia-smi
2. Instalar la herramienta de desarrollo de CUDA
La herramienta de desarrollo de CUDA proporciona el entorno de desarrollo para crear aplicaciones aceleradas por GPU de alto rendimiento.
Para una configuración que no sea de LLM/aprendizaje profundo, puede usar:
sudo apt install nvidia-cuda-toolkit <p>Sin embargo, para garantizar la compatibilidad con BitsAndBytes, seguiremos estos pasos:</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>
Verifique la instalación:
~/local/cuda-12.2/bin/nvcc --version
Establezca las variables de entorno:
<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. Instalar cuDNN
Descargue el paquete de cuDNN desde el sitio web de desarrolladores de NVIDIA. Instálelo con:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Siga las instrucciones para agregar el keyring:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Instale las bibliotecas de cuDNN:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Configurar entorno virtual de Python
Ubuntu 22.04 viene con Python 3.10. Instale venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Cree y active el entorno virtual:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Instalar BitsAndBytes desde el código fuente
Navegue hasta el directorio de BitsAndBytes y compile desde el código fuente:
<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. Instalar PyTorch
Instale PyTorch con el siguiente comando:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Instalar Hugging y Transformers
Instale las bibliotecas de transformers y accelerate:
<p>pip install transformers pip install accelerate</p>
El poder del procesamiento paralelo
En su núcleo, las GPUs son procesadores paralelos de alta velocidad diseñados para manejar miles de hilos concurrentes de manera eficiente. Esta arquitectura las hace adecuadas 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 al máximo el potencial de estas GPUs, lo que les permite escribir código que pueda aprovechar las capacidades de procesamiento paralelo del hardware.
Acelerando el entrenamiento de LLM con GPUs y CUDA.
Entrenar modelos de lenguaje grande es una tarea computacionalmente exigente que requiere procesar grandes cantidades de datos de texto y realizar numerosas operaciones de matrices. Las GPUs, con sus miles de núcleos y alta ancho de banda de memoria, están idealmente adaptadas para estas tareas. Al aprovechar CUDA, los desarrolladores pueden optimizar su código para aprovechar las capacidades de procesamiento paralelo de las GPUs, reduciendo significativamente el tiempo necesario para entrenar LLM.
Por ejemplo, el entrenamiento de GPT-3, uno de los modelos de lenguaje más grandes hasta la fecha, se hizo posible mediante el uso de miles de GPUs de NVIDIA que ejecutan código optimizado por CUDA. Esto permitió que el modelo se entrenara en una cantidad sin precedentes de datos, lo que llevó a su impresionante rendimiento en tareas de lenguaje natural.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Cargue el modelo GPT-2 preentrenado y el tokenizador
modelo = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizador = GPT2Tokenizer.from_pretrained('gpt2')</p>
<p># Mueva el modelo a la GPU si está disponible
dispositivo = torch.device("cuda" if torch.cuda.is_available() else "cpu")
modelo = modelo.to(dispositivo)</p>
<p># Defina los datos de entrenamiento y los hiperparámetros
datos_de_entrenamiento = [...] # Sus datos de entrenamiento
tamaño_de_lote = 32
num_epochs = 10
tasa_de_aprendizaje = 5e-5</p>
<p># Defina la función de pérdida y el optimizador
criterio = nn.CrossEntropyLoss()
optimizador = optim.Adam(modelo.parameters(), lr=tasa_de_aprendizaje)</p>
<p># Bucle de entrenamiento
for epoch in range(num_epochs):
for i in range(0, len(datos_de_entrenamiento), tamaño_de_lote):
# Prepare las secuencias de entrada y objetivo
entradas, objetivos = datos_de_entrenamiento[i:i+tamaño_de_lote]
entradas = tokenizador(entradas, return_tensors="pt", padding=True)
entradas = entradas.to(dispositivo)
objetivos = objetivos.to(dispositivo)</p>
<p># Paso hacia adelante
salidas = modelo(**entradas, labels=objetivos)
pérdida = salidas.loss</p>
<p># Paso hacia atrás y optimización
optimizador.zero_grad()
pérdida.backward()
optimizador.step()</p>
<p>print(f'Epoch {epoch+1}/{num_epochs}, Loss: {pérdida.item()}')</p>
En este ejemplo de código, demostramos el entrenamiento de un modelo de lenguaje GPT-2 utilizando PyTorch y las GPUs compatibles con CUDA. El modelo se carga en la GPU (si está disponible), y el bucle de entrenamiento aprovecha el paralelismo de las GPUs para realizar pasos hacia adelante y hacia atrás de manera eficiente, acelerando el proceso de entrenamiento.
Bibliotecas de aprendizaje profundo aceleradas por CUDA
Además de la plataforma CUDA en sí, NVIDIA y la comunidad de código abierto han desarrollado una serie 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 entrenamiento en lugar de la optimización de bajo nivel.
Una de estas bibliotecas es cuDNN (biblioteca de redes neuronales profundas de CUDA), 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.
<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>
En este ejemplo de código, definimos un bloque residual para una red neuronal convolucional (CNN) utilizando PyTorch. El administrador de contexto de autocast de PyTorch se utiliza para habilitar el entrenamiento de precisión mixta, lo que puede proporcionar ganancias de rendimiento significativas en las GPUs compatibles con CUDA mientras se mantiene una alta precisión. La función F.relu se optimiza mediante cuDNN, lo que garantiza una ejecución eficiente en las GPUs.
Entrenamiento distribuido y multi-GPU para escalabilidad
A medida que los LLM y los modelos de aprendizaje profundo continúan creciendo en tamaño y complejidad, los requisitos computacionales para entrenar estos modelos también aumentan. Para abordar este desafío, los investigadores y desarrolladores han recurrido a técnicas de entrenamiento distribuido y multi-GPU, lo que les permite aprovechar el poder de procesamiento combinado de múltiples GPUs en varias máquinas.
CUDA y bibliotecas asociadas, como NCCL (biblioteca de comunicaciones colectivas de NVIDIA), proporcionan primitivas de comunicación eficientes que permiten la transferencia de datos y la sincronización sin problemas en varias GPUs, lo que permite el entrenamiento distribuido a una escala sin precedentes.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Inicialice el entrenamiento distribuido dist.init_process_group(backend='nccl', init_method='...') local_rank = dist.get_rank() torch.cuda.set_device(local_rank)</p> <p># Cree el modelo y muévalo a la GPU modelo = MyModel().cuda()</p> <p># Envuelva el modelo con DDP modelo = DDP(modelo, device_ids=[local_rank])</p> <p># Bucle de entrenamiento (distribuido) for epoch in range(num_epochs): for data in train_loader: entradas, objetivos = data entradas = entradas.cuda(non_blocking=True) objetivos = objetivos.cuda(non_blocking=True)</p> <p>salidas = modelo(entradas) pérdida = criterio(salidas, objetivos)</p> <p>optimizador.zero_grad() pérdida.backward() optimizador.step()</p>
En este ejemplo, demostramos el entrenamiento distribuido utilizando el módulo DistributedDataParallel (DDP) de PyTorch. El modelo se envuelve en DDP, que maneja automáticamente la paralelización de datos, la sincronización de gradientes y la comunicación en varias GPUs utilizando NCCL. Este enfoque permite escalar eficientemente el proceso de entrenamiento en varias máquinas, lo que permite a los 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 GPUs y CUDA se han utilizado principalmente para entrenar modelos de aprendizaje profundo, también son fundamentales para la implementación y la inferencia eficientes. A medida que los modelos de aprendizaje profundo se vuelven cada vez más complejos y exigentes en términos de recursos, la aceleración de la GPU es esencial para lograr un rendimiento en tiempo real en entornos de producción.
La tecnología TensorRT de NVIDIA es un optimizador y tiempo de ejecución de inferencia de aprendizaje profundo de alto rendimiento que proporciona bajo retraso y alto rendimiento en la inferencia en GPUs compatibles con CUDA. TensorRT puede optimizar y acelerar modelos entrenados en marcos como TensorFlow, PyTorch y MXNet, lo que permite la implementación eficiente en varias plataformas, desde sistemas integrados hasta centros de datos.
import tensorrt as trt <p># Cargue el modelo preentrenado modelo = load_model(...)</p> <p># Cree el motor de TensorRT logger = trt.Logger(trt.Logger.INFO) constructor = trt.Builder(logger) red = constructor.create_network() parser = trt.OnnxParser(red, logger)</p> <p># Analice y optimice el modelo éxito = parser.parse_from_file(model_path) motor = constructor.build_cuda_engine(red)</p> <p># Ejecute la inferencia en la GPU contexto = motor.create_execution_context() entradas, salidas, enlaces, flujo = allocate_buffers(motor)</p> <p># Establezca los datos de entrada y ejecute la inferencia set_input_data(entradas, input_data) contexto.execute_async_v2(enlaces=enlaces, stream_handle=flujo.ptr)</p> # Procese la salida # ...
En este ejemplo, demostramos el uso de TensorRT para implementar un modelo de aprendizaje profundo preentrenado en una GPU compatible con CUDA. El modelo se analiza y optimiza primero mediante TensorRT, que genera un motor de inferencia altamente optimizado adaptado para el modelo y el hardware específicos. Este motor se puede utilizar para realizar la inferencia eficiente en la GPU, aprovechando CUDA para la computación acelerada.
Conclusión
La combinación de GPUs y CUDA ha sido fundamental para impulsar los avances en los modelos de lenguaje grande, la visión por computadora, el reconocimiento de voz y varios otros dominios del aprendizaje profundo. Al aprovechar las capacidades de procesamiento paralelo de las GPUs y las bibliotecas optimizadas proporcionadas por CUDA, los investigadores y desarrolladores pueden entrenar y implementar modelos cada vez más complejos de manera eficiente.
A medida que el campo de la IA continúa evolucionando, la importancia de las GPUs y CUDA solo aumentará. Con hardware y optimizaciones de software aún más potentes, podemos esperar ver avances adicionales en el desarrollo y la implementación de sistemas de IA, lo que ampliará los límites de lo que es posible.
