Изменения

[[Файл:Image1.jpeg|500px|thumb|right|[https://towardsdatascience.com/neural-style-transfer-tutorial-part-1-f5cd3315fa7f Рис. 1. Принцип работы алгоритма]]]Алгоритм '''нейронного переноса стиля''' <ref>[https://arxiv.org/pdf/1508.06576.pdf Gatys, L.A., Ecker, A.S., Bethge, M.: A neural algorithm of artistic style, 2015]</ref> (англ. ''Neural Style Transfer''), разработанный Леоном Гатисом, Александром Экером и Матиасом Бетге, позволяет получить преобразует полученное на вход изображение и воспроизводить его в новом художественном стилесоответствии с выбранным стилем. Алгоритм берет три изображения, входное изображение (англ. ''input image''), изображение контента (англ. ''content image'') и изображение стиля (англ. ''style image''), и изменяет входные данные так, чтобы они соответствовали содержанию изображения контента и художественному стилю изображения стиля. Авторами в качестве модели сверточной нейронной сети предлагается использовать сеть [https://neurohive.io/ru/vidy-nejrosetej/vgg16-model/ [Сверточные_нейронные_сети#VGG | VGG16]].

[[Файл:Image2.png|500px|thumb|right|[https://towardsdatascience.com/neural-style-transfer-tutorial-part-1-f5cd3315fa7f Рис. 2. Архитектура сверточной сети VGG16]]]

Рассмотрим 1-й [[Сверточные_нейронные_сети#Сверточный слой | сверточный слой ]] (англ. ''convolution layer'') VGG16, который использует ядро 3x3 и обучает 64 карты признаков (англ. ''feature map'') для генерации представления изображения размерности 224x224x64, принимая 3-канальное изображение размером 224x224 в качестве входных данных (''Рисунок 32''). Во время обучения эти карты признаков научились обнаруживать простые шаблоны, например, такие как прямые линии, окружности или даже не имеющие никакого смысла для человеческого глаза шаблоны, которые тем не менее имеют огромное значение для этой модели. Такое "обнаружение" шаблонов называется обучением представления признаков. Теперь давайте рассмотрим 10-й сверточный слой VGG16, который использует ядро 3x3 с 512 картами признаков для обучения и в итоге генерирует вывод представления изображения размерности 28x28x512. Нейроны 10-го слоя уже могут обнаруживать более сложные шаблоны такие как, например, колесо автомобиля, окно или дерево и т.д.

Собственно вышеперечисленные свойства характерны для любой [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%B2%D0%B5%D1%80%D1%82%D0%BE%D1%87%D0%BD%D1%8B%D0%B5_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8 [Сверточные_нейронные_сети | сверточной нейронной сети]], работа которой обычно интерпретируется как переход от конкретных особенностей изображения к более абстрактным деталям, и далее к ещё более абстрактным деталям вплоть до выделения понятий высокого уровня. При этом сеть самонастраивается и вырабатывает необходимую иерархию абстрактных признаков (последовательности карт признаков), фильтруя маловажные детали и выделяя существенное.

Следовательно, имеет смысл использовать разницу в значении представления признаков сгенерированного изображения по содержанию и по стилю изображения, чтобы направлять итерации, через которые мы производим само сгенерированное изображение, но как убедиться, что изображение с содержанием '''C''' и сгенерированное изображение '''G''' похожи по своему содержанию, а не по стилю, в то время как сгенерированное изображение наследует только похожее представление стиля изображения стиля '''S''', а не само изображение стиля в целом. Это решается разделением функции потерь на две части: одна {{- --}} потеря контента, а другая {{--- }} потеря стиля.

В уравнении выше, чтобы получить общую потерю <math>L_{total}</math> нужно рассчитать потерю содержимого <math>L_{content}</math> и потерю стиля <math>L_{style}</math>, а также <math>\alpha</math> и <math>\beta</math> {{- --}} гиперпараметры, которые используются для определения весов для каждого типа потерь, то есть эти параметры можно представить просто как "рычаги" для управления тем, сколько контента / стиля мы хотим наследовать в сгенерированном изображении.

[[Файл:Image6.jpeg|500px|thumb|right|[https://towardsdatascience.com/neural-style-transfer-tutorial-part-1-f5cd3315fa7f Рис. 3. Различные представления, используемые для изображений контента, стиля и сгенерированного изображения]]]

 <math>L_{content}(C, G, L) = \frac{1}{2} \sum\limits_{ij}(a[l](C)_{ij} - a[Файл:Image7.jpeg|500px|center]l](G)_{ij})^2</math>

Рассмотрим, как мы передаем наше изображение стиля через VGG16 и получаем значения функции активации из 7-го уровня, который генерирует матрицу представления объектов размером 56x56x256.В этом трехмерном массиве имеется 256 каналов размером 56x56 каждый. Теперь предположим, что есть канал ''A'', чьи блоки активации могут активироваться, когда они сталкиваются с разделом изображения, содержащим коричнево-черные полосы, а затем есть канал ''B'', чьи блоки активации могут активироваться, когда они сталкиваются с чем-то похожим на глазное яблоко. Если оба этих канала ''A'' и ''B'' активируются вместе для одного и того же входа, существует высокая вероятность того, что изображение может содержать лицо тигра (поскольку у него было два канала с высокими значениями, которые активируются для глазного яблока и коричнево-черных полос). Теперь, если оба эти канала будут запущены с высокими значениями активации, это означает, что они будут иметь высокую корреляцию по сравнению с корреляцией между каналом ''A'' и ''С'', где канал ''С'' может активироваться, когда он видит ромбовидный шаблон. Таким образом, чтобы получить корреляцию всех этих каналов друг с другом, нам нужно вычислить нечто называемое матрицей Грама, будем использовать ее для измерения степени корреляции между каналами, которая позже будет служить мерой самого стиля. === Функция потерь на основе корреляции матриц Грама === Теперь, как вы можете видеть, как каждый элемент матрицы Грама содержит меру корреляции всех каналов относительно друг друга. Обозначим матрицу Грама стилевого изображения слоя <math>l</math> как <math>GM[l](S)</math>, а матрицу Грама сгенерированного изображения того же слоя <math>GM[Файл:Image8l](G)</math>.jpeg|500px|thumb|right|РисОбе матрицы были вычислены из одного и того же слоя, следовательно, с использованием одного и того же числа каналов, что привело к тому, что итоговая матрица размера <math>channels \times channels</math>. 4Теперь, если мы найдем сумму квадратов разности или L2-норму вычитания элементов этих двух матриц и попытаемся минимизировать ее, то в конечном итоге это приведет к минимизации разницы между изображением стиля и сгенерированным изображением. Принцип рассчет матрицы Грама <math>L_{GM}(S, G, l) = \frac{1}{4N_l^2M_l^2} \sum\limits_{ij}(GM[l](S)_{ij} - GM[l](G)_{ij})^2</math> В вышеприведенном уравнении <math>N_{l}</math> представляет номер канала в карте признаков / выходных данных уровня <math>l</math>, а <math>M_{l}</math> представляет <math>height*width</math> карты признаков / выходных данных слоя <math>l</math>. Так как при вычислении потери стиля мы используем несколько уровней активации, это позволяет назначать разные весовые коэффициенты для потери на каждом уровне. <math>L_{style}(S, G) = \sum\limits_{l=0}^L w_l * L_{GM}(S, G, l)</math> == Пример кода на Python ==

Я попытаюсь создать основу, необходимую для понимания матрицы грамм, Данный пример реализован на примереоснове [http://neerc. Итак, давайте рассмотрим, как мы передаем наше изображение стиля через vgg16 и получаем значения активации из 7-го уровня, который генерирует матрицу представления объектов размером 56x56x256, которую вы можете использовать на рисунке 2, который описывает архитектуру vgg16ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D0%B7%D0%BE%D1%80_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA_%D0%B4%D0%BB%D1%8F_%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BD%D0%B0_Python#.D0.91.D0.B8.D0.B1.D0.BB.D0.B8.D0.BE.D1.82.D0.B5.D0.BA.D0.B8_.D0.B4.D0.BB.D1.8F_.D0.B3.D0.BB.D1.83.D0.B1.D0.BE.D0.BA.D0.BE.D0.B3.D0.BE_.D0.BE.D0.B1.D1.83.D1.87.D0.B5.D0.BD.D0.B8. Теперь давайте подробнее рассмотрим этот выводD1.8F открытой платформы глубокого обучения PyTorch]

В этом 3-D массиве имеется 256 каналов размером 56x56 каждый'''Функция потери контента''' '''class''' ContentLoss(nn. Теперь давайте предположимModule): '''def''' __init__(self, что есть канал ‘A’target, чьи блоки активации могут активироваться): super(ContentLoss, когда они сталкиваются с разделом изображенияself).__init__() <font color="green"># we 'detach' the target content from the tree used</font> <font color="green"># to dynamically compute the gradient: this is a stated value, содержащим черные и коричневые полосы</font> <font color="green"># not a variable. Otherwise the forward method of the criterion</font> <font color="green"># will throw an error.</font> self.target = target.detach() '''def''' forward(self, а затем есть канал ‘B’input): self.loss = F.mse_loss(input, чьи блоки активации могут активироваться, когда они сталкиваются с чем-то похожим на глазное яблокоself.target) return input

Примечание'''Функция потери стиля''' '''def''' gram_matrix(input): здесь активируемые юниты относятся к ним a, имеющим значительно большую ценность по сравнению с нулем после прохождения через relub, c, d = input.size() <font color="green"># a=batch size(=1)</font> <font color="green"># b=number of feature maps</font> <font color="green"># (c,d)=dimensions of a f. map (N=c*d)</font> features = input.view(a * b, c * d) <font color="green"># resise F_XL into \hat F_XL</font> G = torch.mm(features, features.t()) <font color="green"># compute the gram product</font> <font color="green"># we 'normalize' the values of the gram matrix</font> <font color="green"># by dividing by the number of element in each feature maps.</font> return G.div(a * b * c * d)

Если оба этих канала ‘A’ & ‘B’ активируются вместе для одного и того же входа '''class''' StyleLoss(nn.Module): '''def''' __init__(self, существует высокая вероятность тогоtarget_feature): super(StyleLoss, что изображение может содержать лицо тигра self).__init__() self.target = gram_matrix(поскольку у него было два канала с высокими значениями, которые активируются для глазного яблока и коричневых черных полосtarget_feature) , Теперь, если оба эти канала будут запущены с высокими значениями активации, это означает, что они будут иметь высокую корреляцию по сравнению с корреляцией между каналом ‘A’ & ‘C’, где канал ‘C’ может активироваться, когда он видит ромбовидный шаблон.detach() Таким образом '''def''' forward(self, чтобы получить корреляцию всех этих каналов друг с другом, нам нужно вычислить что-то, называемое граммовой матрицей, мы будем использовать грамм-матрицу для измерения степени корреляции между каналами, которая позже будет служить мерой самого стиляinput): G = gram_matrix(input) self.loss = F. Теперь выmse_loss(G, возможно, поняли значение грамм-матрицы, но чтобы понять, как мы получаем грамм-матрицу из вышеупомянутого трехмерного массива, рассмотрим изображение, упомянутое нижеself.target) return input

Теперь, как вы можете видеть, как каждый элемент этой граммовой матрицы содержит меру корреляции всех каналов относительно друг друга'''Инициализация модели''' cnn = models. Продвигаясь вперед, как мы используем эту вычисленную матрицу Грамма G для расчета потери стиляvgg19(pretrained=True).features. Обозначим грамм-матрицу стилевого изображения слоя L как GM[L]to(Sdevice), а грамм-матрицу сгенерированного изображения того же слоя, что и GM[L].eval(G). Обе матрицы грамм были вычислены из одного и того же слоя, следовательно, с использованием одного и того же числа каналов, что привело к тому, что он стал матрицей размера ch x ch. Теперь, если мы найдем сумму квадратичной разности или L2_norm вычитания элементов этих двух матриц и попытаемся минимизировать это, то это в конечном итоге приведет к минимизации разницы между стилем изображения изображения и сгенерированного изображения. Подумайте об этом, это может занять некоторое время, но когда это произойдет, вы будете загипнотизированы тем, насколько это просто, но эффективно.

'''Нормализация''' cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device) cnn_normalization_std = torch.tensor([Файл0.229, 0.224, 0.225]).to(device) <font color="green"># create a module to normalize input image so we can easily put it in a</font> <font color="green"># nn.Sequential</font> '''class''' Normalization(nn.Module): '''def''' __init__(self, mean, std):Image10 super(Normalization, self).jpeg|500px|center__init__() <font color="green"># .view the mean and std to make them [C x 1 x 1]so that they can</font> <font color="green"># directly work with image Tensor of shape [B x C x H x W].</font> <font color="green"># B is batch size. C is number of channels. H is height and W is width.</font> self.mean = torch.tensor(mean).view(-1, 1, 1) self.std = torch.tensor(std).view(-1, 1, 1) '''def''' forward(self, img): <font color="green"># normalize img</font> return (img - self.mean) / self.std

В вышеприведенном уравнении N_l представляет номер канала в карте признаков '''Добавление собственных слоев''' <font color="green"># desired depth layers to compute style/ выходных данных уровня lcontent losses :</font> content_layers_default = ['conv_4'] style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] '''def''' get_style_model_and_losses(cnn, normalization_mean, normalization_std, style_img, content_img, content_layers=content_layers_default, style_layers=style_layers_default): cnn = copy.deepcopy(cnn) <font color="green"># normalization module</font> normalization = Normalization(normalization_mean, normalization_std).to(device) <font color="green"># just in order to have an iterable access to or list of content/style losses</font> content_losses = [] style_losses = [] <font color="green"># assuming that cnn is a nn.Sequential, so we make a new nn.Sequential</font> <font color="green"># to put in modules that are supposed to be activated sequentially</font> model = nn.Sequential(normalization) i = 0 <font color="green"># increment every time we see a conv</font> for layer in cnn.children(): if isinstance(layer, nn.Conv2d): i += 1 name = 'conv_{}'.format(i) elif isinstance(layer, nn.ReLU): name = 'relu_{}'.format(i) <font color="green"># The in-place version doesn't play very nicely with the ContentLoss</font> <font color="green"># and StyleLoss we insert below. So we replace with out-of-place</font> <font color="green"># ones here.</font> layer = nn.ReLU(inplace=False) elif isinstance(layer, nn.MaxPool2d): name = 'pool_{}'.format(i) elif isinstance(layer, nn.BatchNorm2d): name = 'bn_{}'.format(i) else: raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__)) model.add_module(name, layer) if name in content_layers: <font color="green"># add content loss:</font> target = model(content_img).detach() content_loss = ContentLoss(target) model.add_module("content_loss_{}".format(i), а M_l представляет высоту * ширину карты объектов content_loss) content_losses.append(content_loss) if name in style_layers: <font color="green"># add style loss:</ выходных данных слоя lfont> target_feature = model(style_img).detach() style_loss = StyleLoss(target_feature) model.add_module("style_loss_{}".format(i), style_loss) style_losses.append(style_loss) <font color="green"># now we trim off the layers after the last content and style losses</font> for i in range(len(model) - 1, -1, -1): if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss): break model = model[:(i + 1)] return model, style_losses, content_losses

В то время как при вычислении потери стиля мы используем несколько уровней активации, эти сценарии приводят нас к возможности назначать разные весовые коэффициенты для каждой подпотери, предоставляемой разными уровнями'''Градиентный спуск''' '''def''' get_input_optimizer(input_img): <font color="green"># this line to show that input is a parameter that requires a gradient</font> optimizer = optim. ниже уравнения суммирует то, что я только что сказал, довольно элегантно, но в нашем случае или в большинстве случаев в целом люди дают одинаковый вес для всех слоевLBFGS([input_img.requires_grad_()]) return optimizer

'''Запуск алгоритма''' '''def''' run_style_transfer(cnn, normalization_mean, normalization_std, content_img, style_img, input_img, num_steps=300, style_weight=1000000, content_weight=1): print('Building the style transfer model..') model, style_losses, content_losses = get_style_model_and_losses(cnn, normalization_mean, normalization_std, style_img, content_img) optimizer = get_input_optimizer(input_img) run = [0] while run[Файл0] <= num_steps: def closure(): <font color="green"># correct the values of updated input image</font> input_img.data.clamp_(0, 1) optimizer.zero_grad() model(input_img) style_score = 0 content_score = 0 for sl in style_losses: style_score += sl.loss for cl in content_losses:Image11 content_score += cl.loss style_score *= style_weight content_score *= content_weight loss = style_score + content_score loss.jpeg|500px|centerbackward() run[0]+= 1 if run[0]% 50 == 0: print("run {}:".format(run)) print('Style Loss : {:4f} Content Loss: {:4f}'.format( style_score.item(), content_score.item())) print() return style_score + content_score optimizer.step(closure) <font color="green"># a last correction...</font> input_img.data.clamp_(0, 1) return input_img <font color="green"># run style transfer</font> output = run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std, content_img, style_img, input_img)

== Пример кода на PyTorch См. также==* [https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C Свёрточная нейронная сеть]* [https://ethereon.github.io/netscope/#/gist/3785162f95cd2d5fee77 Интерактивная архитектура сети VGG16]

def __init__(self, target,)== Источники информации ==* [https: super(ContentLoss, self)//towardsdatascience.__init__()com/neural-style-transfer-tutorial-part-1-f5cd3315fa7f Theory of Neural Style Transfer] # we 'detach' the target content from the tree used # to dynamically compute the gradient* [https: this is a stated value, # not a variable//towardsdatascience. Otherwise the forward method com/neural-style-transfer-series-part-2-91baad306b24 TensorFlow and pyTorch Implementation of the criterionNeural Style Transfer] # will throw an error. self* [https://pytorch.target = targetorg/tutorials/advanced/neural_style_tutorial.detach()html Neural Style Transfer using PyTorch]

def forward(self, input)[[Категория:Машинное обучение]] self.loss = F.mse_loss(input, self.target)[[Категория: Нейронные сети]] return input[[Категория: Сверточные нейронные сети]]