4.keras實現-->生成式深度學習之DeepDream

DeepDream是一種藝術性的圖像修改技術，它用到了卷積神經網絡學到的表示，DeepDream由Google於2015年發布。這個算法與卷積神經網絡過濾器可視化技術幾乎相同，都是反向運行一個卷積神經網絡:對卷積神經網絡的輸入做梯度上升，以便將卷積神經網絡靠頂部的某一層的某個過濾器激活最大化。但有以下幾個簡單的區別：

• 使用DeepDream，我們嘗試將所有層的激活最大化，而不是將某一層的激活最大化，因此需要同時將大量特征的可視化混合在一起
• 不是從空白的、略微帶有噪聲的輸入開始，而是從現有的圖像開始，因此所產生的效果能夠抓住已經存在的視覺模式，並以某種藝術性的方式將圖像扭曲
• 輸入圖像是在不同的尺度上【叫作八度（octave）】進行處理的，這可以提高可視化的質量

我們將從一個在ImageNet上預訓練的卷積神經網絡（Keras內置的Inception V3模型）開始

#加載預訓練的Inception V3模型
from keras.applications import inception_v3
from keras import backend as K

#我們不需要訓練模型，所以這個命令會禁用
K.set_learning_phase(0)

#構建不包括全連接層的Inception V3網絡。使用預訓練的ImageNet權重來加載模型
model = inception_v3.InceptionV3(weights = 'imagenet',include_top=False) 

接下來要計算損失loss，即在梯度上升過程中需要最大化的量。在第五章的過濾器可視化中，我們試圖將某一層的某個過濾器的值最大化。這里，我們要將多個層的所有過濾器的激活同時最大化。具體來說，就是對一組靠近頂部的層激活的L2范數進行加權求和，然后將其最大化。選擇哪些層（以及它們對最終損失的貢獻）對生成的可視化結果具有很大影響，所以我們希望讓這些參數變得易於配置。更靠近底部的層生成的是幾何圖案，而更靠近頂部的層生成的則是從中能夠看出某些ImageNet類別（比如鳥或狗）的圖案。我們將隨意選擇4層的配置，但以后一定要探索多個不同的配置

# 設置DeepDream配置
layer_contributions={
    'mixed2':0.2,
    'mixed3':3.,
    'mixed4':2,
    'mixed5':1.5,
}
#這個字典將層的名稱映射為一個系數，這個系數定量表示該層激活對你要最大化的損失的貢獻大小。
# 注意，層的名稱硬編碼在內置的inception V3應用中

　　

#定義需要最大化的損失 #創建一個字典，將層的名稱映射為層的實例 layer_dict = dict([(layer.name,layer) for layer in model.layers] ) #在定義損失時將層的貢獻添加到這個標量變量中 loss = K.variable(0.) for layer_name in layer_contributions: coeff = layer_contributions[layer_name] #該層激活對損失的貢獻大小 activation = layer_dict[layer_name].output #獲取層的輸出 scaling = K.prod(K.cast(K.shape(activation),'float32')) #將該層特征的L2范數添加到loss中，為了避免出現邊界偽影，損失中僅包含非邊界的像素 loss += coeff * K.sum(K.square(activation[:,2:-2,2:-2,:1])) / scaling

layer_dict ={'input_4': <keras.engine.input_layer.InputLayer at 0x281714cc240>, 'conv2d_283': <keras.layers.convolutional.Conv2D at 0x28171545240>, ...} activation.shape: (?, ?, ?, 288)(?, ?, ?, 768) (?, ?, ?, 768)(?, ?, ?, 768) loss: Tensor("add_19:0", shape=(), dtype=float32)

　　

#梯度上升過程

#這個張量用於保存生成的圖像，即夢境圖像
dream = model.input

#計算損失相對於夢境圖像的梯度
grads = K.gradients(loss,dream)[0]

#將梯度標准化（重要技巧）
grads /= K.maximum(K.mean(K.abs(grads)),1e-7)

#給定一張輸出圖像，設置一個keras函數來獲取損失值和梯度值
outputs = [loss,grads]
fetch_loss_and_grads = K.function([dream],outputs)

def eval_loss_and_grads(x):
    outs = fetch_loss_and_grads([x])
    loss_value = outs[0]
    grad_values = outs[1]
    return loss_value,grad_values

#這個函數運行itertions次梯度上升
def gradient_ascent(x,iterations,step,max_loss=None):
    for i in range(iterations):
        loss_value,grad_values = eval_loss_and_grads(x)
        if max_loss is not None and loss_value > max_loss:
            break
        print('...Loss value at',i,':',loss_value)
        x += step * grad_values
    return x

　　

最后就是實際的DeepDream算法

首先，我們來定義一個列表，里面包含的是處理圖像的尺度（也叫八度）。每個連續的尺度都是前一個的1.4倍（放大40%），即首先處理小圖像，然后逐漸增大圖像尺寸。對於每個連續的尺度，從最小到最大，我們都需要在當前尺度運行梯度上升，以便將之前定義的損失最大化。每次運行完梯度上升之后，將得到的圖像放大40%。

在每次連續的放大之后（圖像會變得模糊或像素化），為避免丟失大量圖像細節，我們可以使用一個簡單的技巧:每次放大之后，將丟失的細節重新注入到圖像中。這種方法是可行的，因為我們知道原始圖像放大到這個尺寸應該是什么樣子。

給定一個較小的圖像尺寸S和一個較大的圖像尺寸L，你可以計算將原始圖像大小調整為L與將原始圖像大小調整為S之間的區別，這個區別可以定量描述從S到L的細節損失。

#輔助函數
import scipy
from keras.preprocessing import image

def resize_img(img,size):
    img = np.copy(img)
    factors=(1,
            float(size[0])/img.shape[1],
            float(size[1])/img.shape[2],
            1)
    return scipy.ndimage.zoom(img,factors,order=1)

def save_img(img,fname):
    pil_img = deprocess_image(np.copy(img))
    scipy.misc.imsave(fname,pil_img)
    
def preprocess_image(image_path):
    img = image.load_img(image_path)#打開圖片
    img = image.img_to_array(img)#把圖片轉成array形式
    img = np.expand_dims(img,axis=0)#改變圖像大小
    img = inception_v3.preprocess_input(img)#將圖像格式轉換為Inception V3模型能夠處理的張量
    return img

def deprocess_image(x): #通用函數，將一個張量轉換為有效圖像
    if K.image_data_format() == 'channels_first':
        x = x.reshape((3,x.shape[2],x.shape[3]))
        x = x.transpose((1,2,0))
    else:
        x = x.reshape((x.shape[1],x.shape[2],3)) #對inception_v3.preprocess_input所做的預處理進行反向操作
    x /= 2.
    x += 0.5
    x *= 255.
    x = np.clip(x,0,255).astype('uint8')
    return x

　　

#在多個連續尺度上運行梯度上升
import numpy as np

step = 0.01 #步長
num_octave = 3 #運行梯度上升的尺度個數
octave_scale = 1.4 #兩個尺度之間的大小比例
iterations = 20 #在每個尺度上運行梯度上升的步數

max_loss = 10. #如果損失增大到大於10，我們要中斷梯度上升的過程，以避免得到丑陋的偽影
base_image_path = 'IU.jpeg' #將這個變量修改為你要使用的圖像的路徑

img = preprocess_image(base_image_path)#將基礎圖像加載成一個numpy數組

original_shape = img.shape[1:3]  #img.shape = (1, 776, 1200, 3)
successive_shapes = [original_shape]  #[(776, 1200)]
for i in range(1,num_octave):
    #准備一個由形狀元組組成的列表，它定義了運行梯度上升的不同尺度
    shape = tuple([int(dim/(octave_scale ** i)) for dim in original_shape])
    successive_shapes.append(shape)  #[(776, 1200), (554, 857), (395, 612)]
    
successive_shapes = successive_shapes[::-1] #將形狀列表反轉，變為升序 

original_img = np.copy(img)
shrunk_original_img = resize_img(img,successive_shapes[0])#將圖像numpy數組的大小縮放到最小尺寸

for shape in successive_shapes:
    print('Processing image shape',shape)
    img = resize_img(img,shape)#將夢境圖像放大
    img = gradient_ascent(img,
                         iterations = iterations,
                         step = step,
                         max_loss = max_loss)
    upscaled_shrunk_original_img = resize_img(shrunk_original_img,shape)
    same_size_original = resize_img(original_img,shape)
    lost_detail = same_size_original - upscaled_shrunk_original_img
    
    img += lost_detail
    shrunk_original_img = resize_img(original_img,shape)
    save_img(img,fname='dream_at_scale_'+str(shape)+'.png')
    
save_img(img,fname='final_dream.png')

 訓練損失：

 

                       

原圖	效果圖