基于空洞卷积的自编码器：单层输入输出尺寸保持实现方法问询

Hey there! Let's work through how to implement a single layer (for your dilated convolution-based autoencoder) where the input and output dimensions match exactly. I'll break down both of your proposed options with clear explanations and code snippets.

方案1：tf.nn.atrous_conv2d + tf.nn.atrous_conv2d_transpose #

空洞卷积（atrous convolution） shines when you want to expand the receptive field without ramping up computation, and its transpose counterpart reverses this process. To keep input and output sizes identical, you need to align the dilation rate, kernel size, and padding perfectly.

Size Matching Logic #

For tf.nn.atrous_conv2d, given an input shape [batch, H, W, in_channels], the output size follows:

output_height = ceil((input_height - rate*(kernel_size-1) + 1) / stride)
output_width = ceil((input_width - rate*(kernel_size-1) + 1) / stride)

Since we want matching sizes and atrous convolution uses a default stride of 1, setting padding='SAME' simplifies this to:

output_height = input_height
output_width = input_width

For the transpose step, use the same rate and padding='SAME', and explicitly set the output_shape to match the original input.

Code Example #

import tensorflow as tf

# Sample input shape: [batch_size, 64, 64, 32]
input_tensor = tf.random.normal((8, 64, 64, 32))
kernel_size = 3
rate = 2  # Dilation rate
num_filters = 32  # Match input channels to keep output channels consistent

# Encoder: Atrous convolution
encoder_out = tf.nn.atrous_conv2d(
    input_tensor,
    filters=tf.Variable(tf.random.normal((kernel_size, kernel_size, 32, num_filters))),
    rate=rate,
    padding='SAME'
)
print(f"Encoder output shape: {encoder_out.shape}")  # Should be (8,64,64,32)

# Decoder: Transposed atrous convolution
decoder_out = tf.nn.atrous_conv2d_transpose(
    encoder_out,
    filters=tf.Variable(tf.random.normal((kernel_size, kernel_size, 32, num_filters))),
    output_shape=input_tensor.shape,
    rate=rate,
    padding='SAME'
)
print(f"Decoder output shape: {decoder_out.shape}")  # Matches input shape: (8,64,64,32)

方案2：tf.nn.conv2d + tf.nn.conv2d_transpose #

If you prefer standard convolution paired with transposed convolution, the key is adjusting strides, kernel size, and padding to cancel out any size changes. You can even simulate the receptive field of atrous convolution with larger kernels, though atrous convolution is more efficient.

Size Matching Basics #

• For tf.nn.conv2d, using padding='SAME' and strides=1 ensures the output size matches the input.
• For the transpose step, mirror those settings (strides=1, padding='SAME') and set output_shape to the original input shape to lock in matching dimensions.

If you want to include downsampling/upsampling (common in autoencoder middle layers), adjust strides to 2, then calculate padding and kernel size to reverse the size change.

Code Example (No Downsampling/Upsampling) #

import tensorflow as tf

input_tensor = tf.random.normal((8, 64, 64, 32))
kernel_size = 3
num_filters = 32

# Encoder: Standard convolution (no downsampling)
encoder_out = tf.nn.conv2d(
    input_tensor,
    filters=tf.Variable(tf.random.normal((kernel_size, kernel_size, 32, num_filters))),
    strides=1,
    padding='SAME'
)
print(f"Encoder output shape: {encoder_out.shape}")  # (8,64,64,32)

# Decoder: Transposed convolution (no upsampling)
decoder_out = tf.nn.conv2d_transpose(
    encoder_out,
    filters=tf.Variable(tf.random.normal((kernel_size, kernel_size, 32, num_filters))),
    output_shape=input_tensor.shape,
    strides=1,
    padding='SAME'
)
print(f"Decoder output shape: {decoder_out.shape}")  # (8,64,64,32)

Optional: With Downsampling/Upsampling #

If you want to shrink the feature map then restore it (e.g., 64x64 → 32x32 → 64x64):

# Downsampling convolution (strides=2)
encoder_down = tf.nn.conv2d(
    input_tensor,
    filters=tf.Variable(tf.random.normal((3,3,32,64))),
    strides=2,
    padding='SAME'
)
print(f"Downsampled shape: {encoder_down.shape}")  # (8,32,32,64)

# Upsampling transposed convolution (strides=2)
decoder_up = tf.nn.conv2d_transpose(
    encoder_down,
    filters=tf.Variable(tf.random.normal((3,3,32,64))),
    output_shape=input_tensor.shape,
    strides=2,
    padding='SAME'
)
print(f"Upsampled shape: {decoder_up.shape}")  # (8,64,64,32)

Key Notes #

• The atrous convolution approach is better when you need a large receptive field without extra compute. Always double-check that output_shape in the transpose step matches the original input exactly.
• Transposed convolution can cause checkerboard artifacts. If this happens, try adding a standard convolution after the transpose step for smoothing, or replace transposed convolution with tf.keras.layers.UpSampling2D paired with a convolution.
• For both schemes, make sure the number of input/output channels for each convolution kernel aligns (e.g., encoder output channels match decoder input channels).

内容的提问来源于stack exchange，提问作者moha