作者 | Samuel Noriega
譯者 | Freesia
編輯 | 夕顏
出品 | AI科技大本營（ID: rgznai100）
?
【導讀】最近，谷歌 DeepMInd 發表論文( DRAW: A Recurrent Neural Network For Image Generation），提出了一個用于圖像生成的遞歸神經網絡，該系統大大提高了 MNIST 上生成模型的質量。為更加深入了解 DRAW，本文作者基于 Eric Jang 用 158 行 Python 代碼實現該系統的思路，詳細闡述了 DRAW 的概念、架構和優勢等。
首先我們先解釋一下 DRAW 的概念吧
遞歸神經網絡是一種用于圖像生成的神經網絡結構。Draw Networks 結合了一種新的空間注意機制，該機制模擬了人眼的中心位置，采用了一個順序變化的自動編碼框架，使之對復雜圖像進行迭代構造。
?
該系統大大提高了 MNIST 上生成模型的質量，特別是當對街景房屋編號數據集進行訓練時，肉眼竟然無法將它生成的圖像與真實數據區別開來。
?
Draw 體系結構的核心是一對遞歸神經網絡：一個是壓縮用于訓練的真實圖像的編碼器，另一個是在接收到代碼后重建圖像的解碼器。這一組合系統采用隨機梯度下降的端到端訓練，損失函數的最大值變分主要取決于對數似然函數的數據。
?
DRAW 的架構
?
Draw 網絡類似于其他變分自動編碼器，它包含一個編碼器網絡，該編碼器網絡決定著潛在代碼上的 distribution（潛在代碼主要捕獲有關輸入數據的顯著信息），解碼器網絡接收來自 code distribution 的樣本，并利用它們來調節其自身圖像的 distribution 。
DRAW 與其他自動解碼器的三大區別
?
編碼器和解碼器都是 DRAW 中的遞歸網絡，解碼器的輸出依次添加到 distribution 中以生成數據，而不是一步一步地生成 distribution 。動態更新的注意機制用于限制由編碼器負責的輸入區域和由解碼器更新的輸出區域 。簡單地說，這一網絡在每個 time-step 都能決定“讀到哪里”和“寫到哪里”以及“寫什么”。
?
? ? ??
? ? ? ?
左：傳統變分自動編碼器
?
在生成過程中，從先前的 P（z）中提取一個樣本 z ，并通過前饋譯碼器網絡來計算給定樣本的輸入 P（x_z）的概率。
?
在推理過程中，輸入 x 被傳遞到編碼器網絡，在潛在變量上產生一個近似的后驗 Q(z|x) 。在訓練過程中，從 Q(z|x) 中抽取 z，然后用它計算總描述長度 KL ( Q (Z|x)∣∣ P(Z)?log(P(x|z))，該長度隨隨機梯度的下降（ https://en.wikipedia.org/wiki/Stochastic_gradient_descent ）而減小至最小值。
?
右：DRAW網絡
?
在每一個步驟中，都會將先前 P（z）中的一個樣本 z_t 傳遞給遞歸解碼器網絡，該網絡隨后會修改 canvas matrix 的一部分。最后一個 canvas matrix cT 用于計算 P（x|z_1:t）。
?
在推理過程中，每個 time-step 都會讀取輸入，并將結果傳遞給編碼器 RNN，然后從上一 time-step 中的 RNN 指定讀取位置，編碼器 RNN 的輸出用于計算該 time-step 的潛在變量的近似后驗值。
?
損失函數
?
最后一個 canvas matrix cT 用于確定輸入數據的模型 D(X | cT)?的參數。如果輸入是二進制的，D 的自然選擇呈伯努利分布，means 由?σ(cT) 給出。重建損失 Lx 定義為 D 下 x 的負對數概率：
?
? ? ? ?
?
The latent loss 潛在distributions序列?
?
的潛在損失?
被定義為源自??
?
的潛在先驗 P(Z_t)的簡要 KL散度。
?
鑒于這一損失取決于由?
?繪制的潛在樣本 z_t ，因此其反過來又決定了輸入 x。如果潛在 distribution是一個?
這樣的 diagonal Gaussian ，P(Z_t) 便是一個均值為 0，且具有標準離差的標準 Gaussian，這種情況下方程則變為??
。
網絡的總損失 L 是重建和潛在損失之和的期望值：?
? ? ?
?
對于每個隨機梯度下降，我們使用單個 z 樣本進行優化。
?
L^Z 可以解釋為從之前的序列向解碼器傳輸潛在樣本序列 z_1:T 所需的 NAT 數量，并且（如果 x 是離散的）L^x 是解碼器重建給定 z_1:T 的 x 所需的 NAT 數量。因此，總損失等于解碼器和之前數據的預期壓縮量。
?
改善圖片
?
正如 EricJang 在他的文章中提到的，讓我們的神經網絡僅僅“改善圖像”而不是“一次完成圖像”會更容易些。正如人類藝術家在畫布上涂涂畫畫，并從繪畫過程中推斷出要修改什么，以及下一步要繪制什么。
?
改進圖像或逐步細化只是一次又一次地破壞我們的聯合 distribution P(C)?，導致潛在變量鏈 C1,C2,…CT?1 呈現新的變量分布 P(CT) 。
? ? ??
訣竅是多次從迭代細化分布 P(Ct|Ct?1)中取樣，而不是直接從 P(C) 中取樣。
?
在 DRAW 模型中，?P(Ct|Ct?1) 是所有 t 的同一 distribution，因此我們可以將其表示為以下遞歸關系（如果不是，那么就是 ? Markov Chain? 而不是遞歸網絡了）。
? ? ? ?
? ? ?
DRAW模型的實際應用
?
假設你正在嘗試對數字 8 的圖像進行編碼。每個手寫數字的繪制方式都不同，有的樣本 8 可能看起來寬一些，有的可能長一些。如果不注意，編碼器將被迫同時捕獲所有這些小的差異。
?
但是……如果編碼器可以在每一幀上選擇一小段圖像并一次檢查數字 8 的每一部分呢？這會使工作更容易，對吧？
?
同樣的邏輯也適用于生成數字。注意力單元將決定在哪里繪制數字 8 的下一部分-或任何其他部分-而傳遞的潛在矢量將決定解碼器生成多大的區域。
?
基本上，如果我們把變分的自動編碼器（VAE）中的潛在代碼看作是表示整個圖像的矢量，那么繪圖中的潛在代碼就可以看作是表示筆畫的矢量。最后，這些向量的序列實現了原始圖像的再現。
?
好吧，那么它是如何工作的呢？
在一個遞歸的 VAE 模型中，編碼器在每一個 timestep 會接收整個輸入圖像。在 Draw 中，我們需要將焦點集中在它們之間的 attention gate 上，因此編碼器只接收到網絡認為在該 timestep 重要的圖像部分。第一個 attention gate 被稱為“Read” attention 。
?
“ Read ” attention 分為兩部分：
?
選擇圖像的重要部分和裁剪圖像
?
選擇圖像的重要部分
?
為了確定圖像的哪一部分最重要，我們需要做些觀察，并根據這些觀察做出決定。在 DRAW中，我們使用前一個 timestep 的解碼器隱藏狀態。通過使用一個簡單的完全連接的圖層，我們可以將隱藏狀態映射到三個決定方形裁剪的參數：中心 X、中心 Y 和比例。
? ? ? ?
? ? ? ?
裁剪圖像
現在，我們不再對整個圖像進行編碼，而是對其進行裁剪，只對圖像的一小部分進行編碼。然后，這個編碼通過系統解碼成一個小補丁。
?
現在我們到達 attention gate 的第二部分，?“write”attention，（與“read”部分的設置相同），只是“write”attention 使用當前的解碼器，而不是前一個 timestep 的解碼器。
?
? ? ??
? ? ? ?
實際應用便是如此嗎？
?
雖然可以直觀地將注意力機制描述為一種裁剪，但實踐中使用了一種不同的方法。在上面描述的模型結構仍然精確的前提下，使用了? gaussian filters 矩陣，沒有利用裁剪的方式。 我們 在? DRAW 中 取了一組每個 filter 的中心間距都均勻的? gaussian filters 矩陣?。
?
代碼一覽
?
我們在 Eric Jang 的代碼的基礎上，對其進行一些清理和注釋，以便于理解.
?
# first we import our libraries
import tensorflow as tf
from tensorflow.examples.tutorials import mnist
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
import scipy.misc
import os
?
Eric 為我們提供了一些偉大的功能，可以幫助我們構建 “read” 和 “write” 注意門徑，還有過濾我們將使用的初始狀態功能，但是首先，我們需要添加新的功能，來使我們能創建一個密集層并合并圖像。并將它們保存到本地計算機中，以獲取更新的代碼。
# fully-conected layer
def dense(x, inputFeatures, outputFeatures, scope=None, with_w=False):
with tf.variable_scope(scope or "Linear"):
matrix = tf.get_variable("Matrix", [inputFeatures, outputFeatures], tf.float32, tf.random_normal_initializer(stddev=0.02))
bias = tf.get_variable("bias", [outputFeatures], initializer=tf.constant_initializer(0.0))
if with_w:
return tf.matmul(x, matrix) + bias, matrix, bias
else:
return tf.matmul(x, matrix) + bias
# merge images
def merge(images, size):
h, w = images.shape[1], images.shape[2]
img = np.zeros((h * size[0], w * size[1]))
for idx, image in enumerate(images):
i = idx % size[1]
j = idx / size[1]
img[j*h:j*h+h, i*w:i*w+w] = image
return img
# save image on local machine
def ims(name, img):
# print img[:10][:10]
????scipy.misc.toimage(img,?cmin=0,?cmax=1).save(name)
?
現在讓我們把代碼放在一起以便完成。
?
# DRAW implementation
class draw_model():
def __init__(self):
# First we download the MNIST dataset into our local machine.
self.mnist = input_data.read_data_sets("data/", one_hot=True)
print "------------------------------------"
print "MNIST Dataset Succesufully Imported"
print "------------------------------------"
self.n_samples = self.mnist.train.num_examples
# We set up the model parameters
# ------------------------------
# image width,height
self.img_size = 28
# read glimpse grid width/height
self.attention_n = 5
# number of hidden units / output size in LSTM
self.n_hidden = 256
# QSampler output size
self.n_z = 10
# MNIST generation sequence length
self.sequence_length = 10
# training minibatch size
self.batch_size = 64
# workaround for variable_scope(reuse=True)
self.share_parameters = False
# Build our model
self.images = tf.placeholder(tf.float32, [None, 784]) # input (batch_size * img_size)
self.e = tf.random_normal((self.batch_size, self.n_z), mean=0, stddev=1) # Qsampler noise
self.lstm_enc = tf.nn.rnn_cell.LSTMCell(self.n_hidden, state_is_tuple=True) # encoder Op
self.lstm_dec = tf.nn.rnn_cell.LSTMCell(self.n_hidden, state_is_tuple=True) # decoder Op
# Define our state variables
self.cs = [0] * self.sequence_length # sequence of canvases
self.mu, self.logsigma, self.sigma = [0] * self.sequence_length, [0] * self.sequence_length, [0] * self.sequence_length
# Initial states
h_dec_prev = tf.zeros((self.batch_size, self.n_hidden))
enc_state = self.lstm_enc.zero_state(self.batch_size, tf.float32)
dec_state = self.lstm_dec.zero_state(self.batch_size, tf.float32)
# Construct the unrolled computational graph
x = self.images
for t in range(self.sequence_length):
# error image + original image
c_prev = tf.zeros((self.batch_size, self.img_size**2)) if t == 0 else self.cs[t-1]
x_hat = x - tf.sigmoid(c_prev)
# read the image
r = self.read_basic(x,x_hat,h_dec_prev)
#sanity check
print r.get_shape()
# encode to guass distribution
self.mu[t], self.logsigma[t], self.sigma[t], enc_state = self.encode(enc_state, tf.concat(1, [r, h_dec_prev]))
# sample from the distribution to get z
z = self.sampleQ(self.mu[t],self.sigma[t])
#sanity check
print z.get_shape()
# retrieve the hidden layer of RNN
h_dec, dec_state = self.decode_layer(dec_state, z)
#sanity check
print h_dec.get_shape()
# map from hidden layer
self.cs[t] = c_prev + self.write_basic(h_dec)
h_dec_prev = h_dec
self.share_parameters = True # from now on, share variables
# Loss function
self.generated_images = tf.nn.sigmoid(self.cs[-1])
self.generation_loss = tf.reduce_mean(-tf.reduce_sum(self.images * tf.log(1e-10 + self.generated_images) + (1-self.images) * tf.log(1e-10 + 1 - self.generated_images),1))
kl_terms = [0]*self.sequence_length
for t in xrange(self.sequence_length):
mu2 = tf.square(self.mu[t])
sigma2 = tf.square(self.sigma[t])
logsigma = self.logsigma[t]
kl_terms[t] = 0.5 * tf.reduce_sum(mu2 + sigma2 - 2*logsigma, 1) - self.sequence_length*0.5 # each kl term is (1xminibatch)
self.latent_loss = tf.reduce_mean(tf.add_n(kl_terms))
self.cost = self.generation_loss + self.latent_loss
# Optimization
optimizer = tf.train.AdamOptimizer(1e-3, beta1=0.5)
grads = optimizer.compute_gradients(self.cost)
for i,(g,v) in enumerate(grads):
if g is not None:
grads[i] = (tf.clip_by_norm(g,5),v)
self.train_op = optimizer.apply_gradients(grads)
self.sess = tf.Session()
self.sess.run(tf.initialize_all_variables())
# Our training function
def train(self):
for i in xrange(20000):
xtrain, _ = self.mnist.train.next_batch(self.batch_size)
cs, gen_loss, lat_loss, _ = self.sess.run([self.cs, self.generation_loss, self.latent_loss, self.train_op], feed_dict={self.images: xtrain})
print "iter %d genloss %f latloss %f" % (i, gen_loss, lat_loss)
if i % 500 == 0:
cs = 1.0/(1.0+np.exp(-np.array(cs))) # x_recons=sigmoid(canvas)
for cs_iter in xrange(10):
results = cs[cs_iter]
results_square = np.reshape(results, [-1, 28, 28])
print results_square.shape
ims("results/"+str(i)+"-step-"+str(cs_iter)+".jpg",merge(results_square,[8,8]))
# Eric Jang's main functions
# --------------------------
# locate where to put attention filters on hidden layers
def attn_window(self, scope, h_dec):
with tf.variable_scope(scope, reuse=self.share_parameters):
parameters = dense(h_dec, self.n_hidden, 5)
# center of 2d gaussian on a scale of -1 to 1
gx_, gy_, log_sigma2, log_delta, log_gamma = tf.split(1,5,parameters)
# move gx/gy to be a scale of -imgsize to +imgsize
gx = (self.img_size+1)/2 * (gx_ + 1)
gy = (self.img_size+1)/2 * (gy_ + 1)
sigma2 = tf.exp(log_sigma2)
# distance between patches
delta = (self.img_size - 1) / ((self.attention_n-1) * tf.exp(log_delta))
# returns [Fx, Fy, gamma]
return self.filterbank(gx,gy,sigma2,delta) + (tf.exp(log_gamma),)
# Construct patches of gaussian filters
def filterbank(self, gx, gy, sigma2, delta):
# 1 x N, look like [[0,1,2,3,4]]
grid_i = tf.reshape(tf.cast(tf.range(self.attention_n), tf.float32),[1, -1])
# individual patches centers
mu_x = gx + (grid_i - self.attention_n/2 - 0.5) * delta
mu_y = gy + (grid_i - self.attention_n/2 - 0.5) * delta
mu_x = tf.reshape(mu_x, [-1, self.attention_n, 1])
mu_y = tf.reshape(mu_y, [-1, self.attention_n, 1])
# 1 x 1 x imgsize, looks like [[[0,1,2,3,4,...,27]]]
im = tf.reshape(tf.cast(tf.range(self.img_size), tf.float32), [1, 1, -1])
# list of gaussian curves for x and y
sigma2 = tf.reshape(sigma2, [-1, 1, 1])
Fx = tf.exp(-tf.square((im - mu_x) / (2*sigma2)))
Fy = tf.exp(-tf.square((im - mu_x) / (2*sigma2)))
# normalize area-under-curve
Fx = Fx / tf.maximum(tf.reduce_sum(Fx,2,keep_dims=True),1e-8)
Fy = Fy / tf.maximum(tf.reduce_sum(Fy,2,keep_dims=True),1e-8)
return Fx, Fy
# read operation without attention
def read_basic(self, x, x_hat, h_dec_prev):
return tf.concat(1,[x,x_hat])
# read operation with attention
def read_attention(self, x, x_hat, h_dec_prev):
Fx, Fy, gamma = self.attn_window("read", h_dec_prev)
# apply parameters for patch of gaussian filters
def filter_img(img, Fx, Fy, gamma):
Fxt = tf.transpose(Fx, perm=[0,2,1])
img = tf.reshape(img, [-1, self.img_size, self.img_size])
# apply the gaussian patches
glimpse = tf.batch_matmul(Fy, tf.batch_matmul(img, Fxt))
glimpse = tf.reshape(glimpse, [-1, self.attention_n**2])
# scale using the gamma parameter
return glimpse * tf.reshape(gamma, [-1, 1])
x = filter_img(x, Fx, Fy, gamma)
x_hat = filter_img(x_hat, Fx, Fy, gamma)
return tf.concat(1, [x, x_hat])
# encoder function for attention patch
def encode(self, prev_state, image):
# update the RNN with our image
with tf.variable_scope("encoder",reuse=self.share_parameters):
hidden_layer, next_state = self.lstm_enc(image, prev_state)
# map the RNN hidden state to latent variables
with tf.variable_scope("mu", reuse=self.share_parameters):
mu = dense(hidden_layer, self.n_hidden, self.n_z)
with tf.variable_scope("sigma", reuse=self.share_parameters):
logsigma = dense(hidden_layer, self.n_hidden, self.n_z)
sigma = tf.exp(logsigma)
return mu, logsigma, sigma, next_state
def sampleQ(self, mu, sigma):
return mu + sigma*self.e
# decoder function
def decode_layer(self, prev_state, latent):
# update decoder RNN using our latent variable
with tf.variable_scope("decoder", reuse=self.share_parameters):
hidden_layer, next_state = self.lstm_dec(latent, prev_state)
return hidden_layer, next_state
# write operation without attention
def write_basic(self, hidden_layer):
# map RNN hidden state to image
with tf.variable_scope("write", reuse=self.share_parameters):
decoded_image_portion = dense(hidden_layer, self.n_hidden, self.img_size**2)
return decoded_image_portion
# write operation with attention
def write_attention(self, hidden_layer):
with tf.variable_scope("writeW", reuse=self.share_parameters):
w = dense(hidden_layer, self.n_hidden, self.attention_n**2)
w = tf.reshape(w, [self.batch_size, self.attention_n, self.attention_n])
Fx, Fy, gamma = self.attn_window("write", hidden_layer)
Fyt = tf.transpose(Fy, perm=[0,2,1])
wr = tf.batch_matmul(Fyt, tf.batch_matmul(w, Fx))
wr = tf.reshape(wr, [self.batch_size, self.img_size**2])
return wr * tf.reshape(1.0/gamma, [-1, 1])
model = draw_mod
?
你可以在作者的github主頁上查看更多:
https://github.com/shugert/DRAW
原文鏈接：
https://hackernoon.com/understanding-a-recurrent-neural-network-for-image-generation-7e2f83wdg
(*本文為 AI科技大本營翻譯文章， 轉載請聯系微信? 1092722531 )
◆
福利時刻
◆
入群參與每周抽獎~
掃碼添加小助手，回復：大會，加入福利群，參與抽獎送禮！
CSDN年度Top應用案例重磅評選活動正在火熱報名中。 我們希望找到在汽車、金融、醫療、教育等各大行業的AI Top 30+案例，相信挖掘出優秀先行者會給不同行業領域帶來啟迪，進而推動整個AI行業的發展進程。歡迎參選： https://aiprocon.csdn.net/m/topic/ai_procon/top30
? ? ? ?
推薦閱讀
-
IBM重磅開源Power芯片指令集？國產芯迎來新機遇？
-
KDD 2019高維稀疏數據上的深度學習Workshop論文匯總
-
說出來你可能不信，現在酒廠都在招算法工程師
-
姚班三兄弟3萬塊創業八年，曠視終沖刺港股
-
2019 AI ProCon日程出爐 ： Amazon首席科學家李沐親授「深度學習」
-
AI Top 30+案例評選等你來秀！
-
福利 | 馬上為你安排和大咖面對面交流的機會，不可錯過
-
92年小哥絞盡腦汁騙得價值800萬比特幣, 破案后警方決定還給受害者
-
他是葉問制片人也是紅色通緝犯, 他讓泰森卷入ICO, 卻最終演變成了一場狗血的羅生門……
你點的每個“在看”，我都 認真當成了喜歡
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
