使用NVIDIA GPU和CUDA设置LLM的训练、微调和推理

人工智能（AI）领域在近年来取得了显著的进步，其核心是图形处理器（GPU）和并行计算平台的强大组合。

像GPT、BERT和最近的Llama、Mistral等模型能够以前所未有的流畅度和连贯性理解和生成类似人类的文本。然而，训练这些模型需要大量的数据和计算资源，使得GPU和CUDA成为这一事业中不可或缺的工具。

本综合指南将指导您完成在Ubuntu上设置NVIDIA GPU的过程，包括安装必要的软件组件，如NVIDIA驱动程序、CUDA Toolkit、cuDNN、PyTorch等。

CUDA加速的AI框架的崛起

GPU加速的深度学习得到了流行的AI框架的推动，这些框架利用CUDA进行高效的计算。像TensorFlow、PyTorch和MXNet这样的框架都内置了对CUDA的支持，实现了GPU加速在深度学习管道中的无缝集成。

根据NVIDIA数据中心深度学习产品性能研究，CUDA加速的深度学习模型可以比基于CPU的实现快100倍。

NVIDIA的多实例GPU（MIG）技术是在安培架构中引入的，允许单个GPU被分区为多个安全实例，每个实例都有其自己的专用资源。这一功能使得GPU资源在多个用户或工作负载之间可以高效共享，最大限度地提高了利用率并降低了总成本。

使用NVIDIA TensorRT加速LLM推理

虽然GPU在训练LLM方面发挥了重要作用，但高效的推理对于在生产环境中部署这些模型也同样至关重要。NVIDIA TensorRT是一种高性能的深度学习推理优化器和运行时，在CUDA启用的GPU上发挥着至关重要的作用。

根据NVIDIA的基准测试，TensorRT可以提供最高8倍的推理性能和5倍的总拥有成本降低，相比CPU基于的推理对于像GPT-3这样的大型语言模型。

NVIDIA致力于开源计划一直是AI研究社区广泛采用CUDA的驱动力。像cuDNN、cuBLAS和NCCL这样的项目作为开源库提供，允许研究人员和开发人员利用CUDA的全部潜力来实现他们的深度学习目标。

安装

当设置AI开发环境时，使用最新的驱动程序和库并不总是最佳选择。例如，虽然最新的NVIDIA驱动程序（545.xx）支持CUDA 12.3，但PyTorch和其他库可能还不支持此版本。因此，我们将使用驱动程序版本535.146.02和CUDA 12.2，以确保兼容性。

安装步骤

1. 安装NVIDIA驱动程序

首先，识别您的GPU型号。对于本指南，我们使用NVIDIA GPU。访问NVIDIA驱动程序下载页面，选择适合您的GPU的驱动程序，并记下驱动程序版本。

在Ubuntu上检查预构建的GPU包:

sudo ubuntu-drivers list --gpgpu

重启计算机并验证安装:

nvidia-smi

2. 安装CUDA Toolkit

CUDA Toolkit提供了创建高性能GPU加速应用程序的开发环境。

对于非LLM/深度学习设置，您可以使用：

sudo apt install nvidia-cuda-toolkit

但是，为了确保与BitsAndBytes的兼容性，我们将按照以下步骤进行：

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

验证安装:

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

设置环境变量:

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. 安装cuDNN

从NVIDIA开发者网站下载cuDNN包，并使用以下命令安装：

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

按照以下步骤添加密钥环:

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

安装cuDNN库:

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

4. 设置Python虚拟环境

Ubuntu 22.04附带Python 3.10。安装venv：

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

创建和激活虚拟环境:

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

5. 从源代码安装BitsAndBytes

导航到BitsAndBytes目录并从源代码构建：

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. 安装PyTorch

使用以下命令安装PyTorch：

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

7. 安装Hugging Face和Transformers

安装transformers和accelerate库：

pip install transformers
pip install accelerate

并行处理的力量

在其核心，GPU是高度并行的处理器，能够高效地处理数千个并发线程。这一架构使得它们非常适合深度学习模型（包括LLM）中计算密集型的任务。CUDA平台由NVIDIA开发，提供了一个软件环境，允许开发人员利用GPU的全部潜力，实现能够利用硬件并行处理能力的代码。

加速LLM训练与GPU和CUDA。

训练大型语言模型是一项计算密集型的任务，需要处理大量的文本数据并执行众多的矩阵运算。GPU拥有数千个核心和高内存带宽，非常适合这些任务。通过利用CUDA，开发人员可以优化代码以利用GPU的并行处理能力，从而大大减少训练LLM所需的时间。

例如，训练GPT-3（迄今为止最大的语言模型之一）是通过使用成千上万个NVIDIA GPU运行CUDA优化的代码来实现的。这使得模型能够在前所未有的数据量上进行训练，从而实现了其在自然语言任务中的令人印象深刻的性能。

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

# 加载预训练的GPT-2模型和分词器
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# 将模型移到GPU（如果可用）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# 定义训练数据和超参数
train_data = [...] # 您的训练数据
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练循环
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# 准备输入和目标序列
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# 前向传递
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# 后向传递和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

在这个示例代码片段中，我们演示了使用PyTorch和CUDA启用的GPU训练GPT-2语言模型。模型加载到GPU（如果可用），训练循环利用GPU的并行性执行高效的前向和后向传递，加速训练过程。

CUDA加速的深度学习库

除了CUDA平台本身，NVIDIA和开源社区还开发了一系列CUDA加速的库，用于高效实现深度学习模型，包括LLM。这些库提供了优化的标准例程实现，例如矩阵乘法、卷积和激活函数，允许开发人员专注于模型架构和训练过程，而不是低级优化。

一个这样的库是cuDNN（CUDA深度神经网络库），它提供了深度神经网络中使用的标准例程的高度优化的实现。通过利用cuDNN，开发人员可以显著加速他们的模型的训练和推理，实现与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

在这个代码片段中，我们使用PyTorch定义了一个残差块，用于卷积神经网络（CNN）。PyTorch的Automatic Mixed Precision（AMP）中的autocast上下文管理器用于启用混合精度训练，这可以在CUDA启用的GPU上提供显著的性能提升，同时保持高精度。F.relu函数由cuDNN优化，确保在GPU上高效执行。

多GPU和分布式训练用于可扩展性

随着LLM和深度学习模型的大小和复杂性不断增长，训练这些模型的计算需求也增加了。为了解决这个挑战，研究人员和开发人员转向了多GPU和分布式训练技术，这使得他们能够利用多个GPU和多台机器的综合处理能力。

CUDA和相关库（如NCCL（NVIDIA Collective Communications Library））提供了高效的通信原语，实现了多个GPU之间的无缝数据传输和同步，实现了前所未有的分布式训练规模。

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# 初始化分布式训练
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# 创建模型并移到GPU
model = MyModel().cuda()

# 用DDP包装模型
model = DDP(model, device_ids=[local_rank])

# 分布式训练循环
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()

在这个示例中，我们使用PyTorch的DistributedDataParallel（DDP）模块演示了分布式训练。模型用DDP包装，DDP自动处理数据并行、梯度同步和使用NCCL的多个GPU之间的通信。这一方法实现了训练过程在多台机器上的高效扩展，使得研究人员和开发人员能够在合理的时间内训练更大、更复杂的模型。

使用CUDA部署深度学习模型

虽然GPU和CUDA主要用于训练深度学习模型，但它们对于高效的部署和推理也至关重要。随着深度学习模型变得越来越复杂和资源密集，GPU加速对于实现生产环境中的实时性能至关重要。

NVIDIA的TensorRT是一种高性能的深度学习推理优化器和运行时，提供了CUDA启用的GPU上的低延迟和高吞吐量的推理。TensorRT可以优化和加速在TensorFlow、PyTorch和MXNet等框架中训练的模型，使得能够在从嵌入式系统到数据中心的各种平台上高效部署。

import tensorrt as trt

# 加载预训练模型
model = load_model(...)

# 创建TensorRT引擎
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# 解析和优化模型
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# 在GPU上运行推理
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# 设置输入数据并运行推理
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# 处理输出
# ...

在这个示例中，我们演示了使用TensorRT在CUDA启用的GPU上部署预训练的深度学习模型。模型首先由TensorRT解析和优化，生成一个针对特定模型和硬件的高度优化的推理引擎。然后可以使用此引擎在GPU上高效地执行推理，利用CUDA进行加速计算。

结论

GPU和CUDA的组合在推动大型语言模型、计算机视觉、语音识别和深度学习的各个领域的进步方面发挥了重要作用。通过利用GPU的并行处理能力和CUDA提供的优化库，研究人员和开发人员可以高效地训练和部署越来越复杂的模型。

随着AI领域的不断发展，GPU和CUDA的重要性将会进一步增长。拥有更强大的硬件和软件优化，我们可以期待在AI系统的开发和部署方面看到进一步的突破，推动着可能性的边界。