एनआईडीआईए ग्राफिक्स प्रोसेसिंग यूनिट और सीउडीए के साथ एलएलएम का प्रशिक्षण, फाइन-ट्यूनिंग और अनुमान

कृत्रिम बुद्धिमत्ता (एआई) के क्षेत्र में हाल के वर्षों में उल्लेखनीय प्रगति हुई है, और इसके केंद्र में शक्तिशाली ग्राफिक्स प्रोसेसिंग यूनिट (जीपीयू) और समानांतर कम्प्यूटिंग प्लेटफ़ॉर्म का संयोजन है।

जीपीटी, बीईआरटी जैसे मॉडल, और हाल ही में एलएमए, मिस्ट्रल जैसे मॉडल मानव-जैसे पाठ को समझने और उत्पन्न करने में असाधारण चिकनाई और सुसंगतता के साथ सक्षम हैं। हालांकि, इन मॉडलों को प्रशिक्षित करने के लिए विशाल डेटा और गणना संसाधनों की आवश्यकता होती है, जिससे जीपीयू और सीउडीए इस प्रयास में अपरिहार्य उपकरण बन जाते हैं।

यह व्यापक गाइड आपको यूबंटू पर एनवीडिया जीपीयू सेट करने की प्रक्रिया के माध्यम से ले जाएगा, जिसमें आवश्यक सॉफ़्टवेयर घटकों जैसे कि एनवीडिया ड्राइवर, सीउडीए टूलकिट, क्यूडीएनएन, पायटॉर्च और अधिक की स्थापना शामिल है।

सीउडीए-त्वरित एआई फ्रेमवर्क का उदय

जीपीयू-त्वरित गहरा शिक्षा को लोकप्रिय एआई फ्रेमवर्क के विकास द्वारा ईंधन दिया गया है जो सीउडीए के लिए कुशल गणना के लिए लाभ उठाते हैं। टेंसरफ्लो, पायटॉर्च और एमएक्सनेट जैसे फ्रेमवर्क में सीउडीए के लिए निर्मित समर्थन है, जीपीयू त्वरण को गहरे शिक्षा पाइपलाइनों में निर्बाध एकीकरण की अनुमति देता है।

एनवीडिया डेटा सेंटर डीप लर्निंग प्रोडक्ट प्रदर्शन अध्ययन के अनुसार, सीउडीए-त्वरित गहरे शिक्षा मॉडल सीपीयू-आधारित कार्यान्वयन की तुलना में 100 गुना तेज़ प्रदर्शन प्राप्त कर सकते हैं।

एनवीडिया की मल्टी-इंस्टेंस जीपीयू (एमआईजी) प्रौद्योगिकी, एम्पियर आर्किटेक्चर के साथ पेश की गई, एक जीपीयू को कई सुरक्षित उदाहरणों में विभाजित करने की अनुमति देती है, प्रत्येक के पास अपने स्वयं के समर्पित संसाधन होते हैं। यह सुविधा जीपीयू संसाधनों को कई उपयोगकर्ताओं या कार्यभार के बीच कुशलता से साझा करने की अनुमति देती है, उपयोगिता को अधिकतम करती है और समग्र लागत को कम करती है।

एनवीडिया टेंसरआरटी के साथ एलएलएम अनुमान त्वरण

जबकि जीपीयू एलएलएम को प्रशिक्षित करने में महत्वपूर्ण रहे हैं, कुशल अनुमान उत्पादन वातावरणों में इन मॉडलों को तैनात करने के लिए समान रूप से महत्वपूर्ण है। एनवीडिया टेंसरआरटी, एक उच्च-प्रदर्शन गहरे शिक्षा अनुमान ऑप्टिमाइज़र और रनटाइम, सीउडीए-सक्षम जीपीयू पर एलएलएम अनुमान को त्वरण में एक महत्वपूर्ण भूमिका निभाता है।

एनवीडिया के बेंचमार्क के अनुसार, टेंसरआरटी जीपी-3 जैसे बड़े भाषा मॉडल के लिए सीपीयू-आधारित अनुमान की तुलना में 8 गुना तेज़ अनुमान प्रदर्शन और 5 गुना कम कुल स्वामित्व लागत प्रदान कर सकता है।

एनवीडिया की ओपन-सोर्स पहल के पीछे की प्रतिबद्धता एआई अनुसंधान समुदाय में सीउडीए के व्यापक अपनाने के पीछे एक महत्वपूर्ण ड्राइविंग बल रही है। क्यूडीएनएन, क्यूबीएलएएस और एनसीसीएल जैसी परियोजनाएं ओपन-सोर्स लाइब्रेरी के रूप में उपलब्ध हैं, जो शोधकर्ताओं और विकासकों को अपने गहरे शिक्षा अनुप्रयोगों के लिए सीउडीए की पूरी क्षमता का लाभ उठाने की अनुमति देती हैं।

स्थापना

एआई विकास सेटिंग करते समय, नवीनतम ड्राइवरों और लाइब्रेरी का उपयोग करना हमेशा सबसे अच्छा विकल्प नहीं हो सकता है। उदाहरण के लिए, जबकि नवीनतम एनवीडिया ड्राइवर (545.xx) सीउडीए 12.3 का समर्थन करता है, पायटॉर्च और अन्य लाइब्रेरी अभी तक इस संस्करण का समर्थन नहीं कर सकती हैं। इसलिए, हम संगतता सुनिश्चित करने के लिए ड्राइवर संस्करण 535.146.02 के साथ सीउडीए 12.2 का उपयोग करेंगे।

स्थापना चरण

1. एनवीडिया ड्राइवर स्थापित करें

पहले, अपने जीपीयू मॉडल की पहचान करें। इस गाइड के लिए, हम एनवीडिया जीपीयू का उपयोग करेंगे। एनवीडिया ड्राइवर डाउनलोड पृष्ठ पर जाएं, अपने जीपीयू के लिए उपयुक्त ड्राइवर चुनें, और ड्राइवर संस्करण नोट करें।

यूबंटू पर प्रीबिल्ट जीपीयू पैकेज की जांच के लिए चलाएं:

sudo ubuntu-drivers list --gpgpu

अपने कंप्यूटर को पुनरारंभ करें और स्थापना की पुष्टि करें:

nvidia-smi

2. सीउडीए टूलकिट स्थापित करें

सीउडीए टूलकिट जीपीयू-त्वरित अनुप्रयोगों के निर्माण के लिए विकास वातावरण प्रदान करता है।

गैर-एलएलएम/गहरे शिक्षा सेटअप के लिए, आप उपयोग कर सकते हैं:

sudo apt install nvidia-cuda-toolkit

<p>हालांकि, बिट्सएंडबाइट्स के साथ संगतता सुनिश्चित करने के लिए, हम इन चरणों का पालन करेंगे:</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>

स्थापना की पुष्टि करें:

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

पर्यावरण 변수 सेट करें:

<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. क्यूडीएनएन स्थापित करें

क्यूडीएनएन पैकेज को एनवीडिया डेवलपर वेबसाइट से डाउनलोड करें और इसे स्थापित करें:

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

कुंजी को जोड़ने के निर्देशों का पालन करें:

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

क्यूडीएनएन लाइब्रेरी स्थापित करें:

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

4. पायथन वर्चुअल एनवायरनमेंट सेटअप करें

यूबंटू 22.04 पायथन 3.10 के साथ आता है। वेन्व स्थापित करें:

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

वर्चुअल एनवायरनमेंट बनाएं और सक्रिय करें:

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

5. बिट्सएंडबाइट्स से स्थापित करें

बिट्सएंडबाइट्स निर्देशिका में नेविगेट करें और स्रोत से बनाएं:

<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. पायटॉर्च स्थापित करें

पायटॉर्च स्थापित करें:

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

7. हगिंग फेस और ट्रांसफॉर्मर्स स्थापित करें

ट्रांसफॉर्मर्स और एक्सेलेरेट लाइब्रेरी स्थापित करें:

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

समानांतर प्रसंस्करण की शक्ति

जीपीयू मूल रूप से उच्च समानांतर प्रोसेसर हैं जो हज़ारों समानांतर थ्रेड्स को कुशलता से संभालने के लिए डिज़ाइन किए गए हैं। यह आर्किटेक्चर उन्हें गहरे शिक्षा मॉडल, जीपीयू और सीउडीए के साथ एलएलएम प्रशिक्षण के लिए उपयुक्त बनाता है।

जीपीयू और सीउडीए एलएलएम प्रशिक्षण को त्वरण देने में महत्वपूर्ण भूमिका निभाते हैं।

बड़े भाषा मॉडल को प्रशिक्षित करना एक गणनात्मक रूप से मांग वाला कार्य है जिसमें विशाल पाठ डेटा को संसाधित करना और कई मैट्रिक्स संचालन करना शामिल है। जीपीयू, अपने हज़ारों कोर और उच्च मेमोरी बैंडविड्थ के साथ, इन कार्यों के लिए आदर्श रूप से अनुकूल हैं। सीउडीए का लाभ उठाकर, विकासकर्ता अपने कोड को जीपीयू की समानांतर प्रसंस्करण क्षमताओं का लाभ उठाने के लिए अनुकूलित कर सकते हैं, एलएलएम को प्रशिक्षित करने के लिए आवश्यक समय को काफी कम कर सकते हैं।

उदाहरण के लिए, जीपीटी-3 को प्रशिक्षित करना, जो अब तक के सबसे बड़े भाषा मॉडल में से एक है, हज़ारों एनवीडिया जीपीयू का उपयोग करके सीउडीए-अनुकूलित कोड चलाने के माध्यम से संभव हुआ। इससे मॉडल को अभूतपूर्व मात्रा में डेटा पर प्रशिक्षित किया जा सका, जिससे प्राकृतिक भाषा कार्यों में इसका प्रभावशाली प्रदर्शन हुआ।

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

<p># पूर्व-प्रशिक्षित जीपीटी-2 मॉडल और टोकनाइज़र लोड करें:
model = GPT2LMHeadModel.from_pretrained(&amp;#039;gpt2&amp;#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&amp;#039;gpt2&amp;#039;)</p>

<p># मॉडल को जीपीयू पर ले जाएं, यदि उपलब्ध हो:</p>

<p>device = torch.device(&amp;quot;cuda&amp;quot; if torch.cuda.is_available() else &amp;quot;cpu&amp;quot;)
model = model.to(device)</p>

<p># प्रशिक्षण डेटा और हाइपरपैरामीटर परिभाषित करें:
train_data = [...] # अपना प्रशिक्षण डेटा यहाँ
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>

<p># हानि फ़ंक्शन और ऑप्टिमाइज़र परिभाषित करें:
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>

<p># प्रशिक्षण लूप:
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=&amp;quot;pt&amp;quot;, padding=True)
inputs = inputs.to(device)
targets = targets.to(device)</p>

<p># फ़ॉरवर्ड पास:
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>

<p># बैकवर्ड पास और ऑप्टिमाइज़ेशन:
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

<p>print(f&amp;#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&amp;#039;)</p>

इस उदाहरण में, हम पायटॉर्च और सीउडीए-सक्षम जीपीयू का उपयोग करके जीपीटी-2 भाषा मॉडल को प्रशिक्षित करने का प्रदर्शन करते हैं। मॉडल को जीपीयू (यदि उपलब्ध हो) पर लोड किया जाता है, और प्रशिक्षण लूप जीपीयू की समानांतर प्रसंस्करण क्षमताओं का लाभ उठाता है, जिससे प्रशिक्षण प्रक्रिया में तेजी आती है।

सीउडीए-त्वरित लाइब्रेरी गहरे शिक्षा के लिए

सीउडीए प्लेटफ़ॉर्म के अलावा, एनवीडिया और ओपन-सोर्स समुदाय ने गहरे शिक्षा मॉडल, जिसमें एलएलएम भी शामिल हैं, के कुशल कार्यान्वयन को सक्षम करने वाली सीउडीए-त्वरित लाइब्रेरी की एक श्रृंखला विकसित की है। इन लाइब्रेरी में सामान्य ऑपरेशन के अनुकूलित कार्यान्वयन शामिल हैं, जैसे कि मैट्रिक्स गुणा, संवolution, और सक्रियण फ़ंक्शन, जो विकासकर्ताओं को मॉडल वास्तुकला और प्रशिक्षण प्रक्रिया पर ध्यान केंद्रित करने की अनुमति देते हैं, न कि निम्न-स्तरीय अनुकूलन पर।

एक ऐसी लाइब्रेरी क्यूडीएनएन (सीउडीए गहरे तंत्रिका नेटवर्क लाइब्रेरी) है, जो मानक दिनचर्या के उच्च रूप से अनुकूलित कार्यान्वयन प्रदान करती है जो गहरे तंत्रिका नेटवर्क में उपयोग की जाती हैं। क्यूडीएनएन का लाभ उठाकर, विकासकर्ता अपने मॉडलों को प्रशिक्षित और अनुमान लगाने के लिए काफी तेजी से कर सकते हैं, सीपीयू-आधारित कार्यान्वयन की तुलना में कई गुना तेज़ प्रदर्शन प्राप्त कर सकते हैं।

<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>

इस कोड स्निपेट में, हम पायटॉर्च का उपयोग करके एक संवोल्यूशनल न्यूरल नेटवर्क (सीएनएन) के लिए एक शेष ब्लॉक परिभाषित करते हैं। टेंसरटॉर्च के ऑटोमैटिक मिक्स्ड प्रेसिजन (एएमपी) से ऑटोकास्ट कॉन्टेक्स्ट मैनेजर का उपयोग करके मिश्रित-परिशुद्धता प्रशिक्षण को सक्षम किया जाता है, जो सीउडीए-सक्षम जीपीयू पर प्रदर्शन में महत्वपूर्ण लाभ प्रदान कर सकता है।

मल्टी-जीपीयू और वितरित प्रशिक्षण के लिए स्केलेबिलिटी

जैसे-जैसे एलएलएम और गहरे शिक्षा मॉडल आकार और जटिलता में बढ़ते हैं, उनके प्रशिक्षण के लिए गणनात्मक आवश्यकताएं भी बढ़ती हैं। इस चुनौती का सामना करने के लिए, शोधकर्ता और विकासक मल्टी-जीपीयू और वितरित प्रशिक्षण तकनीकों की ओर मुड़ रहे हैं, जो उन्हें एक से अधिक जीपीयू के संयुक्त प्रसंस्करण शक्ति का लाभ उठाने की अनुमति देते हैं।

सीउडीए और संबद्ध लाइब्रेरी, जैसे कि एनसीसीएल (एनवीडिया सामूहिक संचार लाइब्रेरी), मल्टी-जीपीयू और वितरित प्रशिक्षण के लिए कुशल संचार प्रिमिटिव प्रदान करते हैं, जो बड़े पैमाने पर वितरित प्रशिक्षण को सक्षम बनाते हैं।

</pre>
import torch.distributed as dist

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

<p># वितरित प्रशिक्षण को आरंभ करें:
dist.init_process_group(backend=&amp;#039;nccl&amp;#039;, init_method=&amp;#039;...&amp;#039;)
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)</p>

<p># मॉडल बनाएं और इसे जीपीयू पर ले जाएं:
model = MyModel().cuda()</p>

<p># मॉडल को डीडीपी में लपेटें:
model = DDP(model, device_ids=[local_rank])</p>

<p># प्रशिक्षण लूप (वितरित):
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>

इस उदाहरण में, हम पायटॉर्च के वितरित डेटा पैरेलल (डीडीपी) मॉड्यूल का उपयोग करके वितरित प्रशिक्षण का प्रदर्शन करते हैं। मॉडल को डीडीपी में लपेटा जाता है, जो स्वचालित रूप से डेटा समानांतरता, ग्रेडिएंट सिंक्रनाइजेशन और एनसीसीएल का उपयोग करके मल्टी-जीपीयू पर संचार को संभालता है। यह दृष्टिकोण प्रशिक्षण प्रक्रिया को कुशलता से कई मशीनों पर स्केल करने की अनुमति देता है, जिससे शोधकर्ता और विकासक बड़े और अधिक जटिल मॉडल को एक उचित समय में प्रशिक्षित कर सकते हैं।

सीउडीए के साथ गहरे शिक्षा मॉडल को तैनात करना

जीपीयू और सीउडीए प्रशिक्षण के लिए प्राथमिक रूप से उपयोग किए जाते हैं, वे उत्पादन वातावरणों में गहरे शिक्षा मॉडल के कुशल तैनाती के लिए भी महत्वपूर्ण हैं। जैसे-जैसे गहरे शिक्षा मॉडल जटिलता और संसाधन-गहनता में बढ़ते हैं, जीपीयू त्वरण उत्पादन वातावरणों में वास्तविक समय प्रदर्शन प्राप्त करने के लिए आवश्यक हो जाता है।

एनवीडिया का टेंसरआरटी एक उच्च-प्रदर्शन गहरे शिक्षा अनुमान ऑप्टिमाइज़र और रनटाइम है जो सीउडीए-सक्षम जीपीयू पर कम-विलंबता और उच्च-थ्रूपुट अनुमान प्रदान करता है। टेंसरआरटी टेंसरफ्लो, पायटॉर्च और एमएक्सनेट जैसे फ्रेमवर्क में प्रशिक्षित मॉडल को अनुकूलित और त्वरण दे सकता है, विभिन्न प्लेटफ़ॉर्म पर कुशल तैनाती को सक्षम बनाता है, एम्बेडेड सिस्टम से लेकर डेटा सेंटर तक।

import tensorrt as trt

<p># पूर्व-प्रशिक्षित मॉडल लोड करें:
model = load_model(...)</p>

<p># टेंसरआरटी इंजन बनाएं:
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)</p>

<p># मॉडल को पार्स और अनुकूलित करें:
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)</p>

<p># जीपीयू पर अनुमान चलाएं:
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)</p>

<p># इनपुट डेटा सेट करें और अनुमान चलाएं:
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p>

# आउटपुट प्रोसेस करें
# ...

इस उदाहरण में, हम टेंसरआरटी का उपयोग करके एक पूर्व-प्रशिक्षित गहरे शिक्षा मॉडल को सीउडीए-सक्षम जीपीयू पर तैनात करने का प्रदर्शन करते हैं। मॉडल को टेंसरआरटी द्वारा पार्स और अनुकूलित किया जाता है, जो एक उच्च रूप से अनुकूलित अनुमान इंजन बनाता है जो जीपीयू पर कुशल अनुमान को सक्षम बनाता है।

निष्कर्ष

जीपीयू और सीउडीए का संयोजन गहरे शिक्षा मॉडल, विशेष रूप से एलएलएम के विकास में एक महत्वपूर्ण भूमिका निभाई है। सीउडीए प्लेटफ़ॉर्म और इसके साथ आने वाली लाइब्रेरी जैसे क्यूडीएनएन ने विकासकर्ताओं को अपने मॉडलों को प्रशिक्षित और तैनात करने के लिए आवश्यक उपकरण प्रदान किए हैं। जैसे-जैसे एआई क्षेत्र आगे बढ़ता है, जीपीयू और सीउडीए का महत्व केवल बढ़ेगा, और हमें और अधिक शक्तिशाली और कुशल मॉडल देखने की उम्मीद है जो वास्तविक दुनिया की समस्याओं को हल करने में मदद करेंगे।

एआई क्षेत्र में आगे बढ़ने के साथ, हम और भी नए अवसरों और चुनौतियों का सामना करेंगे। जीपीयू और सीउडीए जैसी प्रौद्योगिकियों के साथ, हम वास्तविक दुनिया की समस्याओं को हल करने और मानव जीवन को बेहतर बनाने के लिए और भी अधिक शक्तिशाली और कुशल मॉडल बनाने में सक्षम होंगे।