PyTorch ट्रांसफर लर्निंग ट्यूटोरियल उदाहरणों के साथ

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

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

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

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

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

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

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

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

PyTorch के साथ डीप लर्निंग के लिए ट्रांसफर लर्निंग का उपयोग करने की चरण-दर-चरण प्रक्रिया यहां दी गई है:

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

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

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

from __future__ import print_function, division
import os
import time
import torch
import torchvision
from torchvision import datasets, models, transforms
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

data_dir = "alien_pred"
input_shape = 224
mean = [0.5, 0.5, 0.5]
std = [0.5, 0.5, 0.5]

#data transformation
data_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'].classes

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

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

images, labels = next(iter(dataloaders['train']))

rows = 4
columns = 4
fig=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 + mean
   plt.imshow(img)
plt.show()

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

इस में गहरी सीख प्रक्रिया में, आप torchvision मॉड्यूल से ResNet18 का उपयोग करेंगे।

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

## Load the model based on VGG19
vgg_based = torchvision.models.vgg19(pretrained=True)

## freeze the layers
for param in vgg_based.parameters():
   param.requires_grad = False

# Modify the last layer
number_features = vgg_based.classifier[6].in_features
features = list(vgg_based.classifier.children())[:-1] # Remove last layer
features.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) मॉडल को प्रशिक्षित और परीक्षण करें

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

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 = data
           inputs = 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() - since
   print('Training complete in {:.0f}m {:.0f}s'.format(
       time_elapsed // 60, time_elapsed % 60))

   return model

def visualize_model(model, num_images=6):
   was_training = model.training
   model.eval()
   images_so_far = 0
   fig = 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 += 1
               ax = 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 + mean
               ax.imshow(img)

               if images_so_far == num_images:
                   model.train(mode=was_training)
                   return
       model.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.0044
train Loss: 0.0078
train Loss: 0.0141
train Loss: 0.0221
train Loss: 0.0306
train Loss: 0.0336
train Loss: 0.0442
train Loss: 0.0482
train Loss: 0.0557
train Loss: 0.0643
train Loss: 0.0763
train Loss: 0.0779
train Loss: 0.0843
train Loss: 0.0910
train Loss: 0.0990
train Loss: 0.1063
train Loss: 0.1133
train Loss: 0.1220
train Loss: 0.1344
train Loss: 0.1382
train Loss: 0.1429
train Loss: 0.1500
Epoch 24/24
----------
train Loss: 0.0076
train Loss: 0.0115
train Loss: 0.0185
train Loss: 0.0277
train Loss: 0.0345
train Loss: 0.0420
train Loss: 0.0450
train Loss: 0.0490
train Loss: 0.0644
train Loss: 0.0755
train Loss: 0.0813
train Loss: 0.0868
train Loss: 0.0916
train Loss: 0.0980
train Loss: 0.1008
train Loss: 0.1101
train Loss: 0.1176
train Loss: 0.1282
train Loss: 0.1323
train Loss: 0.1397
train Loss: 0.1436
train Loss: 0.1467
Training complete in 2m 47s

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

सारांश

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