【神經網絡與深度學習】neural-style、chainer-fast-neuralstyle圖像風格轉換使用

時間 2019-11-06

標籤神經網絡與深度學習 neural style chainer fast neuralstyle 圖像風格轉換使用简体版

原文原文鏈接

neural-style 官方地址:這個是使用torch7實現的;torch7安裝比較麻煩.我這裏使用的是大神使用TensorFlow實現的https://github.com/anishathalye/neural-stylecss

1. 安裝
個人操做系統是win10,裝了Anaconda,TensorFlow包是經過pip安裝的,中間沒什麼可說的.具體看TensorFlow官網就能夠了.
2. 使用html

python neural_style.py --content <content file> --styles <style file> --output <output file>

把參數替換成本身的,運行這個語句就能跑起來,由於個人電腦的顯卡不是NVIDIA的,只能用CPU跑,特別慢,一張圖片跑了三個小時.出來的效果跟大神在github上給出的同樣.

python

因爲上面的跑的太慢了,介紹一下下面這個快速生成風格圖:地址:https://github.com/yusuketomoto/chainer-fast-neuralstylegit

這個須要安裝Chainer 框架,官方的文檔上不推薦使用windows系統,不過我裝上去測試了一下也沒什麼問題.github

安裝
這裏要安利一下Anaconda,對使用Python作數據挖掘,深度學習等,真的是很是方便,若是你沒有安裝這個框架須要按照官方的文檔把Chainer一來的幾個庫都安裝一下,具體的本身百度吧.(我在本身的Ubuntu虛擬機上安裝Pillow庫的時候就怎麼也裝不上,後來按照這個連接http://www.jianshu.com/p/c83e7a599eea解決了)
使用
這裏重點說一下,我運行以後報:ValueError: test argument is not supported anymore. Use chainer.using_config這個錯誤,百度了一圈也找不到問題,後來去看了一下這個倉庫的issues,上面有人說

看了半天在generate.py沒找到在哪去掉test,仔細看了一下報錯的位置發現是在net.py裏面

import math

import numpy as np
import chainer
import chainer.links as L
import chainer.functions as F
from chainer import Variable

class ResidualBlock(chainer.Chain):
    def __init__(self, n_in, n_out, stride=1, ksize=3):
        w = math.sqrt(2)
        super(ResidualBlock, self).__init__(
            c1=L.Convolution2D(n_in, n_out, ksize, stride, 1, w),
            c2=L.Convolution2D(n_out, n_out, ksize, 1, 1, w),
            b1=L.BatchNormalization(n_out),
            b2=L.BatchNormalization(n_out)
        )

    def __call__(self, x, test): **#把這裏的test去掉**
        h = F.relu(self.b1(self.c1(x), test=test))
        h = self.b2(self.c2(h), test=test)
        if x.data.shape != h.data.shape:
            xp = chainer.cuda.get_array_module(x.data)
            n, c, hh, ww = x.data.shape
            pad_c = h.data.shape[1] - c
            p = xp.zeros((n, pad_c, hh, ww), dtype=xp.float32)
            p = chainer.Variable(p, volatile=test)
            x = F.concat((p, x))
            if x.data.shape[2:] != h.data.shape[2:]:
                x = F.average_pooling_2d(x, 1, 2)
        return h + x

class FastStyleNet(chainer.Chain):
    def __init__(self):
        super(FastStyleNet, self).__init__(
            c1=L.Convolution2D(3, 32, 9, stride=1, pad=4),
            c2=L.Convolution2D(32, 64, 4, stride=2, pad=1),
            c3=L.Convolution2D(64, 128, 4,stride=2, pad=1),
            r1=ResidualBlock(128, 128),
            r2=ResidualBlock(128, 128),
            r3=ResidualBlock(128, 128),
            r4=ResidualBlock(128, 128),
            r5=ResidualBlock(128, 128),
            d1=L.Deconvolution2D(128, 64, 4, stride=2, pad=1),
            d2=L.Deconvolution2D(64, 32, 4, stride=2, pad=1),
            d3=L.Deconvolution2D(32, 3, 9, stride=1, pad=4),
            b1=L.BatchNormalization(32),
            b2=L.BatchNormalization(64),
            b3=L.BatchNormalization(128),
            b4=L.BatchNormalization(64),
            b5=L.BatchNormalization(32),
        )
    ***#把這個函數裏面的test參數全都去掉***
    def __call__(self, x, test=False):
        h = self.b1(F.elu(self.c1(x)), test=test)
        h = self.b2(F.elu(self.c2(h)), test=test)
        h = self.b3(F.elu(self.c3(h)), test=test)
        h = self.r1(h, test=test)
        h = self.r2(h, test=test)
        h = self.r3(h, test=test)
        h = self.r4(h, test=test)
        h = self.r5(h, test=test)
        h = self.b4(F.elu(self.d1(h)), test=test)
        h = self.b5(F.elu(self.d2(h)), test=test)
        y = self.d3(h)
        return (F.tanh(y)+1)*127.5

class VGG(chainer.Chain):
    def __init__(self):
        super(VGG, self).__init__(
            conv1_1=L.Convolution2D(3, 64, 3, stride=1, pad=1),
            conv1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1),

            conv2_1=L.Convolution2D(64, 128, 3, stride=1, pad=1),
            conv2_2=L.Convolution2D(128, 128, 3, stride=1, pad=1),

            conv3_1=L.Convolution2D(128, 256, 3, stride=1, pad=1),
            conv3_2=L.Convolution2D(256, 256, 3, stride=1, pad=1),
            conv3_3=L.Convolution2D(256, 256, 3, stride=1, pad=1),

            conv4_1=L.Convolution2D(256, 512, 3, stride=1, pad=1),
            conv4_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv4_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),

            conv5_1=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv5_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv5_3=L.Convolution2D(512, 512, 3, stride=1, pad=1)
        )
        self.train = False
        self.mean = np.asarray(120, dtype=np.float32)

    def preprocess(self, image):
        return np.rollaxis(image - self.mean, 2)

    def __call__(self, x):
        y1 = F.relu(self.conv1_2(F.relu(self.conv1_1(x))))
        h = F.max_pooling_2d(y1, 2, stride=2)
        y2 = F.relu(self.conv2_2(F.relu(self.conv2_1(h))))
        h = F.max_pooling_2d(y2, 2, stride=2)
        y3 = F.relu(self.conv3_3(F.relu(self.conv3_2(F.relu(self.conv3_1(h))))))
        h = F.max_pooling_2d(y3, 2, stride=2)
        y4 = F.relu(self.conv4_3(F.relu(self.conv4_2(F.relu(self.conv4_1(h))))))
        return [y1, y2, y3, y4]