0 前言

?? 這兩年開始畢業(yè)設計和畢業(yè)答辯的要求和難度不斷提升，傳統(tǒng)的畢設題目缺少創(chuàng)新和亮點，往往達不到畢業(yè)答辯的要求，這兩年不斷有學弟學妹告訴學長自己做的項目系統(tǒng)達不到老師的要求。

為了大家能夠順利以及最少的精力通過畢設，學長分享優(yōu)質(zhì)畢業(yè)設計項目，今天要分享的是

?? 畢設 深度學習圖像風格遷移 - opencv python

??學長這里給一個題目綜合評分(每項滿分5分)

• 難度系數(shù)：3分
• 工作量：3分
• 創(chuàng)新點：4分

?? 選題指導, 項目分享：

https://gitee.com/dancheng-senior/project-sharing-1/blob/master/%E6%AF%95%E8%AE%BE%E6%8C%87%E5%AF%BC/README.md

圖片風格遷移指的是將一個圖片的風格轉換到另一個圖片中，如圖所示：

原圖片經(jīng)過一系列的特征變換，具有了新的紋理特征，這就叫做風格遷移。

1 VGG網(wǎng)絡

在實現(xiàn)風格遷移之前，需要先簡單了解一下VGG網(wǎng)絡（由于VGG網(wǎng)絡不斷使用卷積提取特征的網(wǎng)絡結構和準確的圖像識別效率，在這里我們使用VGG網(wǎng)絡來進行圖像的風格遷移）。

如上圖所示，從A-E的每一列都表示了VGG網(wǎng)絡的結構原理，其分別為：VGG-11，VGG-13，VGG-16，VGG-19，如下圖，一副圖片經(jīng)過VGG-19網(wǎng)絡結構可以最后得到一個分類結構。

2 風格遷移

對一副圖像進行風格遷移，需要清楚的有兩點。

• 生成的圖像需要具有原圖片的內(nèi)容特征
• 生成的圖像需要具有風格圖片的紋理特征

根據(jù)這兩點，可以確定，要想實現(xiàn)風格遷移，需要有兩個loss值：
一個是生成圖片的內(nèi)容特征與原圖的內(nèi)容特征的loss，另一個是生成圖片的紋理特征與風格圖片的紋理特征的loss。

而對一張圖片進行不同的特征（內(nèi)容特征和紋理特征）提取，只需要使用不同的卷積結構進行訓練即可以得到。這時我們需要用到兩個神經(jīng)網(wǎng)絡。

再回到VGG網(wǎng)絡上，VGG網(wǎng)絡不斷使用卷積層來提取特征，利用特征將物品進行分類，所以該網(wǎng)絡中提取內(nèi)容和紋理特征的參數(shù)都可以進行遷移使用。故需要將生成的圖片經(jīng)過VGG網(wǎng)絡的特征提取，再分別針對內(nèi)容和紋理進行特征的loss計算。

如圖，假設初始化圖像x（Input image）是一張隨機圖片，我們經(jīng)過fw（image Transform Net）網(wǎng)絡進行生成，生成圖片y。
此時y需要和風格圖片ys進行特征的計算得到一個loss_style，與內(nèi)容圖片yc進行特征的計算得到一個loss_content，假設loss=loss_style+loss_content，便可以對fw的網(wǎng)絡參數(shù)進行訓練。

現(xiàn)在就可以看網(wǎng)上很常見的一張圖片了：

相較于我畫的第一張圖，這即對VGG內(nèi)的loss求值過程進行了細化。

細化的結果可以分為兩個方面：

• （1）內(nèi)容損失
• （2）風格損失

3 內(nèi)容損失

由于上圖中使用的模型是VGG-16，那么即相當于在VGG-16的relu3-3處，對兩張圖片求得的特征進行計算求損失，計算的函數(shù)如下：

簡言之，假設yc求得的特征矩陣是φ(y)，生成圖片求得的特征矩陣為φ(y^)，且c=φ.channel，w=φ.weight，h=φ.height，則有：

代碼實現(xiàn)：

def content_loss(content_img, rand_img):
    content_layers = [('relu3_3', 1.0)]
    content_loss = 0.0
    # 逐個取出衡量內(nèi)容損失的vgg層名稱及對應權重
    for layer_name, weight in content_layers:

        # 計算特征矩陣
        p = get_vgg(content_img, layer_name)
        x = get_vgg(rand_img, layer_name)
        # 長x寬xchannel
        M = p.shape[1] * p.shape[2] * p.shape[3]

        # 根據(jù)公式計算損失，并進行累加
        content_loss += (1.0 / M) * tf.reduce_sum(tf.pow(p - x, 2)) * weight

    # 將損失對層數(shù)取平均
    content_loss /= len(content_layers)
    return content_loss

4 風格損失

風格損失由多個特征一同計算，首先需要計算Gram Matrix

Gram Matrix實際上可看做是feature之間的偏心協(xié)方差矩陣（即沒有減去均值的協(xié)方差矩陣），在feature map中，每一個數(shù)字都來自于一個特定濾波器在特定位置的卷積，因此每個數(shù)字就代表一個特征的強度，而Gram計算的實際上是兩兩特征之間的相關性，哪兩個特征是同時出現(xiàn)的，哪兩個是此消彼長的等等，同時，Gram的對角線元素，還體現(xiàn)了每個特征在圖像中出現(xiàn)的量，因此，Gram有助于把握整個圖像的大體風格。有了表示風格的Gram Matrix，要度量兩個圖像風格的差異，只需比較他們Gram Matrix的差異即可。 故在計算損失的時候函數(shù)如下：

在實際使用時，該loss的層級一般選擇由低到高的多個層，比如VGG16中的第2、4、7、10個卷積層，然后將每一層的style loss相加。

第三個部分不是必須的，被稱為Total Variation Loss。實際上是一個平滑項（一個正則化項），目的是使生成的圖像在局部上盡可能平滑，而它的定義和馬爾科夫隨機場（MRF）中使用的平滑項非常相似。 其中yn+1是yn的相鄰像素。

代碼實現(xiàn)以上函數(shù)：

# 求gamm矩陣
def gram(x, size, deep):
    x = tf.reshape(x, (size, deep))
    g = tf.matmul(tf.transpose(x), x)
    return g

def style_loss(style_img, rand_img):
    style_layers = [('relu1_2', 0.25), ('relu2_2', 0.25), ('relu3_3', 0.25), ('reluv4_3', 0.25)]
    style_loss = 0.0
    # 逐個取出衡量風格損失的vgg層名稱及對應權重
    for layer_name, weight in style_layers:

        # 計算特征矩陣
        a = get_vgg(style_img, layer_name)
        x = get_vgg(rand_img, layer_name)

        # 長x寬
        M = a.shape[1] * a.shape[2]
        N = a.shape[3]

        # 計算gram矩陣
        A = gram(a, M, N)
        G = gram(x, M, N)

        # 根據(jù)公式計算損失，并進行累加
        style_loss += (1.0 / (4 * M * M * N * N)) * tf.reduce_sum(tf.pow(G - A, 2)) * weight
    # 將損失對層數(shù)取平均
    style_loss /= len(style_layers)
    return style_loss

5 主代碼實現(xiàn)

代碼實現(xiàn)主要分為4步：

• 1、隨機生成圖片
• 2、讀取內(nèi)容和風格圖片
• 3、計算總的loss
• 4、訓練修改生成圖片的參數(shù)，使得loss最小

def main():
    # 生成圖片
    rand_img = tf.Variable(random_img(WIGHT, HEIGHT), dtype=tf.float32）
    with tf.Session() as sess:

        content_img = cv2.imread('content.jpg')
        style_img = cv2.imread('style.jpg')

        # 計算loss值
        cost = ALPHA * content_loss(content_img, rand_img) + BETA * style_loss(style_img, rand_img)
        optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(cost)

        sess.run(tf.global_variables_initializer())
        
        for step in range(TRAIN_STEPS):
            # 訓練
            sess.run([optimizer,  rand_img])

            if step % 50 == 0:
                img = sess.run(rand_img)
                img = np.clip(img, 0, 255).astype(np.uint8)
                name = OUTPUT_IMAGE + "http://" + str(step) + ".jpg"
                cv2.imwrite(name, img)

6 遷移模型實現(xiàn)

由于在進行l(wèi)oss值求解時，需要在多個網(wǎng)絡層求得特征值，并根據(jù)特征值進行帶權求和，所以需要根據(jù)已有的VGG網(wǎng)絡，取其參數(shù)，重新建立VGG網(wǎng)絡。
注意：在這里使用到的是VGG-19網(wǎng)絡：

在重建的之前，首先應該下載Google已經(jīng)訓練好的VGG-19網(wǎng)絡，以便提取出已經(jīng)訓練好的參數(shù)，在重建的VGG-19網(wǎng)絡中重新利用。

下載得到.mat文件以后，便可以進行網(wǎng)絡重建了。已知VGG-19網(wǎng)絡的網(wǎng)絡結構如上述圖1中的E網(wǎng)絡，則可以根據(jù)E網(wǎng)絡的結構對網(wǎng)絡重建，VGG-19網(wǎng)絡：

進行重建即根據(jù)VGG-19模型的結構重新創(chuàng)建一個結構相同的神經(jīng)網(wǎng)絡，提取出已經(jīng)訓練好的參數(shù)作為新的網(wǎng)絡的參數(shù)，設置為不可改變的常量即可。

def vgg19():
    layers=(
        'conv1_1','relu1_1','conv1_2','relu1_2','pool1',
        'conv2_1','relu2_1','conv2_2','relu2_2','pool2',
        'conv3_1','relu3_1','conv3_2','relu3_2','conv3_3','relu3_3','conv3_4','relu3_4','pool3',
        'conv4_1','relu4_1','conv4_2','relu4_2','conv4_3','relu4_3','conv4_4','relu4_4','pool4',
        'conv5_1','relu5_1','conv5_2','relu5_2','conv5_3','relu5_3','conv5_4','relu5_4','pool5'
    )
    vgg = scipy.io.loadmat('D://python//imagenet-vgg-verydeep-19.mat')
    weights = vgg['layers'][0]

    network={}
    net = tf.Variable(np.zeros([1, 300, 450, 3]), dtype=tf.float32)
    network['input'] = net
    for i,name in enumerate(layers):
        layer_type=name[:4]
        if layer_type=='conv':
            kernels = weights[i][0][0][0][0][0]
            bias = weights[i][0][0][0][0][1]
            conv=tf.nn.conv2d(net,tf.constant(kernels),strides=(1,1,1,1),padding='SAME',name=name)
            net=tf.nn.relu(conv + bias)
        elif layer_type=='pool':
            net=tf.nn.max_pool(net,ksize=(1,2,2,1),strides=(1,2,2,1),padding='SAME')
        network[name]=net
    return network

由于計算風格特征和內(nèi)容特征時數(shù)據(jù)都不會改變，所以為了節(jié)省訓練時間，在訓練之前先計算出特征結果(該函數(shù)封裝在以下代碼get_neck()函數(shù)中)。

總的代碼如下：

import tensorflow as tf
import numpy as np
import scipy.io
import cv2
import scipy.misc

HEIGHT = 300
WIGHT = 450
LEARNING_RATE = 1.0
NOISE = 0.5
ALPHA = 1
BETA = 500

TRAIN_STEPS = 200

OUTPUT_IMAGE = "D://python//img"
STYLE_LAUERS = [('conv1_1', 0.2), ('conv2_1', 0.2), ('conv3_1', 0.2), ('conv4_1', 0.2), ('conv5_1', 0.2)]
CONTENT_LAYERS = [('conv4_2', 0.5), ('conv5_2',0.5)]


def vgg19():
    layers=(
        'conv1_1','relu1_1','conv1_2','relu1_2','pool1',
        'conv2_1','relu2_1','conv2_2','relu2_2','pool2',
        'conv3_1','relu3_1','conv3_2','relu3_2','conv3_3','relu3_3','conv3_4','relu3_4','pool3',
        'conv4_1','relu4_1','conv4_2','relu4_2','conv4_3','relu4_3','conv4_4','relu4_4','pool4',
        'conv5_1','relu5_1','conv5_2','relu5_2','conv5_3','relu5_3','conv5_4','relu5_4','pool5'
    )
    vgg = scipy.io.loadmat('D://python//imagenet-vgg-verydeep-19.mat')
    weights = vgg['layers'][0]

    network={}
    net = tf.Variable(np.zeros([1, 300, 450, 3]), dtype=tf.float32)
    network['input'] = net
    for i,name in enumerate(layers):
        layer_type=name[:4]
        if layer_type=='conv':
            kernels = weights[i][0][0][0][0][0]
            bias = weights[i][0][0][0][0][1]
            conv=tf.nn.conv2d(net,tf.constant(kernels),strides=(1,1,1,1),padding='SAME',name=name)
            net=tf.nn.relu(conv + bias)
        elif layer_type=='pool':
            net=tf.nn.max_pool(net,ksize=(1,2,2,1),strides=(1,2,2,1),padding='SAME')
        network[name]=net
    return network


# 求gamm矩陣
def gram(x, size, deep):
    x = tf.reshape(x, (size, deep))
    g = tf.matmul(tf.transpose(x), x)
    return g


def style_loss(sess, style_neck, model):
    style_loss = 0.0
    for layer_name, weight in STYLE_LAUERS:
        # 計算特征矩陣
        a = style_neck[layer_name]
        x = model[layer_name]
        # 長x寬
        M = a.shape[1] * a.shape[2]
        N = a.shape[3]

        # 計算gram矩陣
        A = gram(a, M, N)
        G = gram(x, M, N)

        # 根據(jù)公式計算損失，并進行累加
        style_loss += (1.0 / (4 * M * M * N * N)) * tf.reduce_sum(tf.pow(G - A, 2)) * weight
        # 將損失對層數(shù)取平均
    style_loss /= len(STYLE_LAUERS)
    return style_loss


def content_loss(sess, content_neck, model):
    content_loss = 0.0
    # 逐個取出衡量內(nèi)容損失的vgg層名稱及對應權重

    for layer_name, weight in CONTENT_LAYERS:
        # 計算特征矩陣
        p = content_neck[layer_name]
        x = model[layer_name]
        # 長x寬xchannel

        M = p.shape[1] * p.shape[2]
        N = p.shape[3]

        lss = 1.0 / (M * N)
        content_loss += lss * tf.reduce_sum(tf.pow(p - x, 2)) * weight
        # 根據(jù)公式計算損失，并進行累加

    # 將損失對層數(shù)取平均
    content_loss /= len(CONTENT_LAYERS)
    return content_loss


def random_img(height, weight, content_img):
    noise_image = np.random.uniform(-20, 20, [1, height, weight, 3])
    random_img = noise_image * NOISE + content_img * (1 - NOISE)
    return random_img


def get_neck(sess, model, content_img, style_img):
    sess.run(tf.assign(model['input'], content_img))
    content_neck = {}
    for layer_name, weight in CONTENT_LAYERS:
        # 計算特征矩陣
        p = sess.run(model[layer_name])
        content_neck[layer_name] = p
    sess.run(tf.assign(model['input'], style_img))
    style_content = {}
    for layer_name, weight in STYLE_LAUERS:
        # 計算特征矩陣
        a = sess.run(model[layer_name])
        style_content[layer_name] = a
    return content_neck, style_content


def main():
    model = vgg19()
    content_img = cv2.imread('D://a//content1.jpg')
    content_img = cv2.resize(content_img, (450, 300))
    content_img = np.reshape(content_img, (1, 300, 450, 3)) - [128.0, 128.2, 128.0]
    style_img = cv2.imread('D://a//style1.jpg')
    style_img = cv2.resize(style_img, (450, 300))
    style_img = np.reshape(style_img, (1, 300, 450, 3)) - [128.0, 128.2, 128.0]

    # 生成圖片
    rand_img = random_img(HEIGHT, WIGHT, content_img)

    with tf.Session() as sess:
        # 計算loss值
        content_neck, style_neck = get_neck(sess, model, content_img, style_img)
        cost = ALPHA * content_loss(sess, content_neck, model) + BETA * style_loss(sess, style_neck, model)
        optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(cost)

        sess.run(tf.global_variables_initializer())
        sess.run(tf.assign(model['input'], rand_img))
        for step in range(TRAIN_STEPS):
            print(step)
            # 訓練
            sess.run(optimizer)

            if step % 10 == 0:
                img = sess.run(model['input'])
                img += [128, 128, 128]
                img = np.clip(img, 0, 255).astype(np.uint8)
                name = OUTPUT_IMAGE + "http://" + str(step) + ".jpg"
                img = img[0]
                cv2.imwrite(name, img)

        img = sess.run(model['input'])
        img += [128, 128, 128]
        img = np.clip(img, 0, 255).astype(np.uint8)
        cv2.imwrite("D://end.jpg", img[0])

main()

7 效果展示

文章來源地址http://www.zghlxwxcb.cn/news/detail-443031.html

8 最后

到了這里，關于畢設 深度學習圖像風格遷移 - opencv python的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！