การตั้งค่าการฝึกอบรม การปรับแต่ง และการอนุมาน LLM ด้วย NVIDIA GPU และ CUDA

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

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

คู่มือที่ครอบคลุมนี้จะแนะนำคุณตลอดขั้นตอนการตั้งค่า NVIDIA GPU บน Ubuntu ซึ่งครอบคลุมการติดตั้งส่วนประกอบซอฟต์แวร์ที่จำเป็น เช่น ไดรเวอร์ NVIDIA, ชุดเครื่องมือ CUDA, cuDNN, PyTorch และอื่นๆ

การเพิ่มขึ้นของเฟรมเวิร์ก AI ที่เร่งด้วย CUDA

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

จากการวิเคราะห์เพื่อบรรลุเป้าหมายของ การศึกษาประสิทธิภาพผลิตภัณฑ์การเรียนรู้เชิงลึกของศูนย์ข้อมูล NVIDIAโมเดลการเรียนรู้เชิงลึกที่เร่งด้วย CUDA สามารถบรรลุประสิทธิภาพที่เร็วขึ้นสูงสุด 100 เท่า เมื่อเทียบกับการใช้งานบน CPU

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

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

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

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

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

ชุดเครื่องมือ CUDA จัดเตรียมสภาพแวดล้อมการพัฒนาสำหรับการสร้างแอปพลิเคชันที่เร่งด้วย GPU ประสิทธิภาพสูง

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

sudo apt install nvidia-cuda-toolkit

However, to ensure compatibility with BitsAndBytes, we will follow these steps:

[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

ทำตามคำแนะนำเพื่อเพิ่มพวงกุญแจ:

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

ติดตั้งหม้อแปลงและเร่งไลบรารี:

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

# Load pre-trained GPT-2 model and tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Move model to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Define training data and hyperparameters
train_data = [...] # Your training data
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Training loop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Prepare input and target sequences
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 pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward pass and optimization
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

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

CUDA-Accelerated Libraries สำหรับการเรียนรู้เชิงลึก

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

ไลบรารีหนึ่งดังกล่าวคือ cuDNN (ไลบรารี CUDA Deep Neural Network) ซึ่งให้การใช้งานรูทีนมาตรฐานที่ได้รับการปรับแต่งอย่างดีซึ่งใช้ในโครงข่ายประสาทเทียมเชิงลึก ด้วยการใช้ประโยชน์จาก 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 ตัวจัดการบริบทการส่งอัตโนมัติจาก Automatic Mixed Precision (AMP) ของ PyTorch ใช้เพื่อเปิดใช้งานการฝึกอบรมแบบผสมความแม่นยำ ซึ่งสามารถเพิ่มประสิทธิภาพได้อย่างมากบน GPU ที่รองรับ CUDA ในขณะที่ยังคงรักษาความแม่นยำสูงไว้ ฟังก์ชัน F.relu ได้รับการปรับให้เหมาะสมโดย cuDNN เพื่อให้มั่นใจถึงการทำงานที่มีประสิทธิภาพบน GPU

Multi-GPU และการฝึกอบรมแบบกระจายเพื่อความสามารถในการปรับขนาด

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

CUDA และไลบรารีที่เกี่ยวข้อง เช่น NCCL (NVIDIA Collective Communications Library) มอบการสื่อสารแบบดั้งเดิมที่มีประสิทธิภาพซึ่งช่วยให้สามารถถ่ายโอนข้อมูลและการซิงโครไนซ์ข้อมูลได้อย่างราบรื่นบน GPU หลายตัว ช่วยให้สามารถฝึกอบรมแบบกระจายในระดับที่ไม่เคยมีมาก่อน

</pre>
import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialize distributed training
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Create model and move to GPU
model = MyModel().cuda()

# Wrap model with DDP
model = DDP(model, device_ids=[local_rank])

# Training loop (distributed)
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()

ในตัวอย่างนี้ เราสาธิตการฝึกอบรมแบบกระจายโดยใช้โมดูล DistributedDataParallel (DDP) ของ PyTorch โมเดลนี้รวมอยู่ใน DDP ซึ่งจะจัดการข้อมูลแบบขนาน การซิงโครไนซ์การไล่ระดับสี และการสื่อสารระหว่าง GPU หลายตัวโดยอัตโนมัติโดยใช้ NCCL แนวทางนี้ช่วยให้สามารถปรับขนาดกระบวนการฝึกอบรมในเครื่องหลายเครื่องได้อย่างมีประสิทธิภาพ ช่วยให้นักวิจัยและนักพัฒนาสามารถฝึกอบรมโมเดลที่ใหญ่ขึ้นและซับซ้อนมากขึ้นในระยะเวลาที่เหมาะสม

การปรับใช้โมเดลการเรียนรู้เชิงลึกด้วย CUDA

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

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

import tensorrt as trt

# Load pre-trained model
model = load_model(...)

# Create TensorRT engine
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parse and optimize model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Run inference on GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Set input data and run inference
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Process output
# ...

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

สรุป

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

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