Cài đặt Huấn luyện, Tinh chỉnh và Trình diễn của LLMs với NVIDIA GPUs và CUDA

Lĩnh vực trí tuệ nhân tạo (AI) đã chứng kiến những tiến bộ đáng kể trong những năm gần đây, và tại trung tâm của nó là sự kết hợp mạnh mẽ giữa đơn vị xử lý đồ họa (GPUs) và nền tảng tính toán song song.

Các mô hình như GPT, BERT, và gần đây hơn Llama, Mistral có khả năng hiểu và tạo ra văn bản giống con người với sự流暢 và nhất quán chưa từng có. Tuy nhiên, việc huấn luyện những mô hình này đòi hỏi lượng dữ liệu và tài nguyên tính toán khổng lồ, khiến GPUs và CUDA trở thành những công cụ không thể thiếu trong nỗ lực này.

Hướng dẫn toàn diện này sẽ hướng dẫn bạn qua quá trình cài đặt NVIDIA GPU trên Ubuntu, bao gồm việc cài đặt các thành phần phần mềm thiết yếu như trình điều khiển NVIDIA, CUDA Toolkit, cuDNN, PyTorch và nhiều hơn nữa.

Sự trỗi dậy của các khung AI tăng tốc bằng CUDA

Tính toán sâu tăng tốc bằng GPU đã được thúc đẩy bởi sự phát triển của các khung AI phổ biến tận dụng CUDA cho tính toán hiệu quả. Các khung như TensorFlow, PyTorch, và MXNet có hỗ trợ CUDA tích hợp, cho phép tích hợp tăng tốc GPU vào các đường ống học sâu một cách liền mạch.

Theo NVIDIA Data Center Deep Learning Product Performance Study, các mô hình học sâu tăng tốc bằng CUDA có thể đạt được hiệu suất nhanh hơn 100 lần so với các triển khai dựa trên CPU.

Công nghệ GPU Multi-Instance (MIG) của NVIDIA, được giới thiệu cùng với kiến trúc Ampere, cho phép một GPU đơn được phân vùng thành nhiều instance bảo mật, mỗi instance có tài nguyên riêng. Tính năng này cho phép chia sẻ tài nguyên GPU hiệu quả giữa nhiều người dùng hoặc tải trọng, tối đa hóa việc sử dụng và giảm chi phí tổng thể.

Tăng tốc Trình diễn LLM với NVIDIA TensorRT

Mặc dù GPUs đã được sử dụng để huấn luyện LLMs, nhưng trình diễn hiệu quả cũng quan trọng không kém để triển khai các mô hình này trong môi trường sản xuất. NVIDIA TensorRT, một trình tối ưu hóa và thời gian chạy học sâu hiệu suất cao, đóng vai trò quan trọng trong việc tăng tốc trình diễn LLM trên GPU được bật CUDA.

Theo các điểm chuẩn của NVIDIA, TensorRT có thể cung cấp hiệu suất trình diễn nhanh hơn 8 lần và chi phí sở hữu tổng thể thấp hơn 5 lần so với trình diễn dựa trên CPU cho các mô hình ngôn ngữ lớn như GPT-3.

Cam kết của NVIDIA đối với các sáng kiến mã nguồn mở đã là một lực đẩy mạnh mẽ đằng sau việc áp dụng rộng rãi CUDA trong cộng đồng nghiên cứu AI. Các dự án như cuDNN, cuBLAS, và NCCL có sẵn dưới dạng thư viện mã nguồn mở, cho phép các nhà nghiên cứu và nhà phát triển tận dụng toàn bộ tiềm năng của CUDA cho học sâu của họ.

Cài đặt

Khi thiết lập phát triển AI, sử dụng các trình điều khiển và thư viện mới nhất không phải lúc nào cũng là lựa chọn tốt nhất. Ví dụ, trong khi trình điều khiển NVIDIA mới nhất (545.xx) hỗ trợ CUDA 12.3, PyTorch và các thư viện khác có thể chưa hỗ trợ phiên bản này. Do đó, chúng tôi sẽ sử dụng trình điều khiển phiên bản 535.146.02 với CUDA 12.2 để đảm bảo tính tương thích.

Quy trình Cài đặt

1. Cài đặt Trình điều khiển NVIDIA

Đầu tiên, xác định mô hình GPU của bạn. Đối với hướng dẫn này, chúng tôi sử dụng GPU của NVIDIA. Truy cập Trang tải xuống trình điều khiển NVIDIA, chọn trình điều khiển phù hợp cho GPU của bạn và lưu ý phiên bản trình điều khiển.

Để kiểm tra các gói GPU được xây dựng trước trên Ubuntu, chạy:

sudo ubuntu-drivers list --gpgpu

Khởi động lại máy tính và xác minh cài đặt:

nvidia-smi

2. Cài đặt CUDA Toolkit

CUDA Toolkit cung cấp môi trường phát triển để tạo các ứng dụng tăng tốc GPU hiệu suất cao.

Đối với một thiết lập không phải LLM/học sâu, bạn có thể sử dụng:

sudo apt install nvidia-cuda-toolkit

Tuy nhiên, để đảm bảo tính tương thích với BitsAndBytes, chúng tôi sẽ thực hiện theo các bước sau:

[code language="BASH"]

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

Xác minh cài đặt:

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

Thiết lập biến môi trường:

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. Cài đặt cuDNN

Tải xuống gói cuDNN từ Trang web phát triển NVIDIA. Cài đặt nó với:

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

Theo dõi các hướng dẫn để thêm keyring:

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

Cài đặt các thư viện cuDNN:

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

4. Thiết lập Môi trường ảo Python

Ubuntu 22.04 đi kèm với Python 3.10. Cài đặt venv:

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

Tạo và kích hoạt môi trường ảo:

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

5. Cài đặt BitsAndBytes từ Nguồn

Điều hướng đến thư mục BitsAndBytes và xây dựng từ nguồn:

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. Cài đặt PyTorch

Cài đặt PyTorch với lệnh sau:

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

7. Cài đặt Hugging Face và Transformers

Cài đặt các thư viện transformers và accelerate:

pip install transformers
pip install accelerate

Sức mạnh của Xử lý Song song

Tại cốt lõi, GPUs là các bộ xử lý song song cao được thiết kế để xử lý hàng nghìn luồng đồng thời một cách hiệu quả. Kiến trúc này làm cho chúng phù hợp với các nhiệm vụ tính toán đòi hỏi cao liên quan đến việc huấn luyện các mô hình học sâu, bao gồm LLMs. Nền tảng CUDA, được phát triển bởi NVIDIA, cung cấp một môi trường phần mềm cho phép các nhà phát triển tận dụng toàn bộ tiềm năng của những GPU này, cho phép họ viết mã có thể tận dụng khả năng xử lý song song của phần cứng.
Tăng tốc huấn luyện LLM với GPUs và CUDA.

Huấn luyện các mô hình ngôn ngữ lớn là một nhiệm vụ đòi hỏi tính toán cao, đòi hỏi phải xử lý lượng lớn dữ liệu văn bản và thực hiện nhiều phép toán ma trận. GPUs, với hàng nghìn lõi và băng thông nhớ cao, lý tưởng cho những nhiệm vụ này. Bằng cách tận dụng CUDA, các nhà phát triển có thể tối ưu hóa mã của mình để tận dụng khả năng xử lý song song của GPUs, giảm đáng kể thời gian cần thiết để huấn luyện LLMs.

Ví dụ, việc huấn luyện GPT-3, một trong những mô hình ngôn ngữ lớn nhất cho đến nay, đã được thực hiện thông qua việc sử dụng hàng nghìn GPU của NVIDIA chạy mã được tối ưu hóa bởi CUDA. Điều này cho phép mô hình được huấn luyện trên một lượng dữ liệu chưa từng có, dẫn đến hiệu suất ấn tượng trong các nhiệm vụ ngôn ngữ tự nhiên.

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

# Tải mô hình GPT-2 và bộ mã hóa được huấn luyện trước
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Di chuyển mô hình đến GPU nếu có sẵn
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Định nghĩa dữ liệu huấn luyện và siêu tham số
train_data = [...] # Dữ liệu huấn luyện của bạn
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Định nghĩa hàm mất mát và bộ tối ưu hóa
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Vòng lặp huấn luyện
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Chuẩn bị dữ liệu đầu vào và mục tiêu
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
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward và tối ưu hóa
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

Trong đoạn mã này, chúng tôi trình diễn việc huấn luyện mô hình ngôn ngữ GPT-2 bằng PyTorch và GPU được bật CUDA. Mô hình được tải lên GPU (nếu có sẵn), và vòng lặp huấn luyện tận dụng song song của GPU để thực hiện forward và backward pass một cách hiệu quả, tăng tốc quá trình huấn luyện.

Thư viện CUDA Tăng tốc cho Học sâu

Ngoài nền tảng CUDA itself, NVIDIA và cộng đồng mã nguồn mở đã phát triển một loạt các thư viện CUDA tăng tốc cho phép thực hiện hiệu quả các mô hình học sâu, bao gồm LLMs. Những thư viện này cung cấp các thực hiện tối ưu hóa của các hoạt động phổ biến, như nhân ma trận, tích chập và hàm kích hoạt, cho phép các nhà phát triển tập trung vào kiến trúc mô hình và quá trình huấn luyện thay vì tối ưu hóa cấp thấp.

Một trong những thư viện như vậy là cuDNN (CUDA Deep Neural Network library), cung cấp các thực hiện tối ưu hóa của các thói quen chuẩn được sử dụng trong mạng nơ-ron sâu. Bằng cách tận dụng cuDNN, các nhà phát triển có thể tăng tốc đáng kể quá trình huấn luyện và trình diễn của mô hình, đạt được hiệu suất nhanh hơn hàng trăm lần so với các triển khai dựa trên 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

Trong đoạn mã này, chúng tôi định nghĩa một khối dư cho mạng nơ-ron tích chập (CNN) bằng PyTorch. Trình quản lý ngữ cảnh autocast từ PyTorch’s Automatic Mixed Precision (AMP) được sử dụng để bật huấn luyện hỗn hợp, có thể cung cấp lợi ích hiệu suất đáng kể trên GPU được bật CUDA trong khi vẫn duy trì độ chính xác cao. Hàm F.relu được tối ưu hóa bởi cuDNN, đảm bảo thực hiện hiệu quả trên GPU.

Đa GPU và Huấn luyện Phân tán cho Khả năng Mở rộng

Khi các mô hình LLM và học sâu tiếp tục phát triển về kích thước và độ phức tạp, nhu cầu tính toán để huấn luyện những mô hình này cũng tăng lên. Để giải quyết thách thức này, các nhà nghiên cứu và nhà phát triển đã chuyển sang các kỹ thuật huấn luyện đa GPU và phân tán, cho phép họ tận dụng sức mạnh tính toán kết hợp của nhiều GPU trên nhiều máy.

CUDA và các thư viện liên quan, như NCCL (NVIDIA Collective Communications Library), cung cấp các nguyên thủy giao tiếp hiệu quả cho phép chuyển dữ liệu và đồng bộ hóa mượt mà trên nhiều GPU, cho phép huấn luyện phân tán ở quy mô chưa từng có.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Khởi tạo huấn luyện phân tán
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Tạo mô hình và di chuyển đến GPU
model = MyModel().cuda()

# quấn mô hình với DDP
model = DDP(model, device_ids=[local_rank])

# Vòng lặp huấn luyện (phân tán)
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()

Trong đoạn mã này, chúng tôi trình diễn huấn luyện phân tán bằng PyTorch’s DistributedDataParallel (DDP) module. Mô hình được quấn trong DDP, tự động xử lý song song dữ liệu, đồng bộ hóa gradient và giao tiếp trên nhiều GPU bằng NCCL. Cách tiếp cận này cho phép mở rộng quy mô quá trình huấn luyện trên nhiều máy, cho phép các nhà nghiên cứu và nhà phát triển huấn luyện các mô hình lớn và phức tạp hơn trong một khoảng thời gian hợp lý.

Triển khai Mô hình Học sâu với CUDA

Mặc dù GPUs và CUDA chủ yếu được sử dụng để huấn luyện mô hình học sâu, chúng cũng quan trọng không kém để triển khai và trình diễn hiệu quả. Khi các mô hình học sâu trở nên phức tạp và đòi hỏi nhiều tài nguyên hơn, tăng tốc GPU là thiết yếu để đạt được hiệu suất thời gian thực trong môi trường sản xuất.

NVIDIA’s TensorRT là một trình tối ưu hóa và thời gian chạy học sâu hiệu suất cao, cung cấp thời gian trả lời thấp và băng thông cao cho trình diễn trên GPU được bật CUDA. TensorRT có thể tối ưu hóa và tăng tốc các mô hình được huấn luyện trong các khung như TensorFlow, PyTorch và MXNet, cho phép triển khai hiệu quả trên nhiều nền tảng, từ hệ thống nhúng đến trung tâm dữ liệu.

import tensorrt as trt

# Tải mô hình được huấn luyện trước
model = load_model(...)

# Tạo động cơ TensorRT
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Phân tích và tối ưu hóa mô hình
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Chạy trình diễn trên GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Thiết lập dữ liệu đầu vào và chạy trình diễn
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Xử lý đầu ra
# ...

Trong đoạn mã này, chúng tôi trình diễn việc sử dụng TensorRT để triển khai mô hình học sâu được huấn luyện trước trên GPU được bật CUDA. Mô hình được phân tích và tối ưu hóa bởi TensorRT, tạo ra một động cơ tăng tốc cao được tùy chỉnh cho mô hình và phần cứng cụ thể. Động cơ này sau đó có thể được sử dụng để thực hiện trình diễn hiệu quả trên GPU, tận dụng CUDA cho tính toán tăng tốc.

Kết luận

Sự kết hợp giữa GPUs và CUDA đã đóng vai trò quan trọng trong việc thúc đẩy sự tiến bộ của các mô hình ngôn ngữ lớn, tầm nhìn máy tính, nhận dạng giọng nói và nhiều lĩnh vực khác của học sâu. Bằng cách tận dụng khả năng xử lý song song của GPUs và các thư viện được tối ưu hóa bởi CUDA, các nhà nghiên cứu và nhà phát triển có thể huấn luyện và triển khai các mô hình ngày càng phức tạp với hiệu suất cao.

Khi lĩnh vực AI tiếp tục phát triển, tầm quan trọng của GPUs và CUDA sẽ chỉ tăng lên. Với phần cứng và tối ưu hóa phần mềm mạnh mẽ hơn, chúng ta có thể mong đợi thấy những đột phá hơn nữa trong việc phát triển và triển khai các hệ thống AI, đẩy ranh giới của những gì có thể.