NVIDIA GPUs और CUDA के साथ LLMs की स्थापना, फाइन-ट्यूनिंग और अनुमान

कृत्रिम बुद्धिमत्ता (AI) के क्षेत्र में हाल के वर्षों में उल्लेखनीय प्रगति हुई है, और इसके केंद्र में शक्तिशाली ग्राफिक्स प्रोसेसिंग यूनिट (GPUs) और समानांतर कंप्यूटिंग प्लेटफ़ॉर्म का संयोजन है। GPT, BERT, और हाल ही में Llama, Mistral जैसे मॉडल मानव-जैसे पाठ को असाधारण चिकनाई और सुसंगतता के साथ समझने और उत्पन्न करने में सक्षम हैं। हालांकि, इन मॉडलों को प्रशिक्षित करने के लिए विशाल मात्रा में डेटा और गणनात्मक संसाधनों की आवश्यकता होती है, जिससे GPUs और CUDA इस प्रयास में अपरिहार्य उपकरण बन जाते हैं। यह व्यापक गाइड आपको Ubuntu पर NVIDIA GPU सेट करने की प्रक्रिया के माध्यम से चलेगा, जिसमें NVIDIA ड्राइवर, CUDA टूलकिट, cuDNN, PyTorch और अधिक जैसे आवश्यक सॉफ़्टवेयर घटकों की स्थापना शामिल है।

CUDA-असिस्टेड AI फ्रेमवर्क का उदय

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

LLM अनुमान को NVIDIA टेंसरआरटी के साथ त्वरण

जबकि GPUs ने LLMs को प्रशिक्षित करने में महत्वपूर्ण भूमिका निभाई है, कुशल अनुमान उत्पादन वातावरण में इन मॉडलों को तैनात करने के लिए समान रूप से महत्वपूर्ण है। NVIDIA टेंसरआरटी, एक उच्च-प्रदर्शन डीप लर्निंग अनुमान ऑप्टिमाइज़र और रनटाइम, CUDA-इनेबल्ड GPUs पर LLM अनुमान को त्वरण करने में एक महत्वपूर्ण भूमिका निभाता है। NVIDIA के बेंचमार्क के अनुसार, टेंसरआरटी बड़े भाषा मॉडल जैसे GPT-3 के लिए CPU-आधारित अनुमान की तुलना में 8 गुना तेज़ अनुमान प्रदर्शन और 5 गुना कम कुल स्वामित्व लागत प्रदान कर सकता है। NVIDIA की ओपन-सोर्स पहल के प्रति प्रतिबद्धता AI अनुसंधान समुदाय में CUDA के व्यापक अपनाने के पीछे एक महत्वपूर्ण शक्ति रही है। 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 के लिए उपयुक्त ड्राइवर चुनें और ड्राइवर संस्करण पर ध्यान दें।

Ubuntu पर प्रीबिल्ट GPU पैकेज की जांच करने के लिए चलाएं:

 sudo ubuntu-drivers list --gpgpu 

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

 nvidia-smi 

2. CUDA टूलकिट स्थापित करें

CUDA टूलकिट उच्च-प्रदर्शन GPU-असिस्टेड अनुप्रयोगों के निर्माण के लिए विकास वातावरण प्रदान करता है। एक गैर-LLM/डीप लर्निंग सेटअप के लिए, आप उपयोग कर सकते हैं:

 sudo apt install nvidia-cuda-toolkit 

हालांकि, BitsAndBytes के साथ संगतता सुनिश्चित करने के लिए, हम इन चरणों का पालन करेंगे:

 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. पाइथन वर्चुअल एनवायरनमेंट सेटअप करें

Ubuntu 22.04 पाइथन 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. पाइथॉन स्थापित करें

पाइथॉन स्थापित करें:

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

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

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

 pip install transformers pip install accelerate 

समानांतर प्रोसेसिंग की शक्ति

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

बड़े भाषा मॉडलों को प्रशिक्षित करना एक गणनात्मक रूप से मांग वाला कार्य है जिसमें विशाल मात्रा में पाठ डेटा को संसाधित करना और कई मैट्रिक्स संचालन करना शामिल है। GPUs, जिनमें हजारों कोर और उच्च मेमोरी बैंडविथ है, इन कार्यों के लिए आदर्श रूप से अनुकूल हैं। CUDA का लाभ उठाकर, डेवलपर अपने कोड को अनुकूलित कर सकते हैं ताकि वे GPUs की समानांतर प्रोसेसिंग क्षमताओं का लाभ उठा सकें, जिससे LLMs को प्रशिक्षित करने में आवश्यक समय काफी कम हो जाता है। उदाहरण के लिए, GPT-3, सबसे बड़े भाषा मॉडल में से एक, को प्रशिक्षित करना हजारों NVIDIA GPUs के उपयोग से संभव हुआ, जो 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()}') 

इस उदाहरण स्निपेट में, हम पाइथॉन और CUDA-इनेबल्ड GPUs का उपयोग करके GPT-2 भाषा मॉडल को प्रशिक्षित करने का प्रदर्शन करते हैं। मॉडल को GPU (यदि उपलब्ध हो) पर लोड किया जाता है, और प्रशिक्षण लूप GPUs के समानांतरवाद का लाभ उठाता है ताकि कुशल फॉरवर्ड और बैकवर्ड पास किए जा सकें, जिससे प्रशिक्षण प्रक्रिया तेज हो जाती है।

CUDA-असिस्टेड लाइब्रेरी डीप लर्निंग के लिए

CUDA प्लेटफ़ॉर्म के अलावा, NVIDIA और ओपन-सोर्स समुदाय ने CUDA-असिस्टेड लाइब्रेरी की एक श्रृंखला विकसित की है जो डीप लर्निंग मॉडल, जिनमें LLMs भी शामिल हैं, को कुशलता से लागू करने में सक्षम बनाती है। ये लाइब्रेरी मैट्रिक्स गुणा, संवolution और एक्टिवेशन फ़ंक्शन जैसे सामान्य संचालन के अनुकूलित कार्यान्वयन प्रदान करती हैं, जिससे डेवलपर मॉडल आर्किटेक्चर और प्रशिक्षण प्रक्रिया पर ध्यान केंद्रित कर सकते हैं न कि निम्न-स्तरीय अनुकूलन पर। एक ऐसी लाइब्रेरी cuDNN (CUDA डीप न्यूरल नेटवर्क लाइब्रेरी) है, जो डीप न्यूरल नेटवर्क में उपयोग की जाने वाली मानक दिनचर्या के उच्च ट्यून किए गए कार्यान्वयन प्रदान करती है। 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) के लिए परिभाषित करते हैं। पाइथॉन के ऑटोमैटिक मिक्स्ड प्रेसिजन (AMP) से ऑटोकास्ट कॉन्टेक्स्ट मैनेजर का उपयोग मिश्रित-परिशुद्धता प्रशिक्षण को सक्षम करने के लिए किया जाता है, जो CUDA-इनेबल्ड GPUs पर महत्वपूर्ण प्रदर्शन लाभ प्रदान कर सकता है जबकि उच्च सटीकता बनाए रखता है। F.relu फ़ंक्शन को cuDNN द्वारा अनुकूलित किया जाता है, जो GPUs पर कुशल निष्पादन सुनिश्चित करता है।

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

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

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

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

CUDA के साथ डीप लर्निंग मॉडल को तैनात करना

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

 import tensorrt as trt # पूर्व-प्रशिक्षित मॉडल लोड करें model = load_model(...) # टेंसरआरटी इंजन बनाएं 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) # आउटपुट को संसाधित करें # ... 

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

निष्कर्ष

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