उदाहरण के साथ डीप लर्निंग के लिए पाइरटेक ट्रांसफर लर्निंग

ट्रांसफर लर्निंग क्या है?

ट्रांसफर लर्निंग एक अन्य संबंधित कार्य को हल करने के लिए एक प्रशिक्षित मॉडल का उपयोग करने की एक तकनीक है। यह एक मशीन लर्निंग अनुसंधान पद्धति है जो किसी विशेष समस्या को हल करते समय प्राप्त ज्ञान को संग्रहीत करती है और उसी ज्ञान का उपयोग किसी अन्य अलग संबंधित समस्या को हल करने के लिए करती है। यह पहले सीखे गए कार्य से एकत्रित जानकारी का पुन: उपयोग करके दक्षता में सुधार करता है।

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

इस PyTorch Transfer सीखने के ट्यूटोरियल के आगे, हम सीखेंगे कि PyTorch के साथ Transfer Learning का उपयोग कैसे करें।

डेटासेट लोड हो रहा है

स्रोत: एलियन बनाम प्रीडेटर केगल

इससे पहले कि आप Transfer Learning PyTorch का उपयोग करना शुरू करें, आपको उस डेटासेट को समझने की आवश्यकता है, जिसका आप उपयोग करने जा रहे हैं। इस Transfer Learning PyTorch उदाहरण में, आप लगभग 700 छवियों से एक विदेशी और एक शिकारी को वर्गीकृत करेंगे। इस तकनीक के लिए, आपको प्रशिक्षित करने के लिए वास्तव में बड़ी मात्रा में डेटा की आवश्यकता नहीं है। आप केगल: एलियन बनाम प्रिडेटर से डेटासेट डाउनलोड कर सकते हैं।

ट्रांसफर लर्निंग का उपयोग कैसे करें?

यहां पियर्स के साथ डीप लर्निंग के लिए ट्रांसफर लर्निंग का उपयोग करने के तरीके के बारे में कदम दर कदम बताया गया है:

चरण 1) डेटा लोड करें

पहला कदम हमारे डेटा को लोड करना और छवियों में कुछ परिवर्तन करना है ताकि यह नेटवर्क की आवश्यकताओं से मेल खाए।

आप torchvision.dataset वाले फ़ोल्डर से डेटा लोड करेंगे। मॉड्यूल ट्रेन और सत्यापन के लिए डेटा को विभाजित करने के लिए फ़ोल्डर में पुनरावृत्ति करेगा। परिवर्तन प्रक्रिया केंद्र से छवियों को क्रॉप करेगी, एक क्षैतिज फ्लिप करेगी, सामान्य करेगी, और अंत में डीप लर्निंग का उपयोग करके इसे दहाई में बदल देगी।

from __future__ import print_function, divisionimport osimport timeimport torchimport torchvisionfrom torchvision import datasets, models, transformsimport torch.optim as optimimport numpy as npimport matplotlib.pyplot as pltdata_dir = "alien_pred"input_shape = 224mean = [0.5, 0.5, 0.5]std = [0.5, 0.5, 0.5]#data transformationdata_transforms = {'train': transforms.Compose([transforms.CenterCrop(input_shape),transforms.ToTensor(),transforms.Normalize(mean, std)]),'validation': transforms.Compose([transforms.CenterCrop(input_shape),transforms.ToTensor(),transforms.Normalize(mean, std)]),}image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),transform=data_transforms[x])for x in ['train', 'validation']}dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=32,shuffle=True, num_workers=4)for x in ['train', 'validation']}dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'validation']}print(dataset_sizes)class_names = image_datasets['train'].classesdevice = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

आइए PyTorch Transfer Learning के लिए हमारे डेटासेट की कल्पना करें। विज़ुअलाइज़ेशन प्रक्रिया को ट्रेन डेटा-लोडर और लेबल से छवियों का अगला बैच मिलेगा और इसे मैटलपॉट के साथ प्रदर्शित करेगा।

images, labels = next(iter(dataloaders['train']))rows = 4columns = 4fig=plt.figure()for i in range(16):fig.add_subplot(rows, columns, i+1)plt.title(class_names[labels[i]])img = images[i].numpy().transpose((1, 2, 0))img = std * img + meanplt.imshow(img)plt.show()

चरण 2) मॉडल को परिभाषित करें

इस डीप लर्निंग प्रक्रिया में, आप टॉरविजन मोड्यूल से ResNet18 का उपयोग करेंगे।

आप Resnet18 को लोड करने के लिए torchvision.models का उपयोग ट्रू होने के लिए पूर्व-प्रशिक्षित वजन सेट के साथ करेंगे। उसके बाद, आप परतों को फ्रीज करेंगे ताकि ये परतें ट्रेन करने योग्य न हों। आप हमारी आवश्यकताओं के साथ 2 वर्गों को फिट करने के लिए रैखिक परत के साथ अंतिम परत को भी संशोधित करते हैं। आप मल्टी-क्लास लॉस फ़ंक्शन के लिए CrossEntropyLoss का भी उपयोग करते हैं और ऑप्टिमाइज़र के लिए आप 0.0001 की अधिगम दर के साथ SGD का उपयोग करेंगे और 0.9 का एक गति जैसा कि नीचे दिए गए PyTorch Transfer Learning उदाहरण में दिखाया गया है।

## Load the model based on VGG19vgg_based = torchvision.models.vgg19(pretrained=True)## freeze the layersfor param in vgg_based.parameters():param.requires_grad = False# Modify the last layernumber_features = vgg_based.classifier[6].in_featuresfeatures = list(vgg_based.classifier.children())[:-1] # Remove last layerfeatures.extend([torch.nn.Linear(number_features, len(class_names))])vgg_based.classifier = torch.nn.Sequential(*features)vgg_based = vgg_based.to(device)print(vgg_based)criterion = torch.nn.CrossEntropyLoss()optimizer_ft = optim.SGD(vgg_based.parameters(), lr=0.001, momentum=0.9)

आउटपुट मॉडल संरचना

VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace)(16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(17): ReLU(inplace)(18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace)(23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(24): ReLU(inplace)(25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(26): ReLU(inplace)(27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace)(30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(31): ReLU(inplace)(32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(33): ReLU(inplace)(34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(35): ReLU(inplace)(36): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(classifier): Sequential((0): Linear(in_features=25088, out_features=4096, bias=True)(1): ReLU(inplace)(2): Dropout(p=0.5)(3): Linear(in_features=4096, out_features=4096, bias=True)(4): ReLU(inplace)(5): Dropout(p=0.5)(6): Linear(in_features=4096, out_features=2, bias=True)))

चरण 3) ट्रेन और टेस्ट मॉडल

हम अपने मॉडल को प्रशिक्षित करने और मूल्यांकन करने में मदद करने के लिए स्थानांतरण लर्निंग PyTorch ट्यूटोरियल से कुछ फ़ंक्शन का उपयोग करेंगे।

def train_model(model, criterion, optimizer, num_epochs=25):since = time.time()for epoch in range(num_epochs):print('Epoch {}/{}'.format(epoch, num_epochs - 1))print('-' * 10)#set model to trainable# model.train()train_loss = 0# Iterate over data.for i, data in enumerate(dataloaders['train']):inputs , labels = datainputs = inputs.to(device)labels = labels.to(device)optimizer.zero_grad()with torch.set_grad_enabled(True):outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item() * inputs.size(0)print('{} Loss: {:.4f}'.format('train', train_loss / dataset_sizes['train']))time_elapsed = time.time() - sinceprint('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))return modeldef visualize_model(model, num_images=6):was_training = model.trainingmodel.eval()images_so_far = 0fig = plt.figure()with torch.no_grad():for i, (inputs, labels) in enumerate(dataloaders['validation']):inputs = inputs.to(device)labels = labels.to(device)outputs = model(inputs)_, preds = torch.max(outputs, 1)for j in range(inputs.size()[0]):images_so_far += 1ax = plt.subplot(num_images//2, 2, images_so_far)ax.axis('off')ax.set_title('predicted: {} truth: {}'.format(class_names[preds[j]], class_names[labels[j]]))img = inputs.cpu().data[j].numpy().transpose((1, 2, 0))img = std * img + meanax.imshow(img)if images_so_far == num_images:model.train(mode=was_training)returnmodel.train(mode=was_training)

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

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

vgg_based = train_model(vgg_based, criterion, optimizer_ft, num_epochs=25)visualize_model(vgg_based)plt.show()

चरण 4) परिणाम

अंतिम परिणाम यह है कि आपने 92% की सटीकता हासिल की है।

Epoch 23/24----------train Loss: 0.0044train Loss: 0.0078train Loss: 0.0141train Loss: 0.0221train Loss: 0.0306train Loss: 0.0336train Loss: 0.0442train Loss: 0.0482train Loss: 0.0557train Loss: 0.0643train Loss: 0.0763train Loss: 0.0779train Loss: 0.0843train Loss: 0.0910train Loss: 0.0990train Loss: 0.1063train Loss: 0.1133train Loss: 0.1220train Loss: 0.1344train Loss: 0.1382train Loss: 0.1429train Loss: 0.1500Epoch 24/24----------train Loss: 0.0076train Loss: 0.0115train Loss: 0.0185train Loss: 0.0277train Loss: 0.0345train Loss: 0.0420train Loss: 0.0450train Loss: 0.0490train Loss: 0.0644train Loss: 0.0755train Loss: 0.0813train Loss: 0.0868train Loss: 0.0916train Loss: 0.0980train Loss: 0.1008train Loss: 0.1101train Loss: 0.1176train Loss: 0.1282train Loss: 0.1323train Loss: 0.1397train Loss: 0.1436train Loss: 0.1467Training complete in 2m 47s

अंत में हमारे मॉडल के आउटपुट को नीचे दिए गए मैटलपॉट के साथ देखा जाएगा:

सारांश

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