🈚️ 🛅 🤲🏻 शैली हस्तांतरण 🔚 👨🏾‍🔬 🚴🏿

स्टाइल ट्रांसफर स्रोत की शैली को चयनित छवि की शैली में परिवर्तित करने की प्रक्रिया है और पहले से प्रशिक्षित होने के दौरान कन्वेंशन प्रकार के नेटवर्क (CNN) पर निर्भर करता है, इसलिए बहुत कुछ इस प्रशिक्षित नेटवर्क की पसंद पर निर्भर करेगा। सौभाग्य से, ऐसे नेटवर्क हैं और चुनने के लिए बहुत कुछ है, लेकिन यहां वीजीजी -16 का उपयोग किया जाएगा।

पहले आपको आवश्यक पुस्तकालयों को कनेक्ट करना होगा

पुस्तकालय घोषणा कोड

import time import torch from torch.autograd import Variable import torch.nn as nn import torch.nn.functional as F from torch import optim import torchvision from torchvision import transforms from io import BytesIO from PIL import Image from collections import OrderedDict from google.colab import files

फिर आपको पूर्व-प्रशिक्षित नेटवर्क वीजीजी -16 के वर्ग को घोषित करने की आवश्यकता है

कक्षा कोड VGG-16

 class VGG16(nn.Module): def __init__(self, pool='max'): super(VGG, self).__init__() self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, padding=1) self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, padding=1) self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, padding=1) self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, padding=1) self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, padding=1) self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, padding=1) self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, padding=1) self.conv3_4 = nn.Conv2d(256, 256, kernel_size=3, padding=1) self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, padding=1) self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv4_4 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1) self.conv5_4 = nn.Conv2d(512, 512, kernel_size=3, padding=1) if pool == 'max': self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2) self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2) self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2) elif pool == 'avg': self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2) self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2) self.pool3 = nn.AvgPool2d(kernel_size=2, stride=2) self.pool4 = nn.AvgPool2d(kernel_size=2, stride=2) self.pool5 = nn.AvgPool2d(kernel_size=2, stride=2) def forward(self, x, layers): out = {} out['relu1_1'] = F.relu(self.conv1_1(x)) out['relu1_2'] = F.relu(self.conv1_2(out['relu1_1'])) out['pool1'] = self.pool1(out['relu1_2']) out['relu2_1'] = F.relu(self.conv2_1(out['pool1'])) out['relu2_2'] = F.relu(self.conv2_2(out['relu2_1'])) out['pool2'] = self.pool2(out['relu2_2']) out['relu3_1'] = F.relu(self.conv3_1(out['pool2'])) out['relu3_2'] = F.relu(self.conv3_2(out['relu3_1'])) out['relu3_3'] = F.relu(self.conv3_3(out['relu3_2'])) out['relu3_4'] = F.relu(self.conv3_4(out['relu3_3'])) out['pool3'] = self.pool3(out['relu3_4']) out['relu4_1'] = F.relu(self.conv4_1(out['pool3'])) out['relu4_2'] = F.relu(self.conv4_2(out['relu4_1'])) out['relu4_3'] = F.relu(self.conv4_3(out['relu4_2'])) out['relu4_4'] = F.relu(self.conv4_4(out['relu4_3'])) out['pool4'] = self.pool4(out['relu4_4']) out['relu5_1'] = F.relu(self.conv5_1(out['pool4'])) out['relu5_2'] = F.relu(self.conv5_2(out['relu5_1'])) out['relu5_3'] = F.relu(self.conv5_3(out['relu5_2'])) out['relu5_4'] = F.relu(self.conv5_4(out['relu5_3'])) out['pool5'] = self.pool5(out['relu5_4']) return [out[key] for key in layers]

अगला, आपको वीजीजी -16 भार डाउनलोड करने और लोड करने की आवश्यकता है, यदि संभव हो तो पहले इसे वीडियो कार्ड में स्थानांतरित कर दिया जाए

 vgg = VGG16() vgg.load_state_dict(torch.load('vgg_conv.pth')) for param in vgg.parameters(): param.requires_grad = False if torch.cuda.is_available(): vgg.cuda()

जहाँ vgg_conv.pth नेटवर्क वेट फ़ाइल का नाम है।

इस मामले में, नेटवर्क पर मापदंडों के प्रशिक्षण को अक्षम करना आवश्यक है, अन्यथा आप एक से अधिक दिनों के लिए प्रशिक्षित भार भार को खराब कर सकते हैं।

इसके बाद, इनपुट छवियों को परिवर्तित करने के कार्यों को उन छवियों के रूप में लाने की घोषणा की जाती है, जिन पर VGG-16 नेटवर्क को प्रशिक्षित किया गया था

इनपुट छवि रूपांतरण फ़ंक्शंस कोड

 SIZE_IMAGE = 512 to_mean_tensor = transforms.Compose([transforms.Resize(SIZE_IMAGE), transforms.ToTensor(), transforms.Lambda(lambda x: x[torch.LongTensor([2,1,0])]), transforms.Normalize(mean=[0.40760392, 0.45795686, 0.48501961], std=[1,1,1]), transforms.Lambda(lambda x: x.mul_(255)), ]) to_unmean_tensor = transforms.Compose([transforms.Lambda(lambda x: x.div_(255)), transforms.Normalize(mean=[-0.40760392, -0.45795686, -0.48501961], std=[1,1,1]), transforms.Lambda(lambda x: x[torch.LongTensor([2,1,0])]), ]) to_image = transforms.Compose([transforms.ToPILImage()]) normalize_image = lambda t: to_image(torch.clamp(to_unmean_tensor(t), min=0, max=1))

to_mean_tensor - प्रत्यक्ष रूपांतरण
normalize_image - उलटा रूपांतर

इसके बाद, ग्राम मैट्रिक्स के लिए ग्राम मैट्रिक्स कक्षाएं और हानि कार्यों की घोषणा की जाती है

 class GramMatrix(nn.Module): def forward(self, input): b,c,h,w = input.size() F = input.view(b, c, h*w) G = torch.bmm(F, F.transpose(1,2)) G.div_(h*w) return G class GramMSELoss(nn.Module): def forward(self, input, target): out = nn.MSELoss()(GramMatrix()(input), target) return out

ग्राम मैट्रिक्स शैली विवरण के स्थानिक संदर्भ को खत्म करने का कार्य करता है।

फिर स्रोत और शैली की छवियों को लोड करने और परिवर्तित करने की प्रक्रिया आती है

 imgs = [style_img, content_img] imgs_torch = [to_mean_tensor(img) for img in imgs] if torch.cuda.is_available(): imgs_torch = [Variable(img.unsqueeze(0).cuda()) for img in imgs_torch] else: imgs_torch = [Variable(img.unsqueeze(0)) for img in imgs_torch] style_image, content_image = imgs_torch opt_img = Variable(content_image.data.clone(), requires_grad=True)

जहाँ style_img और content_img ऐसी इनपुट छवियां हैं, जिन्हें टेंसरों में परिवर्तित किया जाता है और यदि संभव हो तो वीडियो कार्ड में स्थानांतरित कर दिया जाता है, और Opt_img में शैली हस्तांतरण का परिणाम होगा, और मूल छवि को प्रारंभिक के रूप में लिया जाएगा।

अगला परतों का चयन करने, वजन निर्धारित करने और नुकसान कार्यों को शुरू करने की प्रक्रिया है

वजन और हानि कोड

 style_layers = ['relu1_1','relu2_1','relu3_1','relu4_1', 'relu5_1'] content_layers = ['relu4_2'] loss_layers = style_layers + content_layers losses = [GramMSELoss()] * len(style_layers) + [nn.MSELoss()] * len(content_layers) if torch.cuda.is_available(): losses = [loss.cuda() for loss in losses] style_weights = [1e3/n**2 for n in [64,128,256,512,512]] content_weights = [1e0] weights = style_weights + content_weights style_targets = [GramMatrix()(A).detach() for A in vgg(style_image, style_layers)] content_targets = [A.detach() for A in vgg(content_image, content_layers)] targets = style_targets + content_targets

और अंतिम चरण शैली को स्थानांतरित करने की प्रक्रिया है

 epochs = 300 opt = optim.LBFGS([opt_img]) def step_opt(): opt.zero_grad() out_layers = vgg(opt_img, loss_layers) layer_losses = [] for j, out in enumerate(out_layers): layer_losses.append(weights[j] * losses[j](out, targets[j])) loss = sum(layer_losses) loss.backward() return loss for i in range(0, epochs+1): loss = opt.step(step_opt)

निष्कर्ष में, आप कुछ उदाहरण जोड़ सकते हैं:

शैली हस्तांतरण

More articles: