深度学习图像预处理：统一输入图像尺寸方案-优快云博客

在实际训练中，最常见也最简单的做法，就是在送入网络前把所有图片「变形」到同一个分辨率（比如 256×256 或 224×224），或者先裁剪／填充成同样大小。具体而言，可以分成以下几类方案：

一、图像分类

1. 直接缩放（Resize）

from torchvision import transforms

transform = transforms.Compose([
    transforms.Resize((256, 256)),   # 不保留长宽比，强行拉伸
    transforms.ToTensor(),
    transforms.Normalize(mean, std),
])

– 优点：实现最简单、速度最快。
– 缺点：会改变图片的长宽比，可能带来形变，对模型性能略有影响。

2. 缩放＋中心/随机裁剪（Resize + Crop）

transform = transforms.Compose([
    transforms.Resize(256),               # 保留长宽比，将短边缩放到256
    transforms.CenterCrop(224),           # 或 RandomCrop(224)
    transforms.ToTensor(),
    transforms.Normalize(mean, std),
])

– 流程：先把短边缩放到固定值（如 256 ），长边按比例变化，然后再在中心（或随机位置）裁剪出 224×224 的小块。
– 优点：保留了部分原始长宽比信息；RandomCrop还带来数据增强效果。
– 缺点：如果目标物体刚好出现在被裁掉的区域，会导致信息丢失。

3. 随机缩放＋裁剪（RandomResizedCrop）

transform = transforms.Compose([
    transforms.RandomResizedCrop(
        size=224,
        scale=(0.8, 1.0),      # 随机裁出面积占原图的80%～100%
        ratio=(3/4, 4/3)       # 随机裁出长宽比范围
    ),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean, std),
])

– 原理：先随机在原图上裁一个区域（面积和长宽比都随机），再缩放到固定大小。
– 优点：兼顾数据增强和固定输入大小，常用于 ImageNet 级别的训练。
– 缺点：对小物体定位不友好，如果裁得太小可能把主体裁走。

4. 填充（Padding）后缩放

from PIL import ImageOps

def pad_to_square(img, fill=0):
    w, h = img.size
    pad = (max(h-w,0)//2, max(w-h,0)//2,
           max(h-w,0)-max(h-w,0)//2, max(w-h,0)-max(h-w,0)//2)
    return ImageOps.expand(img, pad, fill)

transform = transforms.Compose([
    transforms.Lambda(pad_to_square),     # 填充为正方形
    transforms.Resize((256,256)),
    transforms.ToTensor(),
    transforms.Normalize(mean,std),
])

– 用途：先把图片填充成正方形（padding），再统一缩放；可保留原始物体比例，不会变形。
– 缺点：padding 部分引入了无效像素，浪费计算。

5. 自适应池化——支持任意输入尺寸

如果网络里最后用的是全局平均池化（nn.AdaptiveAvgPool2d((1,1))）而不是全连接层，那么理论上就可以接受任意分辨率的输入：

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=2):
        super().__init__()
        self.features = nn.Sequential(
            # … 多层卷积+BN+ReLU …
        )
        # 全局自适应池化，输出固定 (batch, C, 1, 1)
        self.global_pool = nn.AdaptiveAvgPool2d((1,1))
        self.classifier = nn.Linear(C, num_classes)
    def forward(self, x):
        x = self.features(x)
        x = self.global_pool(x)
        x = x.view(x.size(0), -1)
        return self.classifier(x)

– 优点：网络本身对输入尺寸不敏感，可以直接给不同分辨率图；实际上很多 modern 结构（如 ResNet）就是这样做的。
– 缺点：当输入分辨率变化很大时，提取到的特征尺度也会差异较大，训练和推理时的 batch 大小、显存使用也会不一致。

小结

最常用 的是先统一缩放（Resize）或缩放＋裁剪（Resize+Center/RandomCrop），这样既简单又有效。
进阶增强 可以用 RandomResizedCrop，同时带来固定输入大小和更多的数据增强。
如果要 严格保留长宽比，可以先 pad 到正方形，再 Resize。
若希望网络天然支持 任意尺寸，可使用全卷积＋自适应池化（AdaptiveAvgPool2d）结构。

根据需求（偏训练速度、保留比例还是增强多样性），可以选择或组合以上方案。

二、图像分割

在语义分割任务中，模型不仅要预测每个像素的类别，还要保证输入图像和标签（pixel-wise mask）在空间上严格对应。不同分辨率／长宽比的处理，跟分类任务类似，但要额外注意对 mask 做相同的变换。常见做法包括：

1. 固定大小的缩放＋裁剪

和分类里一样，最简单也最常用的方式是先把图像和对应的 mask 同时缩放（Resize）或缩放＋裁剪（CenterCrop/RandomCrop）到固定尺寸。

import torchvision.transforms.functional as F

def train_transform(image, mask):
    # 假设我们要最终得到 512×512 的输入
    # 1) 将短边 resize 到 512，保留长宽比
    image = F.resize(image, size=512, interpolation=Image.BILINEAR)
    mask  = F.resize(mask,  size=512, interpolation=Image.NEAREST)
    # 2) 从中心或随机裁剪出 512×512
    i, j, h, w = transforms.RandomCrop.get_params(image, (512, 512))
    image = F.crop(image, i, j, h, w)
    mask  = F.crop(mask,  i, j, h, w)
    # 3) 转 tensor + 标准化
    image = F.to_tensor(image)
    image = F.normalize(image, mean, std)
    mask  = torch.as_tensor(np.array(mask), dtype=torch.long)
    return image, mask

– 优点：实现简单、能批量训练。
– 缺点：裁剪可能丢掉部分对象；大目标／小目标比例失真。

2. 保持长宽比的填充（Pad）

如果想严格保留原图的长宽比，可以先对图像和掩码的长和宽中较大值缩放到目标size，然后再将长或宽中较小的一侧padding到一个目标的长宽size，下面给出一种「先缩放长/宽中较大的一边到目标尺寸，再对另一边做等比填充」的实现。这样在缩放阶段处理的像素更少，最后再补齐到固定大小，计算量更低。

from PIL import Image, ImageOps
import math

def resize_then_pad(image: Image.Image,
                    mask: Image.Image,
                    target_size: int = 512,
                    pad_value_img: int = 0,
                    pad_value_mask: int = 255):
    """
    1) 将 image 和 mask 的长宽中较大的一边缩放到 target_size，保持长宽比
    2) 对另一边做对称 pad，使得最终尺寸为 target_size×target_size
    
    mask 推荐用一个不会和类别冲突的填充值（如 255）表示 padding 区域，
    然后在 loss 里忽略这些像素。
    """
    w, h = image.size
    # 计算缩放比例
    scale = target_size / max(w, h)
    new_w, new_h = math.floor(w * scale), math.floor(h * scale)
    
    # 首先缩放
    image = image.resize((new_w, new_h), Image.BILINEAR)
    mask  = mask.resize((new_w, new_h),  Image.NEAREST)
    
    # 计算需要 pad 的像素数
    pad_w = target_size - new_w
    pad_h = target_size - new_h
    pad_left   = pad_w // 2
    pad_right  = pad_w - pad_left
    pad_top    = pad_h // 2
    pad_bottom = pad_h - pad_top
    
    # 对称 padding
    image = ImageOps.expand(
        image,
        border=(pad_left, pad_top, pad_right, pad_bottom),
        fill=pad_value_img
    )
    mask = ImageOps.expand(
        mask,
        border=(pad_left, pad_top, pad_right, pad_bottom),
        fill=pad_value_mask
    )
    
    return image, mask

用法示例

from torchvision import transforms
import torchvision.transforms.functional as F

def train_transform(img, msk):
    # 1. 先 resize + pad
    img, msk = resize_then_pad(img, msk, target_size=512)
    # 2. 随机水平翻转等增强
    if random.random() > 0.5:
        img = F.hflip(img)
        msk = F.hflip(msk)
    # 3. 转 Tensor，并标准化
    img = F.to_tensor(img)
    img = F.normalize(img, mean, std)
    msk = torch.as_tensor(np.array(msk), dtype=torch.long)
    return img, msk

优点：
- 缩放操作只针对最大边，像素量更少；
- 填充操作只在小边上，不会引入太大额外计算；
- 保持了原始长宽比，填充区域可在损失中忽略（填充值255）。
注意：pad_value_mask 选一个不会冲突的类别 id，并在 loss 里用 ignore_index=pad_value_mask。

– 原因：很多网络（如 U-Net、DeepLab 等）在下采样／上采样时要求输入尺寸能被 2^N 整除，否则拼接或上采样对齐会出错。
– 优点：无失真；只在边缘 padding。
– 缺点：padding 区域对模型无意义，可能需要在损失中忽略这些像素。

只需要在定义损失函数的时候，告诉它把填充值（pad_value_mask）对应的像素跳过即可。以下是一个最常见的做法，假设你把 padding 区域在 mask 中标记为 255，那么可以这样写：

import torch
import torch.nn as nn
import torch.nn.functional as F

# 假设 pad_value_mask = 255
pad_value_mask = 255
num_classes = 21  # 举例：语义分割一共 0～20 类

# 定义损失函数，ignore_index 会自动忽略 mask 中等于 255 的位置
criterion = nn.CrossEntropyLoss(ignore_index=pad_value_mask)

# 假设 model 输出 logits 大小是 [B, C, H, W]，mask 是 LongTensor [B, H, W]
logits = model(images)            # [B, C, H, W]
loss = criterion(logits, masks)   # masks 中值为 255 的像素不参与计算
loss.backward()

如果你更喜欢函数式的写法，也可以用 F.cross_entropy：

loss = F.cross_entropy(
    logits, 
    masks, 
    ignore_index=pad_value_mask
)

原理说明

CrossEntropyLoss（以及底层的 F.cross_entropy）接收一个 ignore_index 参数，所有目标标签等于这个值的像素都会被跳过，不计入损失，也不会参与梯度更新。
通常我们在 padding mask 时，选一个超出真实类别范围的整数（比如 255），以保证不会和真实标签冲突。

在 DataLoader 里，把 mask 转成 torch.long，padding 时用同样的填充值：

# pad_value_mask = 255
mask = ImageOps.expand(mask, border, fill=pad_value_mask)
mask = torch.as_tensor(np.array(mask), dtype=torch.long)

这样就能确保模型训练时「看不见」那些 padding 区域，也不会因为它们引入噪声。

3. 随机裁剪成小块（Patch-based Training）

如果原图非常大（如 2000×1500），直接缩放到 512×512 会失去细节；更好的做法是“打补丁”——随机从原图上裁多个小块（patch），训练时每个 patch 都是固定大小：

# 假设想要 512×512 的训练块
i, j, h, w = transforms.RandomCrop.get_params(image, (512,512))
patch_img  = F.crop(image, i, j, h, w)
patch_mask = F.crop(mask,  i, j, h, w)
# 然后继续 ToTensor、Normalize…

– 优点：保留高分辨率细节；增强了数据多样性。
– 缺点：训练时 batch 内 patch 来自不同原图位置，可能导致上下文不完整，需要更多样本。

4. 任意尺寸输入＋全卷积结构

许多经典分割网络（FCN、U-Net、DeepLab）都是全卷积（no fully-connected layers）的，最末端用 nn.AdaptiveAvgPool2d 或直接上采样到原始分辨率。这样在推理阶段就可以直接输入任意尺寸的图，网络会输出同样 spatial 大小的分割图：

class FCNSegmenter(nn.Module):
    def __init__(self, n_classes):
        super().__init__()
        self.backbone = torchvision.models.resnet34(pretrained=True)
        self.fc     = nn.Conv2d(512, n_classes, kernel_size=1)
    def forward(self, x):
        # x: B×3×H×W
        feat = self.backbone.conv1(x)
        # …一路下采样…
        out  = self.fc(feat)               # B×C×h×w
        seg  = F.interpolate(out, size=x.shape[2:], mode='bilinear', align_corners=False)
        return seg                        # B×C×H×W

– 优点：不需要预先 resize／crop；推理时更灵活。
– 缺点：训练时若 batch 中样本尺寸差异过大，显存占用和速度难以控制；通常仍在训练时对图像做上述固定大小处理。

5. Sliding-Window／Tiling 推理

对于超大输入（比如遥感影像或医学切片），即使网络结构支持任意大小，也会因为内存限制或上下文窗口有限而采用“滑窗”（sliding window）推理：

将大图按一定步长分块（patch），
对每块做分割预测，
将 patch 输出拼接回全图，并对重叠区域取平均或最大概率。

常见工具：

MMsegmentation 中的 inference_sliding
TorchVision 中的 SlidingWindowInferer

小结建议

训练：绝大多数场景还是先把图和 mask 同步变换到固定大小（如 512×512），或 patch-based 随机裁剪。
推理：若输入大小可变且不大，用全卷积网络直接预测；若图像过大，则用滑窗策略。
注意点：所有几何变换（resize、crop、flip、pad）都要对 image 和 mask 一致地做，而且 mask 要用最近邻插值（interpolation=Image.NEAREST）以保证类别标签不被混叠。

这样，既能保证批量训练的稳定性和效率，也能在推理时灵活应对各种分辨率和长宽比。