如何在Keras中实现支持任意尺寸输入的全卷积网络（FCN）？

Let's break this down step by step—your confusion makes total sense, since the jump from fixed-size CNNs to fully convolutional networks (FCNs) can feel counterintuitive at first.

First, Why Your Current Code Doesn't Support Arbitrary Input Sizes #

The issue with your code is the combination of Flatten() and Dense(10*10) layers. These force your model to produce a fixed-size output (10x10) regardless of the input dimensions. FCNs rely entirely on convolutional operations (no fully connected/Dense layers) to maintain spatial relationships and support variable input sizes.

From the FCN paper: "Existing networks can be converted into fully convolutional networks that take input of any size and produce correspondingly-sized output with efficient inference and learning."
The key here is avoiding layers that flatten spatial dimensions into fixed-length vectors.

Building a Simple FCN in Keras #

Here's a minimal example of an FCN that supports arbitrary input sizes (for single-channel images, matching your initial code). This model will output a segmentation mask with dimensions proportional to the input, then upsample it to match the input size:

from keras import models
from keras import layers

def build_simple_fcn(input_channels=1, num_classes=1):
    # Input layer accepts arbitrary height/width
    inputs = layers.Input(shape=(None, None, input_channels))
    
    # Encoder: Conv + Pooling layers (extract features)
    x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
    x = layers.MaxPooling2D((2, 2))(x)
    
    x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
    x = layers.MaxPooling2D((2, 2))(x)
    
    x = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)
    
    # Decoder: Upsample to match input size
    # Use Conv2DTranspose for learnable upsampling (instead of bilinear interpolation)
    x = layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(x)
    x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
    
    x = layers.Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(x)
    x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
    
    # Final convolution to produce segmentation mask
    outputs = layers.Conv2D(num_classes, (1, 1), activation='sigmoid' if num_classes == 1 else 'softmax')(x)
    
    model = models.Model(inputs=inputs, outputs=outputs)
    return model

# Initialize the model
fcn_model = build_simple_fcn(input_channels=1, num_classes=1)
fcn_model.summary()

Key Details About This FCN: #

• Arbitrary Input Support: The input shape uses (None, None, 1), so you can pass images of any height/width (as long as they're compatible with the pooling/upsampling strides—e.g., input dimensions should be divisible by 4 here, since we do two 2x max pools and two 2x upsamplings).
• No Fully Connected Layers: Every layer is convolutional (including Conv2DTranspose for upsampling), so spatial information is preserved throughout the model.
• Padding='same': Ensures that each convolution doesn't shrink the feature map dimensions (except for pooling layers), making it easier to track output sizes relative to inputs.

Why Some FCN Implementations Specify Fixed Input Sizes #

You might see implementations like FCN(input_shape=(500, 500, 3), ...) for a few reasons:

1. Pre-trained Weights: Models like FCN-VGG16 use pre-trained VGG16 weights, which were originally trained on fixed-size images (224x224). While Keras supports modifying the input shape to (None, None, 3), loading pre-trained weights can sometimes require matching the original input dimensions (though you can work around this by adjusting the input layer and reloading weights selectively).
2. Training Convenience: Fixed input sizes make it easier to batch images during training (since all images in a batch need the same dimensions). You can still use arbitrary sizes during inference by resizing images or passing them one at a time.

To adapt a pre-trained FCN to support arbitrary sizes, you can modify the input layer to (None, None, 3) before loading weights—just make sure the convolutional layers are compatible with variable dimensions (which they are, as long as you avoid fixed-size layers like Flatten() or Dense()).

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