ग्रोके प्योर्च

नमस्कार, हेब्र!

हमारे पास प्री-ऑर्डर में पाइरॉच लाइब्रेरी के बारे में एक लंबे समय से प्रतीक्षित पुस्तक है।



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

PyTorch एक लचीली गहरी सीखने की रूपरेखा है जो स्वचालित रूप से डायनेमिक न्यूरल नेटवर्क (यानी, डायनेमिक फ्लो कंट्रोल का उपयोग करने वाले नेटवर्क, जैसे if और while लूप) का उपयोग करके वस्तुओं के बीच अंतर करती है। PyTorch GPU त्वरण, वितरित प्रशिक्षण , विभिन्न प्रकार के अनुकूलन और कई अन्य अच्छी विशेषताओं का समर्थन करता है। यहाँ मैंने कुछ विचार निर्धारित किए कि कैसे, मेरी राय में, PyTorch का उपयोग करना चाहिए; पुस्तकालय और अनुशंसित प्रथाओं के सभी पहलुओं को यहां शामिल नहीं किया गया है, लेकिन मुझे उम्मीद है कि यह पाठ आपके लिए उपयोगी होगा।

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

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

आयात

 import argparse import os import torch from torch import nn, optim from torch.nn import functional as F from torch.utils.data import DataLoader from torchvision import datasets, transforms 

ये सभी काफी मानक आयात हैं, torchvision मॉड्यूल के अपवाद के साथ, जो विशेष रूप से कंप्यूटर दृष्टि से संबंधित कार्यों को हल करने के लिए सक्रिय रूप से उपयोग किया जाता है।

समायोजन

 parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--save-interval', type=int, default=10, metavar='N', help='how many batches to wait before checkpointing') parser.add_argument('--resume', action='store_true', default=False, help='resume training from checkpoint') args = parser.parse_args() use_cuda = torch.cuda.is_available() and not args.no_cuda device = torch.device('cuda' if use_cuda else 'cpu') torch.manual_seed(args.seed) if use_cuda: torch.cuda.manual_seed(args.seed) 

अजगर में कमांड लाइन के तर्कों को संभालने का एक मानक तरीका है।

यदि आपको विभिन्न उपकरणों पर काम करने के लिए डिज़ाइन किए गए कोड को लिखने की आवश्यकता है (उपलब्ध होने पर, जीपीयू-त्वरण का उपयोग करते हुए, लेकिन अगर यह सीपीयू पर कंप्यूटिंग के लिए वापस नहीं लुढ़का है), तो उचित torch.device चयन करें और सहेजें। जिसके साथ आप यह निर्धारित कर सकते हैं कि आपको कहाँ चाहिए टेनर्स जमा हो जाते हैं। इस तरह के कोड बनाने के बारे में अधिक जानकारी के लिए, आधिकारिक दस्तावेज देखें। PyTorch का दृष्टिकोण उपकरणों के चयन को उपयोगकर्ता नियंत्रण में लाना है, जो सरल उदाहरणों में अवांछनीय लग सकता है। हालांकि, यह दृष्टिकोण कार्य को सरल करता है जब आपको टेंसर्स से निपटना पड़ता है, जो कि ए) डिबगिंग बी के लिए सुविधाजनक है) आपको प्रभावी ढंग से उपकरणों का उपयोग करने की अनुमति देता है।

प्रयोगों के प्रतिलिपि प्रस्तुत करने numpy , आपको सभी घटकों के लिए यादृच्छिक प्रारंभिक मान सेट करने की आवश्यकता होती है जो यादृच्छिक संख्या पीढ़ी ( random या numpy सहित, यदि आप उनका उपयोग numpy करते numpy )। कृपया ध्यान दें: cuDNN गैर-नियतात्मक एल्गोरिदम का उपयोग करता है और वैकल्पिक रूप से torch.backends.cudnn.enabled = False का उपयोग करके अक्षम है।

डेटा

 data_path = os.path.join(os.path.expanduser('~'), '.torch', 'datasets', 'mnist') train_data = datasets.MNIST(data_path, train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])) test_data = datasets.MNIST(data_path, train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])) train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=True) test_loader = DataLoader(test_data, batch_size=args.batch_size, num_workers=4, pin_memory=True) 

चूंकि torchvision मॉडल ~/.torch/models/ तहत संग्रहीत किए torchvision , इसलिए मैं ~/.torch/datasets तहत torchvision torchvision को संग्रहीत करना पसंद करता हूं। यह मेरा कॉपीराइट समझौता है, लेकिन यह MNIST, CIFAR-10, आदि के आधार पर विकसित परियोजनाओं में उपयोग करने के लिए बहुत सुविधाजनक है। यदि आप एक से अधिक डेटासेट पुन: उपयोग करने का इरादा रखते हैं, तो सामान्यतया, डेटासेट को कोड से अलग संग्रहीत किया जाना चाहिए।

torchvision.transforms में व्यक्तिगत छवियों के लिए कई सुविधाजनक रूपांतरण विकल्प होते हैं, जैसे कि फसल और सामान्यीकरण।

batch_size में कई विकल्प हैं, लेकिन batch_size और shuffle अलावा, आपको num_workers और pin_memory को भी ध्यान में रखना चाहिए, वे दक्षता बढ़ाने में मदद करते हैं। num_workers > 0 अतुल्यकालिक डेटा लोडिंग के लिए num_workers > 0 का उपयोग करता है, और इसके लिए मुख्य प्रक्रिया को ब्लॉक नहीं करता है। एक विशिष्ट उपयोग मामला डिस्क से डेटा (उदाहरण के लिए, चित्र) लोड कर रहा है और संभवतः, उन्हें परिवर्तित कर रहा है; यह सब नेटवर्क डेटा प्रोसेसिंग के साथ समानांतर में किया जा सकता है। प्रसंस्करण की डिग्री को समायोजित करने की आवश्यकता हो सकती है) क) श्रमिकों की संख्या को कम करना और, परिणामस्वरूप, सीपीयू और रैम की मात्रा का उपयोग किया जाता है (प्रत्येक कार्यकर्ता बैच में शामिल अलग-अलग नमूनों की बजाय एक अलग बैच को लोड करता है) बी) उस नेटवर्क पर डेटा की प्रतीक्षा करने की अवधि को कम से कम करें। pin_memory किसी भी डेटा ट्रांसफर ऑपरेशन को रैम से GPU (और CPU के लिए विशिष्ट कोड के साथ कुछ भी नहीं करने के लिए) के रूप में pin_memory मेमोरी (पृष्ठांकित के विपरीत) का उपयोग करता है।

आदर्श

 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 10, kernel_size=5) self.conv2 = nn.Conv2d(10, 20, kernel_size=5) self.conv2_drop = nn.Dropout2d() self.fc1 = nn.Linear(320, 50) self.fc2 = nn.Linear(50, 10) def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=1) model = Net().to(device) optimiser = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) if args.resume: model.load_state_dict(torch.load('model.pth')) optimiser.load_state_dict(torch.load('optimiser.pth')) 

नेटवर्क इनिशियलाइज़ेशन आमतौर पर सदस्य चर, परतों तक फैली होती है जिसमें सीखने के पैरामीटर होते हैं और संभवतः, व्यक्तिगत सीखने के पैरामीटर और अप्रशिक्षित बफ़र्स होते हैं। फिर, एक प्रत्यक्ष पास के साथ, उनका उपयोग F से कार्यों के संयोजन में किया जाता है जो विशुद्ध रूप से कार्यात्मक होते हैं और पैरामीटर शामिल नहीं होते हैं। कुछ लोग विशुद्ध रूप से कार्यात्मक नेटवर्क के साथ काम करना पसंद करते हैं (उदाहरण के लिए पैरामीटर रखें और F.conv2d बजाय F.conv2d उपयोग करें) या नेटवर्क पूरी तरह से परतों से मिलकर (जैसे nn.ReLU बजाय)।

.to(device) GPU के लिए डिवाइस पैरामीटर (और बफ़र्स) भेजने का एक सुविधाजनक तरीका है यदि device को GPU पर सेट किया गया है, क्योंकि अन्यथा (यदि डिवाइस सीपीयू पर सेट है) तो कुछ भी नहीं किया जाएगा। ऑप्टिमाइज़र को पास करने से पहले डिवाइस पैरामीटर को उपयुक्त डिवाइस में स्थानांतरित करना महत्वपूर्ण है; अन्यथा, ऑप्टिमाइज़र मापदंडों को सही तरीके से ट्रैक करने में सक्षम नहीं होगा!

दोनों तंत्रिका नेटवर्क ( nn.Module ) और ऑप्टिमाइज़र ( optim.Optimizer ) अपनी आंतरिक स्थिति को बचा सकते हैं और लोड कर सकते हैं, और इसे .load_state_dict(state_dict) साथ करने की अनुशंसा की जाती है - पहले से सहेजे गए शब्दकोशों के आधार पर प्रशिक्षण फिर से शुरू करने के लिए दोनों की स्थिति को फिर से लोड करना आवश्यक है। राज्यों। संपूर्ण ऑब्जेक्ट को सहेजना त्रुटियों से भरा हो सकता है। यदि आप GPU पर map_location को map_location हैं और उन्हें CPU या किसी अन्य GPU पर लोड करना चाहते हैं, तो सबसे आसान तरीका है कि उन्हें CPU पर सीधे map_location विकल्प , उदा। torch.load('model.pth' , map_location='cpu' ) का उपयोग करके लोड करना है।

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

 def forward(self, x, hx, drop=False): hx2 = self.rnn(x, hx) print(hx.mean().item(), hx.var().item()) if hx.max.item() > 10 or self.can_drop and drop: return hx else: return hx2 

ट्रेनिंग

 model.train() train_losses = [] for i, (data, target) in enumerate(train_loader): data = data.to(device=device, non_blocking=True) target = target.to(device=device, non_blocking=True) optimiser.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() train_losses.append(loss.item()) optimiser.step() if i % 10 == 0: print(i, loss.item()) torch.save(model.state_dict(), 'model.pth') torch.save(optimiser.state_dict(), 'optimiser.pth') torch.save(train_losses, 'train_losses.pth') 

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

यहाँ .to() विधि न केवल डिवाइस को स्वीकार करता है, बल्कि non_blocking=True भी सेट करता है, इस प्रकार प्रतिबद्ध मेमोरी से GPU में डेटा की अतुल्यकालिक नकल सुनिश्चित करता है, जिससे CPU डेटा ट्रांसफर के दौरान चालू रहता है; अन्यथा, non_blocking=True केवल एक विकल्प नहीं है।

इससे पहले कि आप loss.backward() और loss.backward() का उपयोग कर optimiser.step() का उपयोग करके ग्रेडिएंट्स का एक नया सेट loss.backward() , आपको ऑप्टिमाइज़र का उपयोग करने वाले पैरामीटर के ग्रेडिएंट्स को ऑप्टिमाइज़ करने के लिए अनुकूलित करना होगा optimiser.zero_grad() । डिफ़ॉल्ट रूप से, PyTorch ग्रेडिएटर्स को जमा करता है, जो आपके पास एक पास में आवश्यक सभी ग्रेडिएंट्स की गणना करने के लिए पर्याप्त संसाधन नहीं होने पर बहुत सुविधाजनक है।

PyTorch स्वचालित ढ़ाल के एक "टेप" प्रणाली का उपयोग करता है - यह दसियों पर कौन से संचालन और किस क्रम में किया गया था, इसके बारे में जानकारी एकत्र करता है, और फिर उन्हें विपरीत दिशा में रिवर्स ऑर्डर (रिवर्स-मोड भेदभाव) में प्रदर्शन करने के लिए खेलता है। यही कारण है कि यह बहुत अधिक लचीला है और मनमाने ढंग से कम्प्यूटेशनल रेखांकन की अनुमति देता है। यदि इन टेनर्स में से किसी को भी ग्रेडिएंट्स की आवश्यकता नहीं है (आपको इस उद्देश्य के लिए ट्रैंसर्स बनाने के लिए आवश्यक_ग्रेड requires_grad=True सेट करना है), तो कोई भी ग्राफ़ सहेजा नहीं गया है! हालांकि, नेटवर्क में आमतौर पर पैरामीटर होते हैं जिन्हें ग्रेडिएंट की आवश्यकता होती है, इसलिए नेटवर्क आउटपुट के आधार पर की गई कोई भी गणना ग्राफ़ में संग्रहीत की जाएगी। इसलिए, यदि आप इस चरण से उत्पन्न डेटा को सहेजना चाहते हैं, तो आपको मैन्युअल रूप से ग्रेडिएंट (या अधिक सामान्य दृष्टिकोण) को अक्षम करने की आवश्यकता होगी, इस जानकारी को पायथन संख्या (पाइलट स्केलर में .item() का उपयोग करके) या numpy सरणी के रूप में numpy । आधिकारिक दस्तावेज में autograd बारे में और पढ़ें।

कम्प्यूटेशनल ग्राफ को छोटा करने का एक तरीका है .detach() जब RNN को बैकप्रोपेगैनेशन-थ्रू-टाइम के ट्रंचित संस्करण के साथ सीखते समय छिपे हुए स्टेट को पास किया जाता है। घाटे को अलग करते समय यह सुविधाजनक भी है, जब घटकों में से एक दूसरे नेटवर्क का आउटपुट होता है, लेकिन इस अन्य नेटवर्क को नुकसान के संबंध में अनुकूलित नहीं किया जाना चाहिए। एक उदाहरण के रूप में, मैं GAN के साथ काम करते समय आउटपुट सामग्री उत्पन्न करने वाले भेदभावपूर्ण भाग को सिखाऊंगा, या बेस फ़ंक्शन (उदाहरण के लिए, A2C) के रूप में उद्देश्य फ़ंक्शन का उपयोग करके अभिनेता-आलोचक एल्गोरिथ्म में नीति प्रशिक्षण। एक और तकनीक जो ग्रैडिएंट्स की गणना को रोकती है, वह GAN ( param.requires_grad = False पर जेनरेटिंग पार्ट का प्रशिक्षण) में प्रभावी है और फाइन ट्यूनिंग में विशिष्ट है नेटवर्क मापदंडों का चक्रीय param.requires_grad = False जिसके लिए param.requires_grad = False ।

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

परीक्षण

 model.eval() test_loss, correct = 0, 0 with torch.no_grad(): for data, target in test_loader: data = data.to(device=device, non_blocking=True) target = target.to(device=device, non_blocking=True) output = model(data) test_loss += F.nll_loss(output, target, reduction='sum').item() pred = output.argmax(1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_data) acc = correct / len(test_data) print(acc, test_loss) 

.train() जवाब में .train() नेटवर्क को .train() का उपयोग करके स्पष्ट रूप से मूल्यांकन मोड में डालने की आवश्यकता होती है।

जैसा कि ऊपर उल्लेख किया गया है, नेटवर्क का उपयोग करते समय, एक कम्प्यूटेशनल ग्राफ आमतौर पर संकलित किया जाता है। इसे रोकने के लिए, no_grad प्रसंग no_grad उपयोग with torch.no_grad() ।

कुछ और

यह एक अतिरिक्त खंड है, जिसमें मैंने कुछ और उपयोगी डिग्रेसियन बनाए हैं।
यहां मेमोरी के साथ काम करने के बारे में बताया गया है।

CUDA त्रुटियाँ? उन्हें ठीक करना कठिन है, और आमतौर पर वे तार्किक विसंगतियों से जुड़े होते हैं, जिसके अनुसार सीपीयू पर GPU की तुलना में अधिक समझदार त्रुटि संदेश प्रदर्शित होते हैं। सबसे अच्छा, यदि आप GPU के साथ काम करने की योजना बनाते हैं, तो आप CPU और GPU के बीच जल्दी से स्विच कर सकते हैं। एक अधिक सामान्य विकास टिप कोड को व्यवस्थित करने के लिए है ताकि एक पूर्ण कार्य शुरू करने से पहले इसे जल्दी से जांचा जा सके। उदाहरण के लिए, एक छोटा या सिंथेटिक डेटासेट तैयार करें, एक युग ट्रेन + परीक्षण चलाएं, आदि। यदि मामला CUDA त्रुटि है, या आप CPU को बिल्कुल भी स्विच नहीं कर सकते हैं, CUDA_LAUNCH_BLOCKING = 1 सेट करें। यह CUDA कर्नेल लॉन्च को तुल्यकालिक बना देगा, और आपको अधिक सटीक त्रुटि संदेश प्राप्त होंगे।

torch.multiprocessing पर एक नोट। एक ही समय में कई PyTorch स्क्रिप्ट चलाने या चलाने। क्योंकि PyTorch CPU पर रैखिक बीजगणित अभिकलन को गति देने के लिए बहु-थ्रेडेड BLAS पुस्तकालयों का उपयोग करता है, आमतौर पर कई कोर शामिल होते हैं। यदि आप एक ही समय में कई कार्य करना चाहते हैं, तो बहु-थ्रेडेड प्रसंस्करण या कई स्क्रिप्ट का उपयोग करते हुए, पर्यावरण चर OMP_NUM_THREADS को 1 या किसी अन्य कम मान पर सेट करके मैन्युअल रूप से उनकी संख्या कम करने की सलाह दी जा सकती है। इस प्रकार, प्रोसेसर के फिसलने की संभावना कम हो जाती है। आधिकारिक प्रलेखन में मल्टीथ्रेडेड प्रसंस्करण के संबंध में अन्य टिप्पणियां हैं।