卷积神经网络提取图像微小特征层的卷积核尺寸设计-编程实验室

卷积神经网络提取图像微小特征层的卷积核尺寸设计

卷积神经网络（Convolutional Neural Network, CNN）是深度学习领域最具影响力的架构之一，在图像识别、目标检测、语义分割等计算机视觉任务中取得了卓越成就。CNN的核心在于通过卷积操作提取图像中的层次化特征，从边缘、纹理等低级特征到形状、物体部件等高级语义特征，逐步构建对图像内容的深层理解。

在实际工程应用中，卷积核尺寸的设计直接决定了模型能否有效提取图像中的微小特征。卷积核过大可能丢失细节信息，过小则感受野受限，难以捕捉上下文语义。本文将深入剖析CNN的工作原理，系统探讨卷积核尺寸设计对微小特征提取的影响，并提供可落地的设计指南。

一、卷积神经网络基本原理

CNN的结构设计灵感来源于生物视觉皮层的工作机制。Hubel和Wiesel在20世纪60年代对猫视觉皮层的研究发现，视觉神经元具有局部感受野，只对特定区域内的特定刺激做出响应。CNN通过局部连接、权值共享和池化三种核心机制，模拟了这一生物视觉处理过程。

CNN的核心组件包括卷积层、激活函数、池化层和全连接层。卷积层负责特征提取，通过可学习的卷积核在输入图像上滑动，计算局部区域的加权和。激活函数引入非线性变换，使网络能够学习复杂的特征表示。池化层降维特征图，保留主要特征的同时减少计算量。全连接层将学习到的高维特征映射到最终的分类或回归输出。

二、卷积操作的数学原理

卷积操作在数学上可以理解为输入图像与卷积核之间的点积运算。对于一个输入特征图I和一个卷积核K，卷积操作可表示为：

O(i,j) = ∑(m)∑(n) I(i+m, j+n) * K(m, n)

其中O是输出特征图，i和j是输出位置坐标，m和n是卷积核内的偏移量。输出特征图的尺寸由输入尺寸、卷积核尺寸、填充和步长共同决定：

W_out = (W_in - K + 2P) / S + 1 H_out = (H_in - K + 2P) / S + 1

其中W_in和H_in是输入尺寸，K是卷积核尺寸，P是填充大小，S是步长。

import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt def conv2d_custom(input_tensor, kernel, padding=0, stride=1): batch_size, in_channels, in_height, in_width = input_tensor.shape out_channels, _, k_height, k_width = kernel.shape out_height = (in_height + 2 * padding - k_height) // stride + 1 out_width = (in_width + 2 * padding - k_width) // stride + 1 if padding > 0: input_padded = F.pad(input_tensor, (padding, padding, padding, padding), mode='constant', value=0) else: input_padded = input_tensor output = torch.zeros(batch_size, out_channels, out_height, out_width) for b in range(batch_size): for c_out in range(out_channels): for h in range(out_height): for w in range(out_width): h_start = h * stride w_start = w * stride receptive_field = input_padded[b, :, h_start:h_start+k_height, w_start:w_start+k_width] output[b, c_out, h, w] = torch.sum(receptive_field * kernel[c_out]) return output input_tensor = torch.randn(1, 1, 28, 28) kernel_3x3 = torch.randn(1, 1, 3, 3) kernel_5x5 = torch.randn(1, 1, 5, 5) kernel_7x7 = torch.randn(1, 1, 7, 7) out_3x3 = conv2d_custom(input_tensor, kernel_3x3, padding=1, stride=1) out_5x5 = conv2d_custom(input_tensor, kernel_5x5, padding=2, stride=1) out_7x7 = conv2d_custom(input_tensor, kernel_7x7, padding=3, stride=1) print(f"输入特征图尺寸: {input_tensor.shape}") print(f"3x3卷积输出尺寸: {out_3x3.shape}") print(f"5x5卷积输出尺寸: {out_5x5.shape}") print(f"7x7卷积输出尺寸: {out_7x7.shape}") print(f"3x3卷积参数量: {kernel_3x3.numel()}") print(f"5x5卷积参数量: {kernel_5x5.numel()}") print(f"7x7卷积参数量: {kernel_7x7.numel()}")

三、卷积核尺寸设计的核心原则

卷积核尺寸的选择需要在感受野大小、参数量和特征提取精度之间取得平衡。以下是卷积核设计的核心原则：

3.1 小卷积核的堆叠优势

现代CNN架构普遍采用小卷积核（主要是3x3）堆叠的方式来替代大卷积核。使用两个连续的3x3卷积层可以获得5x5的有效感受野，而参数量仅为大卷积核的2×9/25=72%。三个3x3卷积层堆叠可以获得7x7的有效感受野，参数量为3×9/49=55%。

小卷积核堆叠的另一个优势是引入了更多的非线性变换层，增强了网络的表达能力。每个卷积层之后通常跟随一个非线性激活函数，更多的层数意味着更强的非线性拟合能力。

class SmallKernelStack(nn.Module): def __init__(self, in_channels, out_channels): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(out_channels) self.conv3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1) self.bn3 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): x = self.relu(self.bn1(self.conv1(x))) x = self.relu(self.bn2(self.conv2(x))) x = self.relu(self.bn3(self.conv3(x))) return x class LargeKernelLayer(nn.Module): def __init__(self, in_channels, out_channels): super().__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=7, padding=3) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): return self.relu(self.bn(self.conv(x))) def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) small_stack = SmallKernelStack(64, 128) large_layer = LargeKernelLayer(64, 128) print(f"3层3x3卷积参数量: {count_parameters(small_stack):,}") print(f"1层7x7卷积参数量: {count_parameters(large_layer):,}") print(f"参数节省比例: {(1 - count_parameters(small_stack)/count_parameters(large_layer)):.2%}")

3.2 膨胀卷积与多尺度特征提取

对于微小特征的提取，标准卷积核可能无法有效捕获跨尺度的信息。膨胀卷积（Dilated Convolution）通过在卷积核元素之间插入空洞来扩大感受野，特别适合需要同时关注细节和上下文的场景。

class DilatedConvBlock(nn.Module): def __init__(self, in_channels, out_channels): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, dilation=1) self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=2, dilation=2) self.conv3 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=4, dilation=4) self.conv4 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=8, dilation=8) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): f1 = self.relu(self.bn(self.conv1(x))) f2 = self.relu(self.bn(self.conv2(x))) f3 = self.relu(self.bn(self.conv3(x))) f4 = self.relu(self.bn(self.conv4(x))) return torch.cat([f1, f2, f3, f4], dim=1) dilated_block = DilatedConvBlock(64, 64) test_input = torch.randn(2, 64, 32, 32) output = dilated_block(test_input) print(f"膨胀卷积块输入: {test_input.shape}") print(f"膨胀卷积块输出: {output.shape}")

3.3 深度可分离卷积的效率优化

在移动端和实时应用中，深度可分离卷积是平衡效率与精度的关键设计。它将标准卷积分解为深度卷积和逐点卷积两个步骤，参数量和计算量大幅降低。

class DepthwiseSeparableConv(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=3): super().__init__() self.depthwise = nn.Conv2d( in_channels, in_channels, kernel_size=kernel_size, padding=kernel_size//2, groups=in_channels ) self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1) self.bn1 = nn.BatchNorm2d(in_channels) self.bn2 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): x = self.relu(self.bn1(self.depthwise(x))) x = self.relu(self.bn2(self.pointwise(x))) return x class StandardConv(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=3): super().__init__() self.conv = nn.Conv2d( in_channels, out_channels, kernel_size=kernel_size, padding=kernel_size//2 ) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): return self.relu(self.bn(self.conv(x))) ds_conv = DepthwiseSeparableConv(128, 256, kernel_size=3) std_conv = StandardConv(128, 256, kernel_size=3) print(f"标准卷积参数量: {count_parameters(std_conv):,}") print(f"深度可分离卷积参数量: {count_parameters(ds_conv):,}") print(f"参数压缩比: {count_parameters(ds_conv)/count_parameters(std_conv):.2%}")

四、微小特征提取的卷积核设计策略

图像中的微小特征通常指尺寸较小、对比度较低或纹理精细的图像模式，如医学图像中的微小病灶、工业检测中的细微裂纹、遥感图像中的小目标等。有效提取这类特征对卷积核设计提出了特殊要求。

4.1 浅层网络的小卷积核设计

CNN的浅层主要负责提取边缘、角点、颜色斑块等低级视觉特征。对于微小特征，浅层卷积核的设计尤为关键。过大的卷积核会模糊细节，过小的卷积核则无法建立足够的空间上下文。

针对微小特征提取，推荐在第一个卷积层使用3x3或5x5的卷积核，配合适当的步长和填充策略。如果需要捕获更精细的纹理信息，可以引入多分支结构，同时使用不同尺寸的卷积核提取多尺度特征。

class MultiScaleFeatureExtractor(nn.Module): def __init__(self, in_channels, out_channels): super().__init__() self.branch_1x1 = nn.Conv2d(in_channels, out_channels//4, kernel_size=1) self.branch_3x3 = nn.Conv2d(in_channels, out_channels//4, kernel_size=3, padding=1) self.branch_5x5 = nn.Conv2d(in_channels, out_channels//4, kernel_size=5, padding=2) self.branch_7x7 = nn.Conv2d(in_channels, out_channels//4, kernel_size=7, padding=3) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): f1 = self.branch_1x1(x) f2 = self.branch_3x3(x) f3 = self.branch_5x5(x) f4 = self.branch_7x7(x) concat = torch.cat([f1, f2, f3, f4], dim=1) return self.relu(self.bn(concat)) ms_extractor = MultiScaleFeatureExtractor(3, 128) test_image = torch.randn(4, 3, 224, 224) ms_features = ms_extractor(test_image) print(f"多尺度特征提取器输入: {test_image.shape}") print(f"多尺度特征提取器输出: {ms_features.shape}") print(f"各分支输出通道数: 1x1={128//4}, 3x3={128//4}, 5x5={128//4}, 7x7={128//4}")

4.2 注意力机制引导的卷积核选择

在微小特征提取中，并非所有区域都具有相同的特征提取需求。注意力机制可以帮助网络动态调整卷积核的权重分配，使网络更关注包含微小特征的区域。

通道注意力机制通过学习各通道的重要性权重，增强包含关键微小特征的通道。空间注意力机制则关注特征图中的关键空间位置。

class ChannelAttention(nn.Module): def __init__(self, channels, reduction=16): super().__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.max_pool = nn.AdaptiveMaxPool2d(1) self.fc = nn.Sequential( nn.Linear(channels, channels // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channels // reduction, channels, bias=False) ) self.sigmoid = nn.Sigmoid() def forward(self, x): b, c, _, _ = x.size() avg_out = self.fc(self.avg_pool(x).view(b, c)) max_out = self.fc(self.max_pool(x).view(b, c)) attention = self.sigmoid(avg_out + max_out).view(b, c, 1, 1) return x * attention class SpatialAttention(nn.Module): def __init__(self, kernel_size=7): super().__init__() self.conv = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=kernel_size//2) self.sigmoid = nn.Sigmoid() def forward(self, x): avg_out = torch.mean(x, dim=1, keepdim=True) max_out, _ = torch.max(x, dim=1, keepdim=True) concat = torch.cat([avg_out, max_out], dim=1) attention = self.sigmoid(self.conv(concat)) return x * attention class AttentionGuidedConv(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=3): super().__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, padding=kernel_size//2) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.channel_attn = ChannelAttention(out_channels) self.spatial_attn = SpatialAttention() def forward(self, x): x = self.relu(self.bn(self.conv(x))) x = self.channel_attn(x) x = self.spatial_attn(x) return x attn_conv = AttentionGuidedConv(64, 128) attn_input = torch.randn(4, 64, 56, 56) attn_output = attn_conv(attn_input) print(f"注意力引导卷积输入: {attn_input.shape}") print(f"注意力引导卷积输出: {attn_output.shape}")

4.3 全卷积网络与空洞空间金字塔池化

在需要同时提取多尺度微小特征的场景中，空洞空间金字塔池化（Atrous Spatial Pyramid Pooling, ASPP）是一种高效的解决方案。ASPP使用不同膨胀率的空洞卷积并行提取特征，捕获丰富的多尺度上下文信息。

class ASPP(nn.Module): def __init__(self, in_channels, out_channels, atrous_rates=[6, 12, 18]): super().__init__() self.conv1x1 = nn.Conv2d(in_channels, out_channels, 1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv3x3_d1 = nn.Conv2d(in_channels, out_channels, 3, padding=atrous_rates[0], dilation=atrous_rates[0], bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.conv3x3_d2 = nn.Conv2d(in_channels, out_channels, 3, padding=atrous_rates[1], dilation=atrous_rates[1], bias=False) self.bn3 = nn.BatchNorm2d(out_channels) self.conv3x3_d3 = nn.Conv2d(in_channels, out_channels, 3, padding=atrous_rates[2], dilation=atrous_rates[2], bias=False) self.bn4 = nn.BatchNorm2d(out_channels) self.global_avg_pool = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Conv2d(in_channels, out_channels, 1, bias=False), nn.BatchNorm2d(out_channels) ) self.conv_out = nn.Conv2d(out_channels * 5, out_channels, 1, bias=False) self.bn_out = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): f1 = self.relu(self.bn1(self.conv1x1(x))) f2 = self.relu(self.bn2(self.conv3x3_d1(x))) f3 = self.relu(self.bn3(self.conv3x3_d2(x))) f4 = self.relu(self.bn4(self.conv3x3_d3(x))) f5 = F.interpolate(self.global_avg_pool(x), size=x.shape[2:], mode='bilinear', align_corners=False) concat = torch.cat([f1, f2, f3, f4, f5], dim=1) return self.relu(self.bn_out(self.conv_out(concat))) aspp = ASPP(512, 256) aspp_input = torch.randn(2, 512, 28, 28) aspp_output = aspp(aspp_input) print(f"ASPP模块输入: {aspp_input.shape}") print(f"ASPP模块输出: {aspp_output.shape}")

4.4 残差连接与梯度传播优化

在深层CNN中，梯度消失问题会严重影响微小特征的学习效果。残差连接通过跳跃连接机制，使梯度可以直接传播到浅层网络，确保浅层的微小特征提取也能得到充分优化。

class ResidualBlock(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=3, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=kernel_size//2, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size, padding=kernel_size//2, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, 1, stride=stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): residual = self.shortcut(x) out = self.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += residual out = self.relu(out) return out class TinyFeatureResNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer(64, 64, 2, stride=1) self.layer2 = self._make_layer(64, 128, 2, stride=2) self.layer3 = self._make_layer(128, 256, 2, stride=2) self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(256, num_classes) def _make_layer(self, in_channels, out_channels, blocks, stride): layers = [] layers.append(ResidualBlock(in_channels, out_channels, stride=stride)) for _ in range(1, blocks): layers.append(ResidualBlock(out_channels, out_channels)) return nn.Sequential(*layers) def forward(self, x): x = self.relu(self.bn1(self.conv1(x))) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.avg_pool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x resnet = TinyFeatureResNet(num_classes=10) dummy_input = torch.randn(4, 3, 32, 32) resnet_output = resnet(dummy_input) print(f"残差网络输入: {dummy_input.shape}") print(f"残差网络输出: {resnet_output.shape}") print(f"残差网络总参数量: {count_parameters(resnet):,}")

五、不同卷积核尺寸的对比实验

为了系统性评估不同卷积核尺寸对微小特征提取效果的影响，我们设计了一个对比实验。使用CIFAR-10数据集作为基准，对比不同卷积核配置下的分类准确率。

class KernelSizeBenchmark: def __init__(self, input_channels=3, num_classes=10): self.input_channels = input_channels self.num_classes = num_classes def build_model(self, kernel_size, use_batch_norm=True): if kernel_size == 1: conv_layers = [ nn.Conv2d(self.input_channels, 64, 1), nn.ReLU(inplace=True), nn.Conv2d(64, 128, 1), nn.ReLU(inplace=True), nn.AdaptiveAvgPool2d(1) ] elif kernel_size == 3: conv_layers = [ nn.Conv2d(self.input_channels, 64, 3, padding=1), nn.BatchNorm2d(64) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.Conv2d(64, 128, 3, padding=1), nn.BatchNorm2d(128) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.Conv2d(128, 256, 3, padding=1), nn.BatchNorm2d(256) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.AdaptiveAvgPool2d(1) ] elif kernel_size == 5: conv_layers = [ nn.Conv2d(self.input_channels, 64, 5, padding=2), nn.BatchNorm2d(64) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.Conv2d(64, 128, 5, padding=2), nn.BatchNorm2d(128) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.AdaptiveAvgPool2d(1) ] elif kernel_size == 7: conv_layers = [ nn.Conv2d(self.input_channels, 64, 7, padding=3), nn.BatchNorm2d(64) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.Conv2d(64, 128, 7, padding=3), nn.BatchNorm2d(128) if use_batch_norm else nn.Identity(), nn.ReLU(inplace=True), nn.AdaptiveAvgPool2d(1) ] else: raise ValueError(f"Unsupported kernel size: {kernel_size}") model = nn.Sequential( *conv_layers, nn.Flatten(), nn.Linear(256 if kernel_size == 3 else 128, self.num_classes) ) return model benchmark = KernelSizeBenchmark() for ks in [1, 3, 5, 7]: model = benchmark.build_model(ks) params = count_parameters(model) print(f"卷积核尺寸 {ks}x{ks}: 参数量 {params:,}")

六、训练策略与学习率调度

微小特征提取模型的训练需要特别注意学习率的设置和训练策略的选择。过大的学习率可能导致模型无法收敛到精细的特征空间，过小的学习率则导致训练效率低下。

def train_epoch(model, dataloader, optimizer, criterion, device): model.train() running_loss = 0.0 correct = 0 total = 0 for inputs, targets in dataloader: inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() running_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() epoch_loss = running_loss / len(dataloader) epoch_acc = 100. * correct / total return epoch_loss, epoch_acc def evaluate(model, dataloader, criterion, device): model.eval() running_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for inputs, targets in dataloader: inputs, targets = inputs.to(device), targets.to(device) outputs = model(inputs) loss = criterion(outputs, targets) running_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() epoch_loss = running_loss / len(dataloader) epoch_acc = 100. * correct / total return epoch_loss, epoch_acc def simulate_training(model, epochs=20, lr=0.01): optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) criterion = nn.CrossEntropyLoss() device = torch.device('cpu') train_losses = [] test_losses = [] train_accs = [] test_accs = [] for epoch in range(1, epochs + 1): train_loss = 0.5 * (0.99 ** epoch) + 0.1 * np.random.random() train_acc = min(95, 40 + 3 * epoch + np.random.random() * 2) test_loss = 0.6 * (0.98 ** epoch) + 0.15 * np.random.random() test_acc = min(90, 30 + 2.5 * epoch + np.random.random() * 2) train_losses.append(train_loss) test_losses.append(test_loss) train_accs.append(train_acc) test_accs.append(test_acc) scheduler.step() if epoch % 5 == 0 or epoch == 1: print(f"Epoch {epoch:2d}/{epochs} | Train Loss: {train_loss:.4f} | " f"Train Acc: {train_acc:.2f}% | Test Acc: {test_acc:.2f}%") return train_losses, test_losses, train_accs, test_accs model_3x3 = benchmark.build_model(3) print("\n=== 训练模拟(3x3卷积核) ===") train_losses, test_losses, train_accs, test_accs = simulate_training(model_3x3, epochs=20, lr=0.01)

七、感受野计算与理论分析

感受野是CNN中一个重要的理论概念，它描述了特征图中每个像素对应到输入图像上的区域大小。理解感受野对于卷积核尺寸设计至关重要。

理论感受野的计算公式为：

RF(l) = RF(l-1) + (K(l) - 1) * ∏(i=1 to l-1) S(i)

其中RF(l)是第l层的感受野大小，K(l)是第l层的卷积核尺寸，S(i)是第i层的步长。

def compute_receptive_field(layers): rf = 1 stride_product = 1 rf_history = [rf] for k, s in layers: rf = rf + (k - 1) * stride_product stride_product *= s rf_history.append(rf) return rf,

卷积神经网络提取图像微小特征层的卷积核尺寸设计