python 反卷积(DeConv) tensorflow反卷积(DeConv)(实现原理+手写)

举报
风吹稻花香 发表于 2021/06/05 00:08:56 2021/06/05
【摘要】 Tensorflow反卷积(DeConv)实现原理+手写python代码实现反卷积(DeConv) 理解: https://www.zhihu.com/question/43609045/answer/130868981 上一篇文章已经介绍过卷积的实现,这篇文章我们学习反卷积原理,同样,在了解反卷积原理后,在后面手写python代码实现反卷积。 反卷积用途:上采样...
Tensorflow反卷积(DeConv)实现原理+手写python代码实现反卷积(DeConv)

理解:

https://www.zhihu.com/question/43609045/answer/130868981

上一篇文章已经介绍过卷积的实现,这篇文章我们学习反卷积原理,同样,在了解反卷积原理后,在后面手写python代码实现反卷积。

反卷积用途:
上采样,
gan,反卷积来生成图片

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实现的反卷积代码是正确的。

文章来源: blog.csdn.net,作者:网奇,版权归原作者所有,如需转载,请联系作者。

原文链接:blog.csdn.net/jacke121/article/details/80208175

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。