blocks|key|2656579|text|这是我在网上看到的最好的解释，卷积转置是如何工作的here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2656580|我将给出我自己的简短描述。它以分数步长应用卷积。换句话说，将输入值(用零)隔开，以便在可能小于过滤器大小的区域上应用过滤器。|2656581|至于为什么人们会想要使用它。它可以用作一种具有学习权重的上采样，而不是双线性插值或其他固定形式的上采样。|2656582|entityMap|0|LINK|mutability|MUTABLE|url|https://datascience.stackexchange.com/questions/6107/what-are-deconvolutional-layers^0|P|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

This is the best explanation I've seen online how convolution transpose works is <a href="https://datascience.stackexchange.com/questions/6107/what-are-deconvolutional-layers">here</a>.

I'll give my own short description. It applies convolution with a fractional stride. In other words spacing out the input values (with zeroes) to apply the filter over a region that's potentially smaller than the filter size. 

As for the why one would want to use it. It can be used as a sort of upsampling with learned weights as opposed to bilinear interpolation or some other fixed form of upsampling.

blocks|key|113097|text|这是从“梯度”角度的另一个观点，也就是为什么TensorFlow文档说conv2d_transpose()“实际上是conv2d的转置(gradient)，而不是实际的反卷积”。有关在此conv2d_transpose**，中完成的实际计算的更多详细信息，我强烈建议从第19页开始使用[]。**|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|113098|四个相关函数|113099|在tf.nn中，有4个密切相关且相当混乱的二维卷积函数：|113100|113101|tf.nn.conv2d|unordered-list-item|113102|tf.nn.conv2d_backprop_filter|113103|tf.nn.conv2d_backprop_input|113104|tf.nn.conv2d_transpose|113105|113106|一句话总结:它们都是二维卷积。它们的不同之处在于输入参数排序、输入旋转或转置、步长(包括分数步长)、填充等。有了tf.nn.conv2d，可以通过转换输入和更改conv2d参数来实现所有其他3个操作。|113107|问题设置|113108|向前和向后computations:的|113109|113110|113111|#+forward
out+=+conv2d(x,+w)

#+backward,+given+d_out
=>+find+d_x?
=>+find+d_w?|code-block|syntax|javascript|113112|在正演计算中，我们用滤波器w计算输入图像x的卷积，结果是out。在反向计算中，假设我们给定了d_out，它是梯度w.r.t。out。我们的目标是找到d_x和d_w，它们是梯度w.r.t。x和w。|113113|为了便于讨论，我们假设：|113114|所有的步长大小都是1|113115|All填充和奇数都是1|113116|
|113117|Use+out_channels+VALID+|113118|113119|奇数过滤器大小，这避免了一些不对称的形状问题|113120|113121|简短的回答|113122|从概念上讲，在上述假设下，我们有以下关系：|113123|out+=+conv2d(x,+w,+padding='VALID')
d_x+=+conv2d(d_out,+rot180(w),+padding='FULL')
d_w+=+conv2d(x,+d_out,+padding='VALID')|113124|其中rot180是旋转180度的2d矩阵(左右翻转和自上而下翻转)，FULL的意思是“在与输入部分重叠的地方应用滤波器”(参见theano+docs)。请注意，这仅适用于上述假设，但是，可以更改conv2d参数以对其进行泛化。|113125|关键要点：|113126|输入梯度d_x是输出梯度d_out和权重w的卷积，具有一定的权值梯度d_w是输入x和输出梯度d_out的卷积，具有一定的权重|113127|长长的答案|113128|现在，让我们给出一个实际的工作代码示例，说明如何使用上面的4个函数在给定d_out的情况下计算d_x和d_w。这显示了conv2d、conv2d_backprop_filter、conv2d_backprop_input和conv2d_transpose是如何相互关联的。Please+find+the+full+scripts+here。|113129|以4种不同的方式计算d_x+：|113130|#+Method+1:+TF's+autodiff
d_x+=+tf.gradients(f,+x)[0]

#+Method+2:+manually+using+conv2d
d_x_manual+=+tf.nn.conv2d(input=tf_pad_to_full_conv2d(d_out,+w_size),
++++++++++++++++++++++++++filter=tf_rot180(w),
++++++++++++++++++++++++++strides=strides,
++++++++++++++++++++++++++padding='VALID')

#+Method+3:+conv2d_backprop_input
d_x_backprop_input+=+tf.nn.conv2d_backprop_input(input_sizes=x_shape,
+++++++++++++++++++++++++++++++++++++++++++++++++filter=w,
+++++++++++++++++++++++++++++++++++++++++++++++++out_backprop=d_out,
+++++++++++++++++++++++++++++++++++++++++++++++++strides=strides,
+++++++++++++++++++++++++++++++++++++++++++++++++padding='VALID')

#+Method+4:+conv2d_transpose
d_x_transpose+=+tf.nn.conv2d_transpose(value=d_out,
+++++++++++++++++++++++++++++++++++++++filter=w,
+++++++++++++++++++++++++++++++++++++++output_shape=x_shape,
+++++++++++++++++++++++++++++++++++++++strides=strides,
+++++++++++++++++++++++++++++++++++++++padding='VALID')|113131|以三种不同的方式计算d_w+：|113132|#+Method+1:+TF's+autodiff
d_w+=+tf.gradients(f,+w)[0]

#+Method+2:+manually+using+conv2d
d_w_manual+=+tf_NHWC_to_HWIO(tf.nn.conv2d(input=x,
++++++++++++++++++++++++++++++++++++++++++filter=tf_NHWC_to_HWIO(d_out),
++++++++++++++++++++++++++++++++++++++++++strides=strides,
++++++++++++++++++++++++++++++++++++++++++padding='VALID'))

#+Method+3:+conv2d_backprop_filter
d_w_backprop_filter+=+tf.nn.conv2d_backprop_filter(input=x,
+++++++++++++++++++++++++++++++++++++++++++++++++++filter_sizes=w_shape,
+++++++++++++++++++++++++++++++++++++++++++++++++++out_backprop=d_out,
+++++++++++++++++++++++++++++++++++++++++++++++++++strides=strides,
+++++++++++++++++++++++++++++++++++++++++++++++++++padding='VALID')|113133|tf_rot180、tf_pad_to_full_conv2d、tf_NHWC_to_HWIO的实现请参考full+scripts。在脚本中，我们检查不同方法的最终输出值是否相同；也可以使用numpy实现。|113134|entityMap|0|LINK|mutability|MUTABLE|url|http://deeplearning.net/software/theano/library/tensor/nnet/conv.html#theano.tensor.nnet.conv2d|1|https://gist.github.com/yxlao/ef50416011b9587835ac752aa3ce3530|2^0|Z|I|2L|G|1W|8|2L|I|3Y|5|0|0|6|0|0|S|1|5|0|0|0|C|0|C|0|0|S|0|S|0|0|R|0|R|0|0|M|0|M|0|0|0|E|1K|C|28|6|0|0|0|0|0|0|D|1|K|1|S|3|1A|5|1Q|3|22|3|26|3|2L|1|2N|1|0|0|9|1|0|A|1|0|0|4|C|H|5|0|0|0|0|0|0|0|2|6|Y|4|1R|B|0|0|0|4|3|C|5|K|1|Y|3|14|1|1A|5|0|0|10|5|1B|3|1F|3|1N|6|1U|M|2H|L|33|G|3S|X|1|0|A|3|E|1|A|3|0|0|A|3|E|1|A|3|0|0|0|9|A|L|W|F|1H|C|2|0^^$0|@$1|2|3|4|5|6|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|D]|$9|2W|A|2X|B|D]|$9|2Y|A|2Z|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|30|8|@$9|31|A|32|B|D]]|E|@]|F|$]]|$1|I|3|J|5|6|7|33|8|@$9|34|A|35|B|D]|$9|36|A|37|B|C]]|E|@]|F|$]]|$1|K|3|-4|5|6|7|38|8|@]|E|@]|F|$]]|$1|L|3|M|5|N|7|39|8|@$9|3A|A|3B|B|D]|$9|3C|A|3D|B|C]]|E|@]|F|$]]|$1|O|3|P|5|N|7|3E|8|@$9|3F|A|3G|B|D]|$9|3H|A|3I|B|C]]|E|@]|F|$]]|$1|Q|3|R|5|N|7|3J|8|@$9|3K|A|3L|B|D]|$9|3M|A|3N|B|C]]|E|@]|F|$]]|$1|S|3|T|5|N|7|3O|8|@$9|3P|A|3Q|B|D]|$9|3R|A|3S|B|C]]|E|@]|F|$]]|$1|U|3|-4|5|6|7|3T|8|@]|E|@]|F|$]]|$1|V|3|W|5|6|7|3U|8|@$9|3V|A|3W|B|D]|$9|3X|A|3Y|B|C]|$9|3Z|A|40|B|C]]|E|@]|F|$]]|$1|X|3|Y|5|6|7|41|8|@]|E|@]|F|$]]|$1|Z|3|10|5|6|7|42|8|@]|E|@]|F|$]]|$1|11|3|-4|5|N|7|43|8|@]|E|@]|F|$]]|$1|12|3|-4|5|6|7|44|8|@]|E|@]|F|$]]|$1|13|3|14|5|15|7|45|8|@]|E|@]|F|$16|17]]|$1|18|3|19|5|6|7|46|8|@$9|47|A|48|B|C]|$9|49|A|4A|B|C]|$9|4B|A|4C|B|C]|$9|4D|A|4E|B|C]|$9|4F|A|4G|B|C]|$9|4H|A|4I|B|C]|$9|4J|A|4K|B|C]|$9|4L|A|4M|B|C]|$9|4N|A|4O|B|C]]|E|@]|F|$]]|$1|1A|3|1B|5|6|7|4P|8|@]|E|@]|F|$]]|$1|1C|3|1D|5|6|7|4Q|8|@$9|4R|A|4S|B|C]]|E|@]|F|$]]|$1|1E|3|1F|5|N|7|4T|8|@$9|4U|A|4V|B|C]]|E|@]|F|$]]|$1|1G|3|1H|5|6|7|4W|8|@]|E|@]|F|$]]|$1|1I|3|1J|5|N|7|4X|8|@$9|4Y|A|4Z|B|C]|$9|50|A|51|B|C]]|E|@]|F|$]]|$1|1K|3|1H|5|6|7|52|8|@]|E|@]|F|$]]|$1|1L|3|1M|5|N|7|53|8|@]|E|@]|F|$]]|$1|1N|3|-4|5|6|7|54|8|@]|E|@]|F|$]]|$1|1O|3|1P|5|6|7|55|8|@]|E|@]|F|$]]|$1|1Q|3|1R|5|6|7|56|8|@]|E|@]|F|$]]|$1|1S|3|1T|5|15|7|57|8|@]|E|@]|F|$16|17]]|$1|1U|3|1V|5|6|7|58|8|@$9|59|A|5A|B|C]|$9|5B|A|5C|B|C]]|E|@$9|5D|A|5E|1|5F]]|F|$]]|$1|1W|3|1X|5|6|7|5G|8|@]|E|@]|F|$]]|$1|1Y|3|1Z|5|6|7|5H|8|@$9|5I|A|5J|B|C]|$9|5K|A|5L|B|C]|$9|5M|A|5N|B|C]|$9|5O|A|5P|B|C]|$9|5Q|A|5R|B|C]|$9|5S|A|5T|B|C]]|E|@]|F|$]]|$1|20|3|21|5|6|7|5U|8|@]|E|@]|F|$]]|$1|22|3|23|5|6|7|5V|8|@$9|5W|A|5X|B|C]|$9|5Y|A|5Z|B|C]|$9|60|A|61|B|C]|$9|62|A|63|B|C]|$9|64|A|65|B|C]|$9|66|A|67|B|C]|$9|68|A|69|B|C]]|E|@$9|6A|A|6B|1|6C]]|F|$]]|$1|24|3|25|5|6|7|6D|8|@$9|6E|A|6F|B|D]|$9|6G|A|6H|B|D]|$9|6I|A|6J|B|C]]|E|@]|F|$]]|$1|26|3|27|5|15|7|6K|8|@]|E|@]|F|$16|17]]|$1|28|3|29|5|6|7|6L|8|@$9|6M|A|6N|B|D]|$9|6O|A|6P|B|D]|$9|6Q|A|6R|B|C]]|E|@]|F|$]]|$1|2A|3|2B|5|15|7|6S|8|@]|E|@]|F|$16|17]]|$1|2C|3|2D|5|6|7|6T|8|@$9|6U|A|6V|B|C]|$9|6W|A|6X|B|C]|$9|6Y|A|6Z|B|C]]|E|@$9|70|A|71|1|72]]|F|$]]|$1|2E|3|-4|5|6|7|73|8|@]|E|@]|F|$]]]|2F|$2G|$5|2H|2I|2J|F|$2K|2L]]|2M|$5|2H|2I|2J|F|$2K|2N]]|2O|$5|2H|2I|2J|F|$2K|2N]]]]

Here's another viewpoint from the "gradients" perspective, i.e. why TensorFlow documentation says <code>conv2d_transpose()</code> is "actually the transpose (gradient) of conv2d rather than an actual deconvolution". For more details on the actual computation done in <code>conv2d_transpose</code>, I would highly recommend <a href="https://arxiv.org/pdf/1603.07285.pdf" rel="noreferrer">this article</a>, starting from page 19.

<h3>Four Related Functions</h3>

In <code>tf.nn</code>, there are 4 closely related and rather confusing functions for 2d convolution:

<ul>
<li><code>tf.nn.conv2d</code></li>
<li><code>tf.nn.conv2d_backprop_filter</code></li>
<li><code>tf.nn.conv2d_backprop_input</code></li>
<li><code>tf.nn.conv2d_transpose</code></li>
</ul>

One sentence summary: they are all just 2d convolutions. Their differences are in their input arguments ordering, input rotation or transpose, strides (including fractional stride size), paddings and etc. With <code>tf.nn.conv2d</code> in hand, one can implement all of the 3 other ops by transforming inputs and changing the <code>conv2d</code> arguments.

<h3>Problem Settings</h3>

<ul>
<li>Forward and backward computations:</li>
</ul>



<pre class="lang-py prettyprint-override"><code># forward
out = conv2d(x, w)

# backward, given d_out
=&gt; find d_x?
=&gt; find d_w?
</code></pre>

In the forward computation, we compute the convolution of input image <code>x</code> with the filter <code>w</code>, and the result is <code>out</code>.
In the backward computation, assume we're given <code>d_out</code>, which is the gradient w.r.t. <code>out</code>. Our goal is to find <code>d_x</code> and <code>d_w</code>, which are the gradient w.r.t. <code>x</code> and <code>w</code> respectively.

For the ease of discussion, we assume:

<ul>
<li>All stride size to be <code>1</code></li>
<li>All <code>in_channels</code> and <code>out_channels</code> are <code>1</code></li>
<li>Use <code>VALID</code> padding</li>
<li>Odd number filter size, this avoids some asymmetric shape problem</li>
</ul>

<h3>Short Answer</h3>

Conceptually, with the assumptions above, we have the following relations:

<pre class="lang-py prettyprint-override"><code>out = conv2d(x, w, padding='VALID')
d_x = conv2d(d_out, rot180(w), padding='FULL')
d_w = conv2d(x, d_out, padding='VALID')
</code></pre>

Where <code>rot180</code> is a 2d matrix rotated 180 degrees (a left-right flip and a top-down flip), <code>FULL</code> means "apply filter wherever it partly overlaps with the input" (see <a href="http://deeplearning.net/software/theano/library/tensor/nnet/conv.html#theano.tensor.nnet.conv2d" rel="noreferrer">theano docs</a>). Notes that this is only valid with the above assumptions, however, one can change the conv2d arguments to generalize it.

The key takeaways:

<ul>
<li>The input gradient <code>d_x</code> is the convolution of the output gradient <code>d_out</code> and the weight <code>w</code>, with some modifications.</li>
<li>The weight gradient <code>d_w</code> is the convolution of the input <code>x</code> and the output gradient <code>d_out</code>, with some modifications.</li>
</ul>

<h3>Long Answer</h3>

Now, let's give an actual working code example of how to use the 4 functions above to compute <code>d_x</code> and <code>d_w</code> given <code>d_out</code>. This shows how
<code>conv2d</code>,
<code>conv2d_backprop_filter</code>,
<code>conv2d_backprop_input</code>, and
<code>conv2d_transpose</code> are related to each other. 
<a href="https://gist.github.com/yxlao/ef50416011b9587835ac752aa3ce3530" rel="noreferrer">Please find the full scripts here</a>. 

Computing <code>d_x</code> in 4 different ways:

<pre class="lang-py prettyprint-override"><code># Method 1: TF's autodiff
d_x = tf.gradients(f, x)[0]

# Method 2: manually using conv2d
d_x_manual = tf.nn.conv2d(input=tf_pad_to_full_conv2d(d_out, w_size),
 filter=tf_rot180(w),
 strides=strides,
 padding='VALID')

# Method 3: conv2d_backprop_input
d_x_backprop_input = tf.nn.conv2d_backprop_input(input_sizes=x_shape,
 filter=w,
 out_backprop=d_out,
 strides=strides,
 padding='VALID')

# Method 4: conv2d_transpose
d_x_transpose = tf.nn.conv2d_transpose(value=d_out,
 filter=w,
 output_shape=x_shape,
 strides=strides,
 padding='VALID')
</code></pre>

Computing <code>d_w</code> in 3 different ways:

<pre class="lang-py prettyprint-override"><code># Method 1: TF's autodiff
d_w = tf.gradients(f, w)[0]

# Method 2: manually using conv2d
d_w_manual = tf_NHWC_to_HWIO(tf.nn.conv2d(input=x,
 filter=tf_NHWC_to_HWIO(d_out),
 strides=strides,
 padding='VALID'))

# Method 3: conv2d_backprop_filter
d_w_backprop_filter = tf.nn.conv2d_backprop_filter(input=x,
 filter_sizes=w_shape,
 out_backprop=d_out,
 strides=strides,
 padding='VALID')
</code></pre>

Please see the <a href="https://gist.github.com/yxlao/ef50416011b9587835ac752aa3ce3530" rel="noreferrer">full scripts</a> for the implementation of <code>tf_rot180</code>, <code>tf_pad_to_full_conv2d</code>, <code>tf_NHWC_to_HWIO</code>. In the scripts, we check that the final output values of different methods are the same; a numpy implementation is also available.

blocks|key|110671|text|conv2d_transpose()简单地将权重转置并翻转180度。然后它应用标准的conv2d()。“转置”实际上意味着它改变了权重张量中“列”的顺序。请检查下面的示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|110672|这里有一个使用卷积的示例，其中stride=1和padding=‘相同’。这是一个简单的情况，但同样的推理也可以应用于其他情况。|110673|假设我们有：|110674|权重输入:+MNIST图像28x28x1，shape+=+28,28,1|110675|Convolutional+layer:+32个滤镜，7x7，|unordered-list-item|110676|=+7，7，1，32，name+=+W_conv1|110677|110678|110679|如果我们对输入进行卷积，那么将的激活具有以下形状:+1,28,28,32。|110680|+activations+=+sess.run(h_conv1,feed_dict={x:np.reshape(image,[1,784])})|code-block|syntax|javascript|110681|其中：|110682|+W_conv1+=+weight_variable([7,+7,+1,+32])
+b_conv1+=+bias_variable([32])
+h_conv1+=+conv2d(x,+W_conv1,+strides=[1,+1,+1,+1],+padding='SAME')+%2B+b_conv1|110683|为了获得“反卷积”或“转置卷积”，我们可以这样对卷积激活使用conv2d_transpose()：|110684|++deconv+=+conv2d_transpose(activations,W_conv1,+output_shape=[1,28,28,1],padding='SAME')|110685|或者使用conv2d()，我们需要转置和翻转权重：|110686|++transposed_weights+=+tf.transpose(W_conv1,+perm=[0,+1,+3,+2])|110687|在这里，我们将“列”的顺序从0,+1，2,3改为0，1，3，2。因此，我们将从7，7，1，32获得一个带有shape=7,7,32,1的张量。然后我们反转权重：|110688|++for+i+in+range(n_filters):
++++++#+Flip+the+weights+by+180+degrees
++++++transposed_and_flipped_weights[:,:,i,0]+=++sess.run(tf.reverse(transposed_weights[:,:,i,0],+axis=[0,+1]))|110689|然后我们可以用conv2d()计算卷积如下：|110690|++strides+=+[1,1,1,1]
++deconv+=+conv2d(activations,transposed_and_flipped_weights,strides=strides,padding='SAME')|110691|我们会得到和以前一样的结果。使用conv2d_backprop_input()也可以获得完全相同的结果：|110692|+++deconv+=+conv2d_backprop_input([1,28,28,1],W_conv1,activations,+strides=strides,+padding='SAME')|110693|结果如下所示：|110694|Test+of+the+conv2d(),+conv2d_tranposed()+and+conv2d_backprop_input()|offset|length|110695|我们可以看到结果是一样的。要以更好的方式查看它，请查看我的代码：|110696|https://github.com/simo23/conv2d_transpose|110697|在这里，我使用标准的conv2d()复制conv2d_transpose()函数的输出。|110698|entityMap|0|LINK|mutability|MUTABLE|url|https://i.stack.imgur.com/GJk7l.png|1^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1W|0|0|0|0|16|1|0|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|26|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|27|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|28|8|@]|9|@]|A|$]]|$1|K|3|L|5|J|7|29|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|2D|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|2E|8|@]|9|@]|A|$]]|$1|X|3|Y|5|S|7|2F|8|@]|9|@]|A|$T|U]]|$1|Z|3|10|5|6|7|2G|8|@]|9|@]|A|$]]|$1|11|3|12|5|S|7|2H|8|@]|9|@]|A|$T|U]]|$1|13|3|14|5|6|7|2I|8|@]|9|@]|A|$]]|$1|15|3|16|5|S|7|2J|8|@]|9|@]|A|$T|U]]|$1|17|3|18|5|6|7|2K|8|@]|9|@]|A|$]]|$1|19|3|1A|5|S|7|2L|8|@]|9|@]|A|$T|U]]|$1|1B|3|1C|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|S|7|2N|8|@]|9|@]|A|$T|U]]|$1|1F|3|1G|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|S|7|2P|8|@]|9|@]|A|$T|U]]|$1|1J|3|1K|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|2R|8|@]|9|@$1N|2S|1O|2T|1|2U]]|A|$]]|$1|1P|3|1Q|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|2W|8|@]|9|@$1N|2X|1O|2Y|1|2Z]]|A|$]]|$1|1T|3|1U|5|6|7|30|8|@]|9|@]|A|$]]|$1|1V|3|-4|5|6|7|31|8|@]|9|@]|A|$]]]|1W|$1X|$5|1Y|1Z|20|A|$21|22]]|23|$5|1Y|1Z|20|A|$21|1S]]]]

conv2d_transpose() simply transposes the weights and flips them by 180 degrees. Then it applies the standard conv2d(). "Transposes" practically means that it changes the order of the "columns" in the weights tensor. Please check the example below. 

Here there is an example that uses convolutions with stride=1 and padding='SAME'. It is a simple case but the same reasoning could be applied to the other cases.



Say we have:

<ul>
<li>Input: MNIST image of 28x28x1, shape = [28,28,1]</li>
<li>Convolutional layer: 32 filters of 7x7, weights shape = [7, 7, 1, 32], name = W_conv1</li>
</ul>

If we perform convolution of the input then the activations of the will have shape: [1,28,28,32].

<pre class="lang-py prettyprint-override"><code> activations = sess.run(h_conv1,feed_dict={x:np.reshape(image,[1,784])})
</code></pre>

Where:

<pre class="lang-py prettyprint-override"><code> W_conv1 = weight_variable([7, 7, 1, 32])
 b_conv1 = bias_variable([32])
 h_conv1 = conv2d(x, W_conv1, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
</code></pre>

To obtain the "deconvolution" or "transposed convolution" we can use conv2d_transpose() on the convolution activations in this way:

<pre class="lang-py prettyprint-override"><code> deconv = conv2d_transpose(activations,W_conv1, output_shape=[1,28,28,1],padding='SAME')
</code></pre>

OR using conv2d() we need to transpose and flip the weights:

<pre class="lang-py prettyprint-override"><code> transposed_weights = tf.transpose(W_conv1, perm=[0, 1, 3, 2])
</code></pre>

Here we change the order of the "colums" from [0,1,2,3] to [0,1,3,2].So from [7, 7, 1, 32] we will obtain a tensor with shape=[7,7,32,1]. Then we flip the weights:

<pre class="lang-py prettyprint-override"><code> for i in range(n_filters):
 # Flip the weights by 180 degrees
 transposed_and_flipped_weights[:,:,i,0] = sess.run(tf.reverse(transposed_weights[:,:,i,0], axis=[0, 1]))
</code></pre>

Then we can compute the convolution with conv2d() as: 

<pre class="lang-py prettyprint-override"><code> strides = [1,1,1,1]
 deconv = conv2d(activations,transposed_and_flipped_weights,strides=strides,padding='SAME')
</code></pre>

And we will obtain the same result as before. Also the very same result can be obtained with conv2d_backprop_input() using:

<pre class="lang-py prettyprint-override"><code> deconv = conv2d_backprop_input([1,28,28,1],W_conv1,activations, strides=strides, padding='SAME')
</code></pre>

The results are shown here:

<a href="https://i.stack.imgur.com/GJk7l.png" rel="noreferrer">Test of the conv2d(), conv2d_tranposed() and conv2d_backprop_input()</a>

We can see that the results are the same. To see it in a better way please check my code at:

<a href="https://github.com/simo23/conv2d_transpose" rel="noreferrer">https://github.com/simo23/conv2d_transpose</a>

Here I replicate the output of the conv2d_transpose() function using the standard conv2d().

blocks|key|2867686|text|conv2d_transpose的一个应用是扩展，这里有一个例子解释了它是如何工作的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2867687|a+=+np.array([[0,+0,+1.5],
++++++++++++++[0,+1,+0],
++++++++++++++[0,+0,+0]]).reshape(1,3,3,1)

filt+=+np.array([[1,+2],
+++++++++++++++++[3,+4.0]]).reshape(2,2,1,1)

b+=+tf.nn.conv2d_transpose(a,
+++++++++++++++++++++++++++filt,
+++++++++++++++++++++++++++output_shape=[1,6,6,1],
+++++++++++++++++++++++++++strides=[1,2,2,1],
+++++++++++++++++++++++++++padding='SAME')

print(tf.squeeze(b))

tf.Tensor(
[[0.++0.++0.++0.++1.5+3.+]
+[0.++0.++0.++0.++4.5+6.+]
+[0.++0.++1.++2.++0.++0.+]
+[0.++0.++3.++4.++0.++0.+]
+[0.++0.++0.++0.++0.++0.+]
+[0.++0.++0.++0.++0.++0.+]],+shape=(6,+6),+dtype=float64)|code-block|syntax|javascript|2867688|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One application for conv2d_transpose is upscaling, here is an example that explains how it works:

<pre><code>a = np.array([[0, 0, 1.5],
 [0, 1, 0],
 [0, 0, 0]]).reshape(1,3,3,1)

filt = np.array([[1, 2],
 [3, 4.0]]).reshape(2,2,1,1)

b = tf.nn.conv2d_transpose(a,
 filt,
 output_shape=[1,6,6,1],
 strides=[1,2,2,1],
 padding='SAME')

print(tf.squeeze(b))

tf.Tensor(
[[0. 0. 0. 0. 1.5 3. ]
 [0. 0. 0. 0. 4.5 6. ]
 [0. 0. 1. 2. 0. 0. ]
 [0. 0. 3. 4. 0. 0. ]
 [0. 0. 0. 0. 0. 0. ]
 [0. 0. 0. 0. 0. 0. ]], shape=(6, 6), dtype=float64)
</code></pre>

blocks|key|110724|text|这里简单解释一下在U-Net中使用的一种特殊情况--这是转置卷积的主要用例之一。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|110725|我们对下面这一层很感兴趣：|110726|Conv2DTranspose(64,+(2,+2),+strides=(2,+2))|code-block|syntax|javascript|110727|这一层到底是做什么的？我们能复制它的工作吗？|110728|这是的答案|BOLD|110729|110730|首先，本例中的默认填充是有效的。这意味着我们没有填充。|unordered-list-item|110731|输出的大小将是2倍:如果输入(m，n)，则输出将是(2m，2n)。为什么会这样呢？参见下一点。|110732|从输入中获取第一个元素，然后乘以具有形状(2,2)的过滤器权重。把它放到输出中。取下一个元素，相乘，并将输出放在第一个结果旁边，而不是重叠。为什么会这样呢？我们有步幅(2，2)。|110733|110734|下面是一个输入和输出示例(请参阅详细信息here和here)：|110735|In+[15]:+X.reshape(n,+m)
Out[15]:
array([[+0,++1,++2,++3,++4],
+++++++[+5,++6,++7,++8,++9],
+++++++[10,+11,+12,+13,+14]])
In+[16]:+y_resh
Out[16]:
array([[+0.,++0.,++1.,++1.,++2.,++2.,++3.,++3.,++4.,++4.],
+++++++[+0.,++0.,++1.,++1.,++2.,++2.,++3.,++3.,++4.,++4.],
+++++++[+5.,++5.,++6.,++6.,++7.,++7.,++8.,++8.,++9.,++9.],
+++++++[+5.,++5.,++6.,++6.,++7.,++7.,++8.,++8.,++9.,++9.],
+++++++[10.,+10.,+11.,+11.,+12.,+12.,+13.,+13.,+14.,+14.],
+++++++[10.,+10.,+11.,+11.,+12.,+12.,+13.,+13.,+14.,+14.]],+dtype=float32)|110736|这张来自斯坦福大学cs231n的幻灯片对我们的问题很有用：|110737|​|110738|📷|atomic|110739|110740|entityMap|0|LINK|mutability|MUTABLE|url|https://arxiv.org/abs/1505.04597|1|https://medium.com/@ilyarudyak/transposed-convolution-3a4725872a9a?source=friends_link&sk=ecd7a3f8568cb0ac327920c9676d788e|2|https://gist.github.com/ilyarudyak/8fdec3a6111226a5123fa0988dc36303|3|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/e5ce18360f2271c188db953962724e34.png|imageAlt^0|9|5|9|5|0|0|0|0|0|2|3|0|0|0|0|0|0|K|4|1|P|4|2|0|0|0|0|0|1|3|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|F|3|G|5|6|7|20|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|21|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|22|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|23|8|@$9|24|A|25|B|Q]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|27|8|@]|D|@]|E|$]]|$1|V|3|W|5|U|7|28|8|@]|D|@]|E|$]]|$1|X|3|Y|5|U|7|29|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|2B|8|@]|D|@$9|2C|A|2D|1|2E]|$9|2F|A|2G|1|2H]]|E|$]]|$1|12|3|13|5|J|7|2I|8|@]|D|@]|E|$K|L]]|$1|14|3|15|5|6|7|2J|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2K|8|@]|D|@]|E|$]]|$1|18|3|19|5|1A|7|2L|8|@]|D|@$9|2M|A|2N|1|2O]]|E|$]]|$1|1B|3|17|5|6|7|2P|8|@]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2Q|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J]]|1K|$5|1F|1G|1H|E|$1I|1L]]|1M|$5|1F|1G|1H|E|$1I|1N]]|1O|$5|1P|1G|1Q|E|$1R|1S|1T|-4]]]]

Here's a simple explanation of what is going on in a special case that is used in <a href="https://arxiv.org/abs/1505.04597" rel="nofollow noreferrer"><code>U-Net</code></a> - that's one of the main use cases for transposed convolution. 

We're interested in the following layer:

<pre><code>Conv2DTranspose(64, (2, 2), strides=(2, 2))
</code></pre>

What does this layer do exactly? Can we reproduce its work?

Here’s the answer:

<ul>
<li>First of all the default padding in this case is valid. This means we have no padding.</li>
<li>The size of the output will be 2 times bigger: if input (m, n), output will be (2m, 2n). Why is that? See the next point.</li>
<li>Take the first element from the input and multiply by the filter weights with shape (2,2). Put it into the output. Take the next element, multiply and put in the output next to the first result without overlapping. Why is that? We have strides (2, 2).</li>
</ul>

Here's an example input and output (see details <a href="https://medium.com/@ilyarudyak/transposed-convolution-3a4725872a9a?source=friends_link&amp;sk=ecd7a3f8568cb0ac327920c9676d788e" rel="nofollow noreferrer">here</a> and <a href="https://gist.github.com/ilyarudyak/8fdec3a6111226a5123fa0988dc36303" rel="nofollow noreferrer">here</a>):

<pre><code>In [15]: X.reshape(n, m)
Out[15]:
array([[ 0, 1, 2, 3, 4],
 [ 5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14]])
In [16]: y_resh
Out[16]:
array([[ 0., 0., 1., 1., 2., 2., 3., 3., 4., 4.],
 [ 0., 0., 1., 1., 2., 2., 3., 3., 4., 4.],
 [ 5., 5., 6., 6., 7., 7., 8., 8., 9., 9.],
 [ 5., 5., 6., 6., 7., 7., 8., 8., 9., 9.],
 [10., 10., 11., 11., 12., 12., 13., 13., 14., 14.],
 [10., 10., 11., 11., 12., 12., 13., 13., 14., 14.]], dtype=float32)
</code></pre>

This slide from Stanford's cs231n is useful for our question:

<a href="https://i.stack.imgur.com/T5EyN.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/T5EyN.png" alt="enter image description here"></a>

blocks|key|110660|text|任何线性变换，包括卷积，都可以表示为矩阵。转置卷积可以解释为在应用卷积矩阵之前对其进行转置。例如，考虑内核大小为3、步长为2的简单1D卷积。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|110661|​|110662|📷|atomic|offset|length|110663|110664|如果我们转置卷积矩阵并将其应用于3元素向量，则得到转置卷积运算|110665|110666|110667|110668|首先，这看起来不再像卷积运算了。但是，如果我们首先在y向量中插入一些零，我们可以将其等价地重写为|110669|110670|110671|110672|此示例演示了跨步卷积运算符的转置等效于通过插入零，然后添加一些额外的填充，并最终执行未跨步(即stride=1)卷积来对步长的一个因子进行上采样。|110673|对于高维转置卷积，在执行无步长卷积之前，对每个维度应用相同的上采样插入零点方法。|110674|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/b19c6e36ef5d9b30ef74dd2d56cdf792.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/858cf40d2348fcfec1a0261824ca6834.png|2|https://ask.qcloudimg.com/http-save/yehe-900000/a30c670a548a24c2838bd75b336ef32e.png^0|0|0|0|1|0|0|0|0|0|0|1|1|0|0|0|0|0|1|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@$G|1D|H|1E|1|1F]]|A|$]]|$1|I|3|C|5|6|7|1G|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1H|8|@]|9|@]|A|$]]|$1|L|3|C|5|6|7|1I|8|@]|9|@]|A|$]]|$1|M|3|E|5|F|7|1J|8|@]|9|@$G|1K|H|1L|1|1M]]|A|$]]|$1|N|3|C|5|6|7|1N|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|C|5|6|7|1P|8|@]|9|@]|A|$]]|$1|R|3|E|5|F|7|1Q|8|@]|9|@$G|1R|H|1S|1|1T]]|A|$]]|$1|S|3|C|5|6|7|1U|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1V|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1W|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|Y|$Z|$5|10|11|12|A|$13|14|15|-4]]|16|$5|10|11|12|A|$13|17|15|-4]]|18|$5|10|11|12|A|$13|19|15|-4]]]]

Any linear transform, including convolution, can be represented as a matrix. A transpose convolution can be interpreted as transposing the convolution matrix before applying it. For example, consider the simple 1D convolution with kernel size of 3 and stride of 2.
<a href="https://i.stack.imgur.com/T3RIq.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/T3RIq.png" alt="enter image description here" /></a>
If we transpose the convolution matrix and apply it to a 3 element vector we get the transpose convolution operation
<a href="https://i.stack.imgur.com/cr69k.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/cr69k.png" alt="enter image description here" /></a>
Now at first, this doesn't look like a convolution operation anymore. But if we insert some zeros into the y vector first we can rewrite this equivalently as
<a href="https://i.stack.imgur.com/ZAE5S.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/ZAE5S.png" alt="enter image description here" /></a>
This example demonstrates that the transpose of a strided convolution operator is equivalent to upsampling by a factor of the stride by inserting zeros, then adding some additional padding, and finally performing an unstrided (i.e. stride=1) convolution.
For higher dimensional transpose convolutions, the same upsampling-by-inserting-zeros method is applied to each dimensions before performing an unstrided convolution.

The documentation for the <code>conv2d_transpose()</code> operation does not clearly explain what it does:

<blockquote>
 The transpose of conv2d.
 
 This operation is sometimes called "deconvolution" after
 <a href="http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf" rel="noreferrer">Deconvolutional Networks</a>, but is actually the transpose (gradient) of
 conv2d rather than an actual deconvolution.
</blockquote>

I went through the paper that the doc points to, but it did not help.

What does this operation do and what are examples of why you would want to use it?

What does TensorFlow's `conv2d_transpose()` operation do?

conv2d_transpose()操作的文档没有清楚地解释它的作用： conv2d的转置。这种操作有时被称为之后的“反卷积”，但实际上是conv2d的转置(梯度)，而不是实际的反卷积。我看了医生所指的那篇论文，但没有帮助。这个操作是做什么的，你为什么想要使用它的例子有哪些？

问TensorFlow的`conv2d_transpose()`操作是做什么的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问TensorFlow的`conv2d_transpose()`操作是做什么的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问TensorFlow的`conv2d_transpose()`操作是做什么的？
EN