การตั้งค่าการฝึกอบรม การปรับให้เหมาะสม และการอนุมานของ LLMs โดยใช้ NVIDIA GPUs และ CUDA

สาขาหนึ่งของปัญญาประดิษฐ์ (AI) ได้เห็นการพัฒนาที่น่าประทับใจในช่วงไม่กี่ปีที่ผ่านมา และที่ใจกลางของสิ่งนี้คือการรวมกันที่ทรงพลังของหน่วยประมวลผลกราฟฟิก (GPUs) และแพลตฟอร์มการประมวลผลขนาน

โมเดล เช่น GPT, BERT, และ最近 Llama, Mistral มีความสามารถในการเข้าใจและสร้างข้อความที่เหมือนมนุษย์พร้อมความชำนาญและความสอดคล้องที่ไม่เคยเห็นมาก่อน อย่างไรก็ตาม การฝึกอบรมโมเดลเหล่านี้ต้องใช้ข้อมูลและทรัพยากรการประมวลผลจำนวนมาก ทำให้ GPU และ CUDA เป็นเครื่องมือที่จำเป็นในความพยายามนี้

คู่มือที่ครอบคลุมนี้จะพาคุณผ่านกระบวนการติดตั้ง NVIDIA GPU บน Ubuntu โดยครอบคลุมถึงการติดตั้งซอฟต์แวร์หลักๆ เช่น ไดรเวอร์ NVIDIA, CUDA Toolkit, cuDNN, PyTorch และอื่นๆ

การเพิ่มขึ้นของ CUDA-Accelerated AI Frameworks

การเรียนรู้เชิงลึกที่เร่งด้วย GPU ได้รับการขับเคลื่อนโดยการพัฒนาเฟรมเวิร์ก AI ที่ได้รับความนิยมซึ่งใช้ CUDA สำหรับการคำนวณที่มีประสิทธิภาพ เฟรมเวิร์ก เช่น TensorFlow, PyTorch, และ MXNet มีการสนับสนุน CUDA ที่มีประสิทธิภาพ ซึ่งทำให้สามารถรวมการเร่งความเร็ว GPU เข้ากับพายพันการเรียนรู้เชิงลึกได้อย่างราบรื่น

ตาม NVIDIA Data Center Deep Learning Product Performance Study, โมเดลการเรียนรู้เชิงลึกที่เร่งด้วย CUDA สามารถบรรลุประสิทธิภาพที่เร็วขึ้น 100 เท่าเมื่อเทียบกับการใช้ CPU

เทคโนโลยี Multi-Instance GPU (MIG) ของ NVIDIA ซึ่งแนะนำพร้อมกับโครงสร้าง Ampere ช่วยให้สามารถแบ่ง GPU หนึ่งอันเป็นหลายอินสแตนซ์ที่มีความปลอดภัย โดยแต่ละอินสแตนซ์มีทรัพยากรที่专 dụngของตนเอง คุณลักษณะนี้ช่วยให้สามารถใช้ทรัพยากร GPU ได้อย่างมีประสิทธิภาพระหว่างผู้ใช้หลายคนหรือเวิร์กโหลด ลดต้นทุนโดยรวม

การเร่งการอนุมาน LLM ด้วย NVIDIA TensorRT

ในขณะที่ GPU มีบทบาทสำคัญในการฝึกอบรม LLM การอนุมานที่มีประสิทธิภาพก็มีความสำคัญเช่นกันสำหรับการนำโมเดลเหล่านี้ไปใช้ในสภาพแวดล้อมการผลิต NVIDIA TensorRT ซึ่งเป็นเครื่องมือการอนุมานและการเร่งความเร็วการเรียนรู้เชิงลึกที่มีประสิทธิภาพสูง มีบทบาทสำคัญในการเร่งการอนุมาน LLM บน GPU ที่ใช้ CUDA

ตามที่ NVIDIA ระบุ TensorRT สามารถให้ประสิทธิภาพการอนุมานที่เร็วขึ้น 8 เท่าและต้นทุนรวมที่ลดลง 5 เท่าเมื่อเทียบกับการอนุมานโดยใช้ CPU สำหรับโมเดลภาษาขนาดใหญ่ เช่น GPT-3

ความมุ่งมั่นของ NVIDIA ต่อโครงการโอเพ่นซอร์สเป็นแรงผลักดันที่อยู่เบื้องหลังการนำ CUDA ไปใช้ในวงการวิจัย AI โครงการ เช่น 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 ของคุณ และบันทึกเวอร์ชันของไดรเวอร์

เพื่อตรวจสอบแพ็คเกจ GPU ที่สร้างไว้ล่วงหน้าบน Ubuntu ให้ใช้:

sudo ubuntu-drivers list --gpgpu

รีบูตคอมพิวเตอร์และตรวจสอบการติดตั้ง:

nvidia-smi

2. ติดตั้ง CUDA Toolkit

CUDA Toolkit ให้สภาพแวดล้อมการพัฒนาสำหรับการสร้างแอปพลิเคชันที่เร่งด้วย GPU

สำหรับการตั้งค่าที่ไม่ใช่ LLM/การเรียนรู้เชิงลึก คุณสามารถใช้:

sudo apt install nvidia-cuda-toolkit

อย่างไรก็ตาม เพื่อให้แน่ใจถึงความเข้ากันได้กับ BitsAndBytes เราจะทำตามขั้นตอนเหล่านี้:

[code language="BASH"]

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

ดาวน์โหลด แพ็คเกจ cuDNN จาก เว็บไซต์นักพัฒนา NVIDIA ติดตั้งโดยใช้:

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

ทำตามคำแนะนำเพื่อเพิ่ม keyring:

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 เป็นโปรเซสเซอร์ขนานที่มีประสิทธิภาพสูงซึ่งออกแบบมาเพื่อจัดการกับスレดที่มีการประมวลผลพร้อมกันหลายพันอย่างมีประสิทธิภาพ สถาปัตยกรรมนี้ทำให้พวกมันเหมาะสำหรับงานที่ต้องใช้การประมวลผลมากที่เกี่ยวข้องกับการฝึกโมเดลการเรียนรู้เชิงลึก รวมถึง LLMs แพลตฟอร์ม CUDA ที่พัฒนาโดย NVIDIA ให้สภาพแวดล้อมซอฟต์แวร์ที่ช่วยให้นักพัฒนาสามารถใช้ประโยชน์จาก GPU ได้อย่างเต็มที่ โดยช่วยให้พวกเขาเขียนโค้ดที่สามารถใช้ความสามารถในการประมวลผลขนานของฮาร์ดแวร์ได้
การเร่งการฝึกอบรม LLM ด้วย GPU และ CUDA

การฝึกโมเดลภาษาขนาดใหญ่เป็นงานที่ต้องใช้การประมวลผลมากที่ต้องการการประมวลผลข้อมูลข้อความจำนวนมากและดำเนินการเมทริกซ์หลายครั้ง GPU มีคอร์หลายพันและแบนด์วิธหน่วยความจำสูง จึงเหมาะสำหรับงานเหล่านี้ โดยการนำ CUDA มาใช้ นักพัฒนาสามารถปรับโค้ดให้เหมาะสมเพื่อใช้ความสามารถในการประมวลผลขนานของ GPU ลดเวลาในการฝึกอบรม LLM ได้อย่างมาก

ตัวอย่างเช่น การฝึกอบรม GPT-3 หนึ่งในโมเดลภาษาที่ใหญ่ที่สุดที่มีการฝึกอบรมจนถึงปัจจุบัน ได้รับการทำให้เป็นไปได้โดยใช้ GPU ของ NVIDIA หลายพันเครื่องโดยใช้โค้ดที่ได้รับการปรับให้เหมาะสมสำหรับ 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()}')

ในตัวอย่างโค้ดนี้ เราแสดงการฝึกอบรมโมเดลภาษา GPT-2 โดยใช้ PyTorch และ GPU ที่ใช้ CUDA โมเดลถูกโหลดไปยัง GPU (หากมี) และลูปการฝึกอบรมใช้ขนานของ GPU เพื่อดำเนินการการส่งไปข้างหน้าและข้างหลังอย่างมีประสิทธิภาพ

ไลบรารี CUDA ที่เร่งการเรียนรู้เชิงลึก

นอกเหนือจากแพลตฟอร์ม CUDA เอง NVIDIA และชุมชนโอเพ่นซอร์สได้พัฒนาไลบรารี CUDA ที่เร่งการเรียนรู้เชิงลึกหลายตัว ซึ่งช่วยให้สามารถใช้งานโมเดลการเรียนรู้เชิงลึกได้อย่างมีประสิทธิภาพ รวมถึง LLMs ไลบรารีเหล่านี้ให้การนำไปใช้ที่ได้รับการปรับให้เหมาะสมของการดำเนินการทั่วไป เช่น การคูณเมทริกซ์ การสังเคราะห์ และฟังก์ชันการกระตุ้น ทำให้นักพัฒนาสามารถมุ่งเน้นไปที่สถาปัตยกรรมของโมเดลและกระบวนการฝึกอบรมมากกว่าการปรับให้เหมาะสมระดับต่ำ

ไลบรารีหนึ่งที่มีชื่อเสียงคือ cuDNN (CUDA Deep Neural Network library) ซึ่งให้การนำไปใช้ที่ได้รับการปรับให้เหมาะสมของกิจวัตรทั่วไปที่ใช้ในเครือข่ายประสาทเทียมลึก โดยการใช้ 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

ในโค้ดนี้ เรานิยามบล็อกที่เหลือสำหรับเครือข่ายประสาทเทียมลึกแบบโครงสร้าง (CNN) โดยใช้ PyTorch ผู้จัดการบริบท autocast จาก PyTorch’s Automatic Mixed Precision (AMP) ถูกใช้เพื่อเปิดใช้งานการฝึกอบรมที่มีการผสมผสาน โดยให้ประสิทธิภาพที่ดีขึ้นอย่างมากบน GPU ที่ใช้ CUDA ในขณะที่ยังคงรักษาความแม่นยำสูง

การฝึกอบรมหลาย 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’s DistributedDataParallel (DDP) โมเดลถูกห่อด้วย DDP ซึ่งจัดการการขนานข้อมูล การซิงค์เกรเดียนต์ และการสื่อสารระหว่าง GPU หลายตัวโดยใช้ NCCL

การนำโมเดลการเรียนรู้เชิงลึกไปใช้พร้อม CUDA

ในขณะที่ GPU และ CUDA ได้ถูกนำมาใช้ในการฝึกอบรมโมเดลการเรียนรู้เชิงลึกเป็นหลัก พวกเขายังมีความสำคัญต่อการนำไปใช้และการอนุมานที่มีประสิทธิภาพเช่นกัน เมื่อโมเดลการเรียนรู้เชิงลึกมีความซับซ้อนและต้องการทรัพยากรมากขึ้น การเร่งด้วย GPU จึงจำเป็นต่อการบรรลุประสิทธิภาพในเวลาจริงในสภาพแวดล้อมการผลิต

NVIDIA’s TensorRT เป็นเครื่องมือการอนุมานและการเร่งการเรียนรู้เชิงลึกที่มีประสิทธิภาพสูง ซึ่งให้การอนุมานที่ต่ำและความเร็วสูงบน GPU ที่ใช้ CUDA 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 สำหรับการนำโมเดลการเรียนรู้เชิงลึกที่ฝึกอบรมไว้แล้วไปใช้บน GPU ที่ใช้ CUDA โมเดลถูกวิเคราะห์และปรับให้เหมาะสมโดย TensorRT ซึ่งสร้างเครื่องมือการอนุมานที่ได้รับการปรับให้เหมาะสมสำหรับโมเดลและฮาร์ดแวร์เฉพาะ

สรุป

การรวมกันของ GPU และ CUDA เป็นปัจจัยสำคัญที่ขับเคลื่อนความก้าวหน้าในโมเดลภาษาขนาดใหญ่ การมองเห็นคอมพิวเตอร์ การรู้จำเสียง และโดเมนอื่นๆ ของการเรียนรู้เชิงลึก ด้วยการนำความสามารถในการประมวลผลขนานของ GPU และไลบรารีที่ได้รับการปรับให้เหมาะสมจาก CUDA มาใช้ นักวิจัยและนักพัฒนาสามารถฝึกอบรมและนำโมเดลไปใช้ได้อย่างมีประสิทธิภาพ

เมื่อภาค AI ยังคงพัฒนา ความสำคัญของ GPU และ CUDA จะเพิ่มขึ้นเท่านั้น ด้วยฮาร์ดแวร์และซอฟต์แวร์ที่มีประสิทธิภาพมากขึ้น เราสามารถคาดหวังการผ่านทางที่สำคัญในการพัฒนาและการนำระบบ AI ไปใช้ ซึ่งจะขยายขอบเขตของสิ่งที่เป็นไปได้