1. 程式人生 > >Tensorflow反捲積(DeConv)實現原理+手寫python程式碼實現反捲積(DeConv)

Tensorflow反捲積(DeConv)實現原理+手寫python程式碼實現反捲積(DeConv)

上一篇文章已經介紹過卷積的實現,這篇文章我們學習反捲積原理,同樣,在瞭解反捲積原理後,在後面手寫python程式碼實現反捲積。

1 反捲積原理

反捲積原理不太好用文字描述,這裡直接以一個簡單例子描述反捲積過程。

假設輸入如下:

[[1,0,1],
 [0,2,1],
 [1,1,0]]

反捲積卷積核如下:

[[ 1, 0, 1],
 [-1, 1, 0],
 [ 0,-1, 0]]

現在通過stride=2來進行反捲積,使得尺寸由原來的3*3變為6*6.那麼在Tensorflow框架中,反捲積的過程如下(不同框架在裁剪這步可能不一樣):

反捲積實現例子
其實通過我繪製的這張圖,就已經把原理講的很清楚了。大致步奏就是,先填充0,然後進行卷積,卷積過程跟上一篇文章講述的一致。最後一步還要進行裁剪。好了,原理講完了,(#^.^#)….

2 程式碼實現

上一篇文章我們只針對了輸出通道數為1進行程式碼實現,在這篇文章中,反捲積我們將輸出通道設定為多個,這樣更符合實際場景。

先定義輸入和卷積核:

input_data=[
               [[1,0,1],
                [0,2,1],
                [1,1,0]],

               [[2,0,2],
                [0,1,0],
                [1,0,0]],

               [[1,1,1],
                [2,2,0],
                [1
,1,1]], [[1,1,2], [1,0,1], [0,2,2]] ] weights_data=[ [[[ 1, 0, 1], [-1, 1, 0], [ 0,-1, 0]], [[-1, 0, 1], [ 0, 0, 1], [ 1, 1, 1]], [[ 0, 1, 1
], [ 2, 0, 1], [ 1, 2, 1]], [[ 1, 1, 1], [ 0, 2, 1], [ 1, 0, 1]]], [[[ 1, 0, 2], [-2, 1, 1], [ 1,-1, 0]], [[-1, 0, 1], [-1, 2, 1], [ 1, 1, 1]], [[ 0, 0, 0], [ 2, 2, 1], [ 1,-1, 1]], [[ 2, 1, 1], [ 0,-1, 1], [ 1, 1, 1]]] ]

上面定義的輸入和卷積核,在接下的運算過程如下圖所示:

執行過程

可以看到實際上,反捲積和卷積基本一致,差別在於,反捲積需要填充過程,並在最後一步需要裁剪。具體實現程式碼如下:

#根據輸入map([h,w])和卷積核([k,k]),計算卷積後的feature map
import numpy as np
def compute_conv(fm,kernel):
    [h,w]=fm.shape 
    [k,_]=kernel.shape 
    r=int(k/2)
    #定義邊界填充0後的map
    padding_fm=np.zeros([h+2,w+2],np.float32)
    #儲存計算結果
    rs=np.zeros([h,w],np.float32) 
    #將輸入在指定該區域賦值,即除了4個邊界後,剩下的區域
    padding_fm[1:h+1,1:w+1]=fm 
    #對每個點為中心的區域遍歷
    for i in range(1,h+1):
        for j in range(1,w+1): 
            #取出當前點為中心的k*k區域
            roi=padding_fm[i-r:i+r+1,j-r:j+r+1]
            #計算當前點的卷積,對k*k個點點乘後求和
            rs[i-1][j-1]=np.sum(roi*kernel)

    return rs

#填充0
def fill_zeros(input):
    [c,h,w]=input.shape
    rs=np.zeros([c,h*2+1,w*2+1],np.float32)

    for i in range(c):
        for j in range(h):
            for k in range(w): 
                rs[i,2*j+1,2*k+1]=input[i,j,k] 
    return rs

def my_deconv(input,weights):
    #weights shape=[out_c,in_c,h,w]
    [out_c,in_c,h,w]=weights.shape   
    out_h=h*2
    out_w=w*2
    rs=[]
    for i in range(out_c):
        w=weights[i]
        tmp=np.zeros([out_h,out_w],np.float32)
        for j in range(in_c):
            conv=compute_conv(input[j],w[j])
            #注意裁剪,最後一行和最後一列去掉
            tmp=tmp+conv[0:out_h,0:out_w]
        rs.append(tmp)

    return rs 


def main():  
    input=np.asarray(input_data,np.float32)
    input= fill_zeros(input)
    weights=np.asarray(weights_data,np.float32)
    deconv=my_deconv(input,weights)

    print(np.asarray(deconv))

if __name__=='__main__':
    main()

計算卷積程式碼,跟上一篇文章一致。程式碼直接看註釋,不再解釋。執行結果如下:

[[[  4.   3.   6.   2.   7.   3.]
  [  4.   3.   3.   2.   7.   5.]
  [  8.   6.   8.   5.  11.   2.]
  [  3.   2.   7.   2.   3.   3.]
  [  5.   5.  11.   3.   9.   3.]
  [  2.   1.   4.   5.   4.   4.]]

 [[  4.   1.   7.   0.   7.   2.]
  [  5.   6.   0.   1.   8.   5.]
  [  8.   0.   8.  -2.  14.   2.]
  [  3.   3.   9.   8.   1.   0.]
  [  3.   0.  13.   0.  11.   2.]
  [  3.   5.   3.   1.   3.   0.]]]

為了驗證實現的程式碼的正確性,我們使用tensorflow的conv2d_transpose函式執行相同的輸入和卷積核,看看結果是否一致。驗證程式碼如下:

import tensorflow as tf
import numpy as np 
def tf_conv2d_transpose(input,weights):
    #input_shape=[n,height,width,channel]
    input_shape = input.get_shape().as_list()
    #weights shape=[height,width,out_c,in_c]
    weights_shape=weights.get_shape().as_list() 
    output_shape=[input_shape[0], input_shape[1]*2 , input_shape[2]*2 , weights_shape[2]]

    print("output_shape:",output_shape)

    deconv=tf.nn.conv2d_transpose(input,weights,output_shape=output_shape,
        strides=[1, 2, 2, 1], padding='SAME')
    return deconv

def main(): 
    weights_np=np.asarray(weights_data,np.float32)
    #將輸入的每個卷積核旋轉180°
    weights_np=np.rot90(weights_np,2,(2,3))

    const_input = tf.constant(input_data , tf.float32)
    const_weights = tf.constant(weights_np , tf.float32 )


    input = tf.Variable(const_input,name="input")
    #[c,h,w]------>[h,w,c]
    input=tf.transpose(input,perm=(1,2,0))
    #[h,w,c]------>[n,h,w,c]
    input=tf.expand_dims(input,0)

    #weights shape=[out_c,in_c,h,w]
    weights = tf.Variable(const_weights,name="weights")
    #[out_c,in_c,h,w]------>[h,w,out_c,in_c]
    weights=tf.transpose(weights,perm=(2,3,0,1))

    #執行tensorflow的反捲積
    deconv=tf_conv2d_transpose(input,weights) 

    init=tf.global_variables_initializer()
    sess=tf.Session()
    sess.run(init)

    deconv_val  = sess.run(deconv) 

    hwc=deconv_val[0]
    print(hwc) 

if __name__=='__main__':
    main() 

上面程式碼中,有幾點需要注意:

  1. 每個卷積核需要旋轉180°後,再傳入tf.nn.conv2d_transpose函式中,因為tf.nn.conv2d_transpose內部會旋轉180°,所以提前旋轉,再經過內部旋轉後,能保證卷積核跟我們所使用的卷積核的資料排列一致。
  2. 我們定義的輸入的shape為[c,h,w]需要轉為tensorflow所使用的[n,h,w,c]。
  3. 我們定義的卷積核shape為[out_c,in_c,h,w],需要轉為tensorflow反捲積中所使用的[h,w,out_c,in_c]

執行上面程式碼後,執行結果如下:

[[  4.   3.   6.   2.   7.   3.]
 [  4.   3.   3.   2.   7.   5.]
 [  8.   6.   8.   5.  11.   2.]
 [  3.   2.   7.   2.   3.   3.]
 [  5.   5.  11.   3.   9.   3.]
 [  2.   1.   4.   5.   4.   4.]]
[[  4.   1.   7.   0.   7.   2.]
 [  5.   6.   0.   1.   8.   5.]
 [  8.   0.   8.  -2.  14.   2.]
 [  3.   3.   9.   8.   1.   0.]
 [  3.   0.  13.   0.  11.   2.]
 [  3.   5.   3.   1.   3.   0.]]

對比結果可以看到,資料是一致的,證明前面手寫的python實現的反捲積程式碼是正確的。