Cài đặt Huấn luyện, Tinh chỉnh và Trộn của LLM với GPU NVIDIA 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 (GPU) và nền tảng tính toán song song.

Mô hình như GPT, BERT, và gần đây Llama, Mistral có khả năng hiểu và tạo ra văn bản giống con người với sự thông thạo 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 lớn dữ liệu và tài nguyên tính toán, khiến GPU và CUDA trở thành những công cụ không thể thiếu trong lĩnh vự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 GPU NVIDIA (NVDA ) trên Ubuntu, bao gồm 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, Bộ công cụ CUDA, 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ởi CUDA

Tính toán học sâu tăng tốc bởi 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ợ tích hợp cho CUDA, cho phép tích hợp liền mạch tăng tốc GPU vào các đường ống học sâu.

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

Công nghệ Multi-Instance GPU (MIG) của NVIDIA, được giới thiệu với kiến trúc Ampere, cho phép một GPU duy nhất được phân vùng thành nhiều实 thể bảo mật, mỗi thực thể 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 công việc, tối đa hóa sử dụng và giảm chi phí tổng thể.

Tăng tốc Trộn LLM với NVIDIA TensorRT

Trong khi GPU đã đóng vai trò quan trọng trong việc huấn luyện LLM, thì việc trộ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 bộ tối ưu hóa và chạy inference học sâu hiệu suất cao, đóng vai trò quan trọng trong việc tăng tốc trộn LLM trên GPU được kích hoạt bởi CUDA.

Theo các điểm chuẩn của NVIDIA, TensorRT có thể cung cấp hiệu suất trộn nhanh hơn tới 8 lần và chi phí sở hữu tổng thể thấp hơn 5 lần so với trộ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 với các sáng kiến mã nguồn mở đã là một lực đẩy quan trọng đằng sau sự áp dụng rộng rãi của 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à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.

Các bước Cài đặt

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

Trước 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 NVIDIA. Truy cập trang tải 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 prebuilt 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 Bộ công cụ CUDA

Bộ công cụ CUDA cung cấp môi trường phát triển cho việc tạo ra 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

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

[code language=&amp;quot;BASH&amp;quot;]

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

Xác minh cài đặt:

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

Đặt biến môi trường:

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

Tải xuống gói cuDNN từ trang web NVIDIA Developer. Cài đặt nó với:

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

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

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

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

<p>sudo apt update
sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>

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:

<p>sudo apt-get install python3-pip
sudo apt install python3.10-venv</p>

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

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

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

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

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

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

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

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

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

<p>pip install transformers
pip install accelerate</p>

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

Tại cốt lõi, GPU 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 cả LLM. 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 GPU và CUDA.

Huấn luyện các mô hình ngôn ngữ lớn là một nhiệm vụ tính toán đòi hỏi 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. GPU, 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 họ để tận dụng khả năng xử lý song song của GPU, giảm đáng kể thời gian cần thiết để huấn luyện LLM.

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 có thể thông qua việc sử dụng hàng nghìn GPU 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.

<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>

<p># Tải mô hình GPT-2 đã được huấn luyện trước và bộ phân tích cú pháp
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')</p>

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

<p># Đị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</p>

<p># Đị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)</p>

<p># 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ị chuỗi đầ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)</p>

<p># Chuyển tiếp
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>

<p># Lùi và tối ưu hóa
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

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

Trong đoạn mã này, chúng tôi trình diễn việc huấn luyện một mô hình ngôn ngữ GPT-2 bằng PyTorch và GPU được kích hoạt bởi 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 chuyển tiếp và lùi 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 chính, NVIDIA và cộng đồng mã nguồn mở đã phát triển một loạt các thư viện tăng tốc bởi CUDA, cho phép thực hiện hiệu quả các mô hình học sâu, bao gồm cả LLM. Những thư viện này cung cấp các thực hiện được tối ưu hóa của các phép toán chung, 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 (Thư viện Mạng Nơ-ron Sâu CUDA), cung cấp các thực hiện được điều chỉnh cao của các chương trình thông thường đượ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ể việc huấn luyện và trộn của mô hình, đạt được lợi ích hiệu suất lên đến vài cấp độ so với các triển khai dựa trên 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>

Trong đoạn mã này, chúng tôi định nghĩa một khối dư cho một 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 để kích hoạ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 kích hoạt bởi CUDA. 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.

Huấn luyện Phân tán và Multi-GPU 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 phân tán và multi-GPU, cho phép họ tận dụng sức mạnh xử lý 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 (Thư viện Truyền thông Tập thể NVIDIA), cung cấp các nguyên thủy truyền thông 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ó.

</pre>
import torch.distributed as dist

<p>from torch.nn.parallel import DistributedDataParallel as DDP</p>

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

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

<p># Gói mô hình với DDP
model = DDP(model, device_ids=[local_rank])</p>

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

<p>outputs = model(inputs)
loss = criterion(outputs, targets)</p>

<p>optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

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 gói trong DDP, tự động xử lý song song dữ liệu, đồng bộ hóa gradient và truyền thông trên nhiều GPU bằng NCCL. Cách tiếp cận này cho phép mở rộng hiệu quả 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ù GPU và CUDA chủ yếu được sử dụng cho việc huấn luyện mô hình học sâu, chúng cũng quan trọng cho việc triển khai và trộ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à điều cần thiết để đạ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 bộ tối ưu hóa và chạy inference học sâu hiệu suất cao, cung cấp hiệu suất thấp và hiệu suất cao trên GPU được kích hoạt bởi 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 các nền tảng, từ hệ thống nhúng đến trung tâm dữ liệu.

import tensorrt as trt

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

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

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

<p># Chạy inference trên GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)</p>

<p># Thiết lập dữ liệu đầu vào và chạy inference
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p>

# 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ột mô hình học sâu đã được huấn luyện trước trên GPU được kích hoạt bởi 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ơ inference được tối ưu hóa cao cho mô hình và phần cứng cụ thể. Động cơ này có thể được sử dụng để thực hiện inference 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 GPU và CUDA đã đóng vai trò quan trọng trong việc thúc đẩy các tiến bộ trong các mô hình ngôn ngữ lớn, thị giác 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 GPU 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 GPU 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 sẽ 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ể.