2. 程式人生 > >機器學習筆記（二十二）：TensorFlow實戰十四（影象風格遷移）

機器學習筆記（二十二）：TensorFlow實戰十四（影象風格遷移）

阿新 • • 發佈：2018-12-15

1 - 引言

相信大家都使用過一種濾鏡，可以把一張照片轉換成不同風格的照片，如下圖所示：
在這裡插入圖片描述
那麼我們就來利用TensorFlow來實現以下這個演算法，這個演算法出自Gatys的A Neural Algorithm of Artistic Style論文，十分有趣，讓我們來詳細的介紹一下這個演算法吧

2 - 利用VGG提取特徵

總得來說，就是利用一個訓練好的卷積神經網路 VGG-19，這個網路在ImageNet 上已經訓練過了。

給定一張風格影象 和一張普通影象 ，風格影象經過VGG-19 的時候在每個卷積層會得到很多 feature maps, 這些feature maps 組成一個集合 ，同樣的，普通影象 通過 VGG-19 的時候也會得到很多 feature maps，這些feature maps 組成一個集合 ，然後生成一張隨機噪聲影象 , 隨機噪聲影象 通過VGG-19 的時候也會生成很多feature maps，這些 feature maps 構成集合 和 分別對應集合 和 , 最終的優化函式是希望調整 讓 隨機噪聲影象 最後看起來既保持普通影象 的內容, 又有一定的風格影象 的風格。
在這裡插入圖片描述

3 - 神經風格轉換

總得來說，就是利用一個訓練好的卷積神經網路 VGG-19，這個網路在ImageNet 上已經訓練過了。

給定一張風格影象 和一張普通影象 ，風格影象經過VGG-19 的時候在每個卷積層會得到很多 feature maps, 這些feature maps 組成一個集合 ，同樣的，普通影象 通過 VGG-19 的時候也會得到很多 feature maps，這些feature maps 組成一個集合 ，然後生成一張隨機噪聲影象 , 隨機噪聲影象 通過VGG-19 的時候也會生成很多feature maps，這些 feature maps 構成集合 和 分別對應集合 和 , 最終的優化函式是希望調整 讓 隨機噪聲影象 最後看起來既保持普通影象 的內容, 又有一定的風格影象 的風格。

所以我們先要構建這些損失函式：

  • 構建內容損失函式 j c o n t e
    n t ( C , G ) j_{content}(C,G)
  • 構建風格損失函式 J s t y l e ( S , G ) J_{style}(S,G)
  • 把它們放在一起構造總代價函式 J ( G ) = α J c o n t e n t ( C , G ) + β J s t y l e ( S , G ) J(G)=\alpha J_{content}(C,G)+\beta J_{style}(S,G)

3.1 - 計算內容損失

根據內容損失函式
J c o n t e n t ( C , G ) = 1 4 ∗ n h ∗ n w ∗ n c ∑ 所 有 條 目 ( a ( C ) − a ( G ) ) 2 J_{content}(C,G)=\frac{1}{4*n_h*n_w*n_c}\sum_{所有條目}(a^{(C)}-a^{(G)})^2

3.2 - 計算風格損失

根據風格損失函式
J s t y l e ( S , G ) = 1 4 ∗ n c 2 ∗ ( n h ∗ n w ) 2 ∑ i = 1 n c ∑ j = 1 n c ( G i j ( S ) − G i j ( G ) ) 2 J_{style}(S,G)=\frac{1}{4*n_c^2*(n_h*n_w)^2}\sum_{i=1}^{n_c}\sum_{j=1}^{n_c}(G_{ij}^(S)-G_{ij}^(G))^2

3.3 - 總體成本優化公式

最後我們要建立一個最小化風格的內容成本函式
J ( G ) = α J c o n t e n t ( C , G ) + β J s t y l e ( S , G ) J(G)= \alpha J_{content}(C,G)+\beta J_{style}(S,G)

4 - 使用TensorFlow實現演算法

程式碼執行前先確保下載好了VGG-19模型

import os
import sys
import numpy as np
import scipy.io
import scipy.misc
import tensorflow as tf
 
# Output folder for the images.
OUTPUT_DIR = 'output/'
# Style image to use.
STYLE_IMAGE = '/images/ocean.jpg'
# Content image to use.
CONTENT_IMAGE = '/images/Taipei101.jpg'
# Image dimensions constants.
IMAGE_WIDTH = 800
IMAGE_HEIGHT = 600
COLOR_CHANNELS = 3
 
###############################################################################
# Algorithm constants
###############################################################################
# 設定隨機噪聲影象與內容影象的比率
NOISE_RATIO = 0.6
# 設定迭代次數
ITERATIONS = 1000
# 設定內容影象與風格影象的權重
alpha = 1
beta = 500
# 載入VGG-19 MODEL及設定均值
VGG_Model = 'Downloads/imagenet-vgg-verydeep-19.mat'
MEAN_VALUES = np.array([123.68, 116.779, 103.939]).reshape((1, 1, 1, 3))
# 設定需要用到的卷積層
CONTENT_LAYERS = [('conv4_2', 1.)]
STYLE_LAYERS = [('conv1_1', 0.2), ('conv2_1', 0.2), ('conv3_1', 0.2), ('conv4_1', 0.2), ('conv5_1', 0.2)]
 
# 生成隨機噪聲圖，與content圖以一定比率融合
def generate_noise_image(content_image, noise_ratio = NOISE_RATIO):
    """
    Returns a noise image intermixed with the content image at a certain ratio.
    """
    noise_image = np.random.uniform(
            -20, 20,
            (1, IMAGE_HEIGHT, IMAGE_WIDTH, COLOR_CHANNELS)).astype('float32')
    # White noise image from the content representation. Take a weighted average
    # of the values
    img = noise_image * noise_ratio + content_image * (1 - noise_ratio)
    return img
 
def load_image(path):
    image = scipy.misc.imread(path)
    # Resize the image for convnet input, there is no change but just
    # add an extra dimension.
    image = np.reshape(image, ((1,) + image.shape))
    # Input to the VGG net expects the mean to be subtracted.
    image = image - MEAN_VALUES
    return image
 
def save_image(path, image):
    # Output should add back the mean.
    image = image + MEAN_VALUES
    # Get rid of the first useless dimension, what remains is the image.
    image = image[0]
    image = np.clip(image, 0, 255).astype('uint8')
    scipy.misc.imsave(path, image)
 
 
def build_net(ntype, nin, nwb=None):
    if ntype == 'conv':
        return tf.nn.relu(tf.nn.conv2d(nin, nwb[0], strides=[1, 1, 1, 1], padding='SAME') + nwb[1])
    elif ntype == 'pool':
        return tf.nn.avg_pool(nin, ksize=[1, 2, 2, 1],
                              strides=[1, 2, 2, 1], padding='SAME')
 
def get_weight_bias(vgg_layers, i):
    weights = vgg_layers[i][0][0][2][0][0]
    weights = tf.constant(weights)
    bias = vgg_layers[i][0][0][2][0][1]
    bias = tf.constant(np.reshape(bias, (bias.size)))
    return weights, bias
 
 
def build_vgg19(path):
    net = {}
    vgg_rawnet = scipy.io.loadmat(path)
    vgg_layers = vgg_rawnet['layers'][0]
    net['input'] = tf.Variable(np.zeros((1, IMAGE_HEIGHT, IMAGE_WIDTH, 3)).astype('float32'))
    net['conv1_1'] = build_net('conv', net['input'], get_weight_bias(vgg_layers, 0))
    net['conv1_2'] = build_net('conv', net['conv1_1'], get_weight_bias(vgg_layers, 2))
    net['pool1'] = build_net('pool', net['conv1_2'])
    net['conv2_1'] = build_net('conv', net['pool1'], get_weight_bias(vgg_layers, 5))
    net['conv2_2'] = build_net('conv', net['conv2_1'], get_weight_bias(vgg_layers, 7))
    net['pool2'] = build_net('pool', net['conv2_2'])
    net['conv3_1'] = build_net('conv', net['pool2'], get_weight_bias(vgg_layers, 10))
    net['conv3_2'] = build_net('conv', net['conv3_1'], get_weight_bias(vgg_layers, 12))
    net['conv3_3'] = build_net('conv', net['conv3_2'], get_weight_bias(vgg_layers, 14))
    net['conv3_4'] = build_net('conv', net['conv3_3'], get_weight_bias(vgg_layers, 16))
    net['pool3'] = build_net('pool', net['conv3_4'])
    net['conv4_1'] = build_net('conv', net['pool3'], get_weight_bias(vgg_layers, 19))
    net['conv4_2'] = build_net('conv', net['conv4_1'], get_weight_bias(vgg_layers, 21))
    net['conv4_3'] = build_net('conv', net['conv4_2'], get_weight_bias(vgg_layers, 23))
    net['conv4_4'] = build_net('conv', net['conv4_3'], get_weight_bias(vgg_layers, 25))
    net['pool4'] = build_net('pool', net['conv4_4'])
    net['conv5_1'] = build_net('conv', net['pool4'], get_weight_bias(vgg_layers, 28))
    net['conv5_2'] = build_net('conv', net['conv5_1'], get_weight_bias(vgg_layers, 30))
    net['conv5_3'] = build_net('conv', net['conv5_2'], get_weight_bias(vgg_layers, 32))
    net['conv5_4'] = build_net('conv', net['conv5_3'], get_weight_bias(vgg_layers, 34))
    net['pool5'] = build_net('pool', net['conv5_4'])
    return net
 
 
def content_layer_loss(p, x):
 
    M = p.shape[1] * p.shape[2]
    N = p.shape[3]
    loss = (1. / (2 * N * M)) * tf.reduce_sum(tf.pow((x - p), 2))
    return loss
 
 
def content_loss_func(sess, net):
 
    layers = CONTENT_LAYERS
    total_content_loss = 0.0
    for layer_name, weight in layers:
        p = sess.run(net[layer_name])
        x = net[layer_name]
        total_content_loss += content_layer_loss(p, x)*weight
 
    total_content_loss /= float(len(layers))
    return total_content_loss
 
 
def gram_matrix(x, area, depth):
 
    x1 = tf.reshape(x, (area, depth))
    g = tf.matmul(tf.transpose(x1), x1)
    return g
 
def style_layer_loss(a, x):
 
    M = a.shape[1] * a.shape[2]
    N = a.shape[3]
    A = gram_matrix(a, M, N)
    G = gram_matrix(x, M, N)
    loss = (1. / (4 * N ** 2 * M ** 2)) * tf.reduce_sum(tf.pow((G - A), 2))
    return loss
 
 
def style_loss_func(sess, net):
 
    layers = STYLE_LAYERS
    total_style_loss = 0.0
    for layer_name, weight in layers:
        a = sess.run(net[layer_name])
        x = net[layer_name]
        total_style_loss += style_layer_loss(a, x) * weight
    total_style_loss /= float(len(layers))
    return total_style_loss
 
 
def main():
    net = build_vgg19(VGG_Model)
    sess = tf.Session()
    sess.run(tf.initialize_all_variables())
 
    content_img = load_image(CONTENT_IMAGE)
    style_img = load_image(STYLE_IMAGE)
 
    sess.run([net['input'].assign(content_img)])
    cost_content = content_loss_func(sess, net)
 
    sess.run([net['input'].assign(style_img)])
    cost_style = style_loss_func(sess, net)
 
    total_loss = alpha * cost_content + beta * cost_style
    optimizer = tf.train.AdamOptimizer(2.0)
 
    init_img = generate_noise_image(content_img)
 
    train_op = optimizer.minimize(total_loss)
    sess.run(tf.initialize_all_variables())
    sess.run(net['input'].assign(init_img))
 
    for it in range(ITERATIONS):
        sess.run(train_op)
        if it % 100 == 0:
            # Print every 100 iteration.
            mixed_image = sess.run(net['input'])
            print('Iteration %d' % (it))
            print('sum : ', sess.run(tf.reduce_sum(mixed_image)))
            print('cost: ', sess.run(total_loss))
 
            if not os.path.exists(OUTPUT_DIR):
                os.mkdir(OUTPUT_DIR)
 
            filename = 'output/%d.png' % (it)
            save_image(filename, mixed_image)
 
if __name__ == '__main__':
    main()

5 - 實驗結果

將晴空下的盧浮宮設為待融合的原始圖片（很好看有木有）：
在這裡插入圖片描述

與之融合的圖片，山水畫（也很美有木有）：
在這裡插入圖片描述

那麼我們利用影象風格遷移融合的效果是什麼呢？
在這裡插入圖片描述
是不是很酷呢？你們也可以換成其他圖片來試一試效果。

相關推薦

機器學習筆記（二十）：TensorFlow實戰十二（TensorBoard視覺化）

1 - 引言 前面已經介紹到TensorFlow可以實現許多非常常用的神經網路結構，有的網路結構十分複雜，裡面的引數關係更是難以管理。因此，TensorFlow提供了一個視覺化工具TensorBoard。可以有效的展示執行過程中的計算圖、各種指標隨著時間的變化趨勢以及訓練中使用到的影象等

機器學習筆記（二十二）：TensorFlow實戰十四（影象風格遷移）

1 - 引言 相信大家都使用過一種濾鏡，可以把一張照片轉換成不同風格的照片，如下圖所示： 那麼我們就來利用TensorFlow來實現以下這個演算法，這個演算法出自Gatys的A Neural Algorithm of Artistic Style論文，十分有趣，讓我們來詳細的介紹一下這

機器學習筆記（十九）：TensorFlow實戰十一（多執行緒輸入資料）

1 - 引言 為了加速模型訓練的時間，TensorFlow提供了一套多執行緒處理輸入資料的框架。 下面我們來詳細的介紹如何使用多執行緒來加速我們的模型訓練速度 2 - 佇列與多執行緒 在TensorFlow中，佇列和變數類似，我們可以修改它們的狀態。下面給出一個示例來展示如

機器學習筆記（十八）：TensorFlow實戰十（影象資料處理）

1 - 引言 之前我們介紹了通過卷積神經網路可以給影象識別技術帶來突破性的進展，現在我們從影象的預處理這個角度來繼續提升我們影象識別的準確率。 輸入的預處理需要使用TFRecord格式來同一不同的原始資料格式，並且更加有效的管理不同的屬性。 並且TensorFlow支援影象處理函式，

機器學習筆記（十）：TensorFlow實戰二（深層神經網路）

1 - 深度學習與深層神經網路 深度學習的精確定義為：“一類通過多層非線性變換對高複雜性資料建模演算法的集合” 因此，多層神經網路有著2個非常重要的特性 多層 非線性 1.1 - 線性模型的侷限性 線上性模型中，模型的輸出為輸入的加權和，假設一

機器學習筆記（十二）：TensorFlow實戰四（影象識別與卷積神經網路）

1 - 卷積神經網路常用結構 1.1 - 卷積層 我們先來介紹卷積層的結構以及其前向傳播的演算法。 一個卷積層模組，包含以下幾個子模組： 使用0擴充邊界(padding) 卷積視窗過濾器（filter） 前向卷積 反向卷積（可選） 1.1

機器學習筆記（二十一）：TensorFlow實戰十三（遷移學習）

1 - 引言 越複雜的神經網路，需要的訓練集越大，ImageNet影象分類資料集有120萬標註圖片，所以才能將152層的ResNet的模型訓練到大約96.%的正確率。但是在真正的應用中，很難收集到如此多的標註資料。即使收集到也需要花費大量人力物力來標註。並且即使有了大量的資料集，要訓練一

機器學習筆記（十一）： TensorFlow實戰三（MNIST數字識別問題）

1 - MNIST數字識別問題 前面介紹了這樣用TensorFlow訓練一個神經網路模型和主要考慮的問題及解決這些問題的常用方法。下面我們用一個實際的問題來驗證之前的解決方法。 我們使用的是MNIST手寫數字識別資料集。在很多深度學習教程中，這個資料集都會被當做一個案例。 1.1

機器學習筆記（十五）：TensorFlow實戰七（經典卷積神經網路：VGG）

1 - 引言 之前我們介紹了LeNet-5和AlexNet，在AlexNet發明之後，卷積神經網路的層數開始越來越複雜，VGG-16就是一個相對前面2個經典卷積神經網路模型層數明顯更多了。 VGGNet是牛津大學計算機視覺組（Visual Geometry Group）和Google

機器學習筆記（十四）：TensorFlow實戰六（經典卷積神經網路：AlexNet ）

1 - 引言 2012年，Imagenet比賽冠軍的model——Alexnet [2]（以第一作者alex命名）。這個網路算是一個具有突破性意義的模型 首先它證明了CNN在複雜模型下的有效性，然後GPU實現使得訓練在可接受的時間範圍內得到結果，讓之後的網路模型構建變得更加複雜，並且通過

機器學習筆記（十七）：TensorFlow實戰九（經典卷積神經網路：ResNet）

1 - 引言 我們可以看到CNN經典模型的發展從 LeNet -5、AlexNet、VGG、再到Inception，模型的層數和複雜程度都有著明顯的提高，有些網路層數更是達到100多層。但是當神經網路的層數過高時，這些神經網路會變得更加難以訓練。 一個特別大的麻煩就在於訓練的時候會產

機器學習筆記（十六）：TensorFlow實戰八（經典卷積神經網路：GoogLeNet）

1 - 引言 GoogLeNet, 在2014年ILSVRC挑戰賽獲得冠軍，將Top5 的錯誤率降低到6.67%. 一個22層的深度網路 論文地址：http://arxiv.org/pdf/1409.4842v1.pdf 題目為：Going deeper with convolu

機器學習筆記（九）：Tensorflow 實戰一 （Tensorflow入門）

1 - TsensorFlow計算模型 ——計算圖 1.1- 計算圖的概念 計算圖是TensorFlow中最基本的一個概念，TensorFlow中的所有計算都會被轉化為計算圖上的節點。 在TensorFlow中，張量可以簡單地理解為多為陣列。如果說TensorFlow的第一個詞T

機器學習筆記（十三）：TensorFlow實戰五（經典卷積神經網路： LeNet -5 ）

1 - 引言 之前我們介紹了一下卷積神經網路的基本結構——卷積層和池化層。通過這兩個結構我們可以任意的構建各種各樣的卷積神經網路模型，不同結構的網路模型也有不同的效果。但是怎樣的神經網路模型具有比較好的效果呢？ 下圖展示了CNN的發展歷程。 經過人們不斷的嘗試，誕生了許多有

【OS學習筆記】十三 保護模式一：全域性描述符表（GDT）

上一篇文章，我們大致領略了現代處理器的結構和特點。點解連結檢視上一篇文章：現代處理器的結構和特點 本篇文章開始，學習保護模式下的的各種機制。什麼是保護模式呢？ 一般來說，作業系統負責整個計算機軟硬體的的管理，它做任何事情都是可以的。但是使用者程式就應當有所限制，使用者程式它只能訪

機器學習筆記（十二）：聚類

目錄 1）Unsupervised learning introduction 2）K-means algorithm 3）Optimization objective 4）Random initialization 5）Choosing the number of clus

機器學習筆記（十二）：TensorFlow實現四（影象識別與卷積神經網路）

1 - 卷積神經網路常用結構 1.1 - 卷積層 我們先來介紹卷積層的結構以及其前向傳播的演算法。 一個卷積層模組，包含以下幾個子模組： 使用0擴充邊界(padding) 卷積視窗過濾器（filter） 前向卷積 反向卷積（可選） 1.1.2 - 邊界填充

吳恩達機器學習筆記（十二）-支援向量機

第十三章 支援向量機（SVM）優化目標支援向量機在學習複雜的非線性方程時能夠提供一種更為清晰個更加強大的方式。    先回顧一下邏輯迴歸的相關概念，看如何進行改動可以得到支援向量機。邏輯迴歸的假設函式為

機器學習筆記（十二）——馬爾科夫模型

    馬爾科夫模型是一種概率圖模型，它描述了一類重要的隨機過程(隨機過程又稱為隨機函式，是隨時間而隨機變化的過程)。我們常常需要考察一個隨機變數序列，這些隨機變數序列並不是相互獨立的，每個隨機變數的值都依賴於這個序列前邊的狀態。     如果一個系統有N個有

（原創）(二)機器學習筆記之數據預處理

labels 學習筆記 取值 特征 tarray 均值 imp represent 中位數 數據預處理 數據預處理一般包括： （1） 數據標準化 這是最常用的數據預處理，把某個特征的所有樣本轉換成均值為0，方差為1。 將數據轉換成標準正態分布的方法： 對每維特征單