#卷积核、步长与池化：感受野、参数共享与特征提取完整指南

"""
卷积核数学表示：

输入特征图 X ∈ R^(H×W×C)
卷积核 K ∈ R^(k×k×C×F) 
输出特征图 Y ∈ R^(H'×W'×F)

其中：
- k: 卷积核尺寸 (k×k)
- C: 输入通道数
- F: 输出通道数
- H,W: 输入高度和宽度
- H',W': 输出高度和宽度
"""

import torch
import torch.nn as nn
import numpy as np

def analyze_kernel_sizes():
    """
    分析不同卷积核大小的特点
    """
    kernel_sizes = [1, 3, 5, 7, 9, 11]
    
    print("卷积核大小分析:")
    print("-" * 60)
    for ks in kernel_sizes:
        # 参数数量计算 (假设输入通道=3, 输出通道=64)
        params = ks * ks * 3 * 64 + 64  # weights + biases
        print(f"{ks}×{ks}卷积核: 参数数量 {params:,}")
    
    print("\n各尺寸卷积核的典型用途:")
    print("1×1: 通道融合、降维、升维")
    print("3×3: 通用卷积，平衡感受野和计算量")
    print("5×5: 较大感受野，替代大卷积核")
    print("7×7及以上: 初始卷积，减少参数")

analyze_kernel_sizes()

def kernel_size_applications():
    """
    不同卷积核尺寸的应用场景
    """
    """
    1×1卷积核（Point-wise Convolution）：
    - 用途：通道融合、降维、升维
    - 优势：计算量小，不改变空间尺寸
    - 应用：Inception模块、ResNet瓶颈层
    
    3×3卷积核：
    - 用途：通用卷积操作
    - 优势：感受野适中，参数少
    - 应用：几乎所有CNN架构的基础卷积
    
    5×5卷积核：
    - 用途：较大感受野
    - 优势：可替代7×7卷积核
    - 应用：早期CNN架构、特定任务
    
    7×7卷积核：
    - 用途：初始卷积（如ResNet）
    - 劣势：参数多，计算量大
    - 应用：图像分类网络的初始层
    """
    
    import torch
    import torch.nn as nn
    
    # 实际应用示例
    class KernelSizeComparison(nn.Module):
        def __init__(self):
            super().__init__()
            
            # 1×1卷积：通道变换
            self.conv_1x1 = nn.Conv2d(64, 32, kernel_size=1)
            
            # 3×3卷积：标准卷积
            self.conv_3x3 = nn.Conv2d(64, 32, kernel_size=3, padding=1)
            
            # 5×5卷积：较大感受野
            self.conv_5x5 = nn.Conv2d(64, 32, kernel_size=5, padding=2)
            
            # 用两个3×3替代5×5
            self.conv_3x3_twice = nn.Sequential(
                nn.Conv2d(64, 32, kernel_size=3, padding=1),
                nn.Conv2d(32, 32, kernel_size=3, padding=1)
            )
        
        def forward(self, x):
            return {
                '1x1': self.conv_1x1(x),
                '3x3': self.conv_3x3(x),
                '5x5': self.conv_5x5(x),
                '3x3_twice': self.conv_3x3_twice(x)
            }
    
    # 参数对比
    model = KernelSizeComparison()
    
    def count_params(module):
        return sum(p.numel() for p in module.parameters())
    
    print("参数数量对比:")
    print(f"1×1卷积: {count_params(model.conv_1x1):,}")
    print(f"3×3卷积: {count_params(model.conv_3x3):,}")
    print(f"5×5卷积: {count_params(model.conv_5x5):,}")
    print(f"两个3×3: {count_params(model.conv_3x3_twice):,}")

kernel_size_applications()

def depthwise_1x1_convolutions():
    """
    1×1卷积的高级应用
    """
    """
    1×1卷积的三个主要作用：
    
    1. 通道融合（Channel Mixing）：
       - 在不同通道间混合信息
       - 增加跨通道交互
    
    2. 维度变换（Dimensionality Reduction）：
       - 减少通道数，降低计算复杂度
       - 常用于瓶颈层
    
    3. 非线性增强（Non-linearity Injection）：
       - 在网络中插入非线性激活
       - 增加网络表达能力
    """
    
    import torch
    import torch.nn as nn
    
    class BottleneckLayer(nn.Module):
        """
        典型的瓶颈层结构（ResNet风格）
        """
        def __init__(self, in_channels, bottleneck_channels, out_channels):
            super().__init__()
            self.conv1 = nn.Conv2d(in_channels, bottleneck_channels, kernel_size=1)
            self.bn1 = nn.BatchNorm2d(bottleneck_channels)
            self.conv2 = nn.Conv2d(bottleneck_channels, bottleneck_channels, kernel_size=3, padding=1)
            self.bn2 = nn.BatchNorm2d(bottleneck_channels)
            self.conv3 = nn.Conv2d(bottleneck_channels, out_channels, kernel_size=1)
            self.bn3 = nn.BatchNorm2d(out_channels)
            self.relu = nn.ReLU(inplace=True)
        
        def forward(self, x):
            identity = x
            
            out = self.relu(self.bn1(self.conv1(x)))
            out = self.relu(self.bn2(self.conv2(out)))
            out = self.bn3(self.conv3(out))
            
            return self.relu(out + identity)
    
    # Inception模块中的1×1卷积应用
    class InceptionBlock(nn.Module):
        """
        Inception模块：并行使用不同尺寸卷积核
        """
        def __init__(self, in_channels, out_channels_1x1, out_channels_3x3_reduce, 
                     out_channels_3x3, out_channels_5x5_reduce, out_channels_5x5):
            super().__init__()
            
            # 1×1分支
            self.branch1 = nn.Sequential(
                nn.Conv2d(in_channels, out_channels_1x1, kernel_size=1),
                nn.ReLU(inplace=True)
            )
            
            # 3×3分支（先用1×1降维）
            self.branch2 = nn.Sequential(
                nn.Conv2d(in_channels, out_channels_3x3_reduce, kernel_size=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(out_channels_3x3_reduce, out_channels_3x3, kernel_size=3, padding=1),
                nn.ReLU(inplace=True)
            )
            
            # 5×5分支（先用1×1降维）
            self.branch3 = nn.Sequential(
                nn.Conv2d(in_channels, out_channels_5x5_reduce, kernel_size=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(out_channels_5x5_reduce, out_channels_5x5, kernel_size=5, padding=2),
                nn.ReLU(inplace=True)
            )
            
            # 池化分支
            self.branch4 = nn.Sequential(
                nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
                nn.Conv2d(in_channels, out_channels_5x5, kernel_size=1),
                nn.ReLU(inplace=True)
            )
        
        def forward(self, x):
            out1 = self.branch1(x)
            out2 = self.branch2(x)
            out3 = self.branch3(x)
            out4 = self.branch4(x)
            
            return torch.cat([out1, out2, out3, out4], dim=1)

def practical_kernel_size_examples():
    """
    实际应用中的卷积核大小选择
    """
    import torch
    import torch.nn as nn
    
    # 不同任务的卷积核选择策略
    class TaskSpecificConvs(nn.Module):
        def __init__(self):
            super().__init__()
            
            # 分类任务：从大到小的卷积核
            self.classification_branch = nn.Sequential(
                nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),  # 大卷积核用于初始特征提取
                nn.ReLU(inplace=True),
                nn.Conv2d(64, 128, kernel_size=3, padding=1),         # 小卷积核用于细节提取
                nn.ReLU(inplace=True)
            )
            
            # 检测任务：多尺度特征提取
            self.detection_branch = nn.ModuleList([
                nn.Conv2d(256, 64, kernel_size=1),    # 1×1用于降维
                nn.Conv2d(256, 64, kernel_size=3, padding=1),  # 3×3用于特征提取
                nn.Conv2d(256, 64, kernel_size=5, padding=2),  # 5×5用于大感受野
            ])
            
            # 分割任务：保持空间分辨率
            self.segmentation_branch = nn.Sequential(
                nn.Conv2d(256, 128, kernel_size=3, padding=1),   # 使用3×3保持分辨率
                nn.ReLU(inplace=True),
                nn.Conv2d(128, 64, kernel_size=1),              # 1×1用于通道调整
                nn.ReLU(inplace=True),
                nn.Conv2d(64, 1, kernel_size=3, padding=1)      # 最终预测
            )

# 演示不同卷积核的输出
def demonstrate_kernel_effects():
    """
    演示不同卷积核的效果
    """
    import torch
    import torch.nn as nn
    
    x = torch.randn(1, 3, 224, 224)
    
    # 不同大小的卷积核
    conv1x1 = nn.Conv2d(3, 64, kernel_size=1)
    conv3x3 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
    conv5x5 = nn.Conv2d(3, 64, kernel_size=5, padding=2)
    conv7x7 = nn.Conv2d(3, 64, kernel_size=7, padding=3)
    
    print("不同卷积核输出尺寸:")
    print(f"输入: {x.shape}")
    print(f"1×1卷积输出: {conv1x1(x).shape}")
    print(f"3×3卷积输出: {conv3x3(x).shape}")
    print(f"5×5卷积输出: {conv5x5(x).shape}")
    print(f"7×7卷积输出: {conv7x7(x).shape}")
    
    # 参数数量对比
    def count_params(conv_layer):
        return sum(p.numel() for p in conv_layer.parameters())
    
    print("\n参数数量对比:")
    print(f"1×1卷积参数: {count_params(conv1x1):,}")
    print(f"3×3卷积参数: {count_params(conv3x3):,}")
    print(f"5×5卷积参数: {count_params(conv5x5):,}")
    print(f"7×7卷积参数: {count_params(conv7x7):,}")

demonstrate_kernel_effects()

def stride_principle():
    """
    步长的基本原理和计算
    """
    """
    步长（Stride）定义卷积核在输入特征图上移动的步长。
    
    输出尺寸计算公式：
    H_out = floor((H_in + 2*pad - kernel_size) / stride) + 1
    W_out = floor((W_in + 2*pad - kernel_size) / stride) + 1
    
    其中：
    - H_in, W_in: 输入高度和宽度
    - H_out, W_out: 输出高度和宽度
    - pad: 填充大小
    - kernel_size: 卷积核尺寸
    - stride: 步长
    """
    
    import torch
    import torch.nn as nn
    
    def calculate_output_size(input_size, kernel_size, stride, padding):
        """
        计算卷积后输出尺寸
        """
        return (input_size + 2 * padding - kernel_size) // stride + 1
    
    # 示例计算
    input_size = 224
    kernel_size = 3
    
    print("不同步长下的输出尺寸:")
    for stride in [1, 2, 3, 4]:
        for padding in [0, 1]:
            output_size = calculate_output_size(input_size, kernel_size, stride, padding)
            print(f"输入{input_size}×{input_size}, 卷积核{kernel_size}×{kernel_size}, "
                  f"步长{stride}, 填充{padding} → 输出{output_size}×{output_size}")

stride_principle()

def stride_impact_analysis():
    """
    步长对网络性能的影响分析
    """
    """
    步长的影响：
    
    1. 特征图尺寸变化：
       - stride=1: 保持或轻微改变尺寸（取决于padding）
       - stride=2: 尺寸减半（下采样）
       - stride>2: 更大幅度的下采样
    
    2. 计算复杂度：
       - stride越大，计算量越小
       - 但可能丢失细节信息
    
    3. 感受野：
       - stride越大，有效感受野越大
       - 每个输出点看到的输入区域更大
    """
    
    import torch
    import torch.nn as nn
    
    class StrideAnalysis(nn.Module):
        def __init__(self):
            super().__init__()
            
            # 不同步长的卷积层
            self.stride_1 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
            self.stride_2 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
            self.stride_3 = nn.Conv2d(64, 128, kernel_size=3, stride=3, padding=1)
        
        def forward(self, x):
            return {
                'stride_1': self.stride_1(x),
                'stride_2': self.stride_2(x),
                'stride_3': self.stride_3(x)
            }
    
    # 分析不同步长的效果
    x = torch.randn(1, 64, 224, 224)
    model = StrideAnalysis()
    outputs = model(x)
    
    print("步长对输出的影响:")
    for stride_key, output in outputs.items():
        print(f"{stride_key}: {output.shape}")
    
    # 计算量对比（粗略估计）
    def estimate_flops(input_shape, output_shape, kernel_size):
        """
        估算FLOPs（浮点运算次数）
        """
        input_h, input_w = input_shape[2], input_shape[3]
        output_h, output_w = output_shape[2], output_shape[3]
        input_c, output_c = input_shape[1], output_shape[1]
        
        # 卷积操作的FLOPs
        flops = output_h * output_w * output_c * input_c * kernel_size * kernel_size
        return flops
    
    print("\n计算量对比（FLOPs）:")
    for stride_key, output in outputs.items():
        flops = estimate_flops(x.shape, output.shape, 3)
        print(f"{stride_key}: ~{flops/1e6:.2f}M FLOPs")

stride_impact_analysis()

def padding_strategies():
    """
    不同填充策略的分析
    """
    """
    填充类型：
    
    1. Valid Padding (padding=0):
       - 不填充
       - 输出尺寸减小
       - 边缘信息丢失
    
    2. Same Padding (padding=k//2):
       - 填充使输出尺寸与输入相同（当stride=1时）
       - 保持空间维度
       - 保留边缘信息
    
    3. Custom Padding:
       - 自定义填充大小
       - 灵活控制输出尺寸
    """
    
    import torch
    import torch.nn as nn
    
    x = torch.randn(1, 3, 32, 32)
    
    # 不同填充策略
    conv_valid = nn.Conv2d(3, 64, kernel_size=3, padding=0)  # valid padding
    conv_same = nn.Conv2d(3, 64, kernel_size=3, padding=1)   # same padding
    conv_custom = nn.Conv2d(3, 64, kernel_size=5, padding=2) # custom padding
    
    print("填充策略对输出的影响:")
    print(f"输入: {x.shape}")
    print(f"Valid padding (3×3, pad=0): {conv_valid(x).shape}")
    print(f"Same padding (3×3, pad=1): {conv_same(x).shape}")
    print(f"Custom padding (5×5, pad=2): {conv_custom(x).shape}")
    
    # 自定义填充函数
    class CustomPadding(nn.Module):
        def __init__(self, padding):
            super().__init__()
            self.padding = padding
        
        def forward(self, x):
            # 手动实现填充
            pad_h, pad_w = self.padding
            return torch.nn.functional.pad(x, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=0)
    
    # 不同填充模式
    x_small = torch.randn(1, 1, 4, 4)
    print(f"\n原始输入:\n{x_small[0, 0]}")
    
    # 零填充
    zero_padded = torch.nn.functional.pad(x_small, (1, 1, 1, 1), mode='constant', value=0)
    print(f"零填充:\n{zero_padded[0, 0]}")
    
    # 反射填充
    reflect_padded = torch.nn.functional.pad(x_small, (1, 1, 1, 1), mode='reflect')
    print(f"反射填充:\n{reflect_padded[0, 0]}")

padding_strategies()

def stride_padding_combinations():
    """
    步长与填充的组合应用
    """
    """
    常见的步长-填充组合：
    
    1. stride=1, padding=k//2:
       - 保持空间尺寸
       - 常用于特征提取层
    
    2. stride=2, padding=k//2:
       - 空间尺寸减半
       - 常用于下采样层
    
    3. stride=1, padding=0:
       - 空间尺寸减小
       - 用于特定的尺寸调整
    """
    
    import torch
    import torch.nn as nn
    
    class DownsampleBlock(nn.Module):
        """
        典型的下采样块
        """
        def __init__(self, in_channels, out_channels, stride=2):
            super().__init__()
            self.conv = nn.Conv2d(in_channels, out_channels, 
                                kernel_size=3, stride=stride, 
                                padding=1 if stride == 1 else 1)
            self.bn = nn.BatchNorm2d(out_channels)
            self.relu = nn.ReLU(inplace=True)
        
        def forward(self, x):
            return self.relu(self.bn(self.conv(x)))
    
    class FeaturePreservingBlock(nn.Module):
        """
        保持特征尺寸的块
        """
        def __init__(self, in_channels, out_channels):
            super().__init__()
            self.conv = nn.Conv2d(in_channels, out_channels,
                                kernel_size=3, stride=1, padding=1)
            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 advanced_stride_techniques():
    """
    高级步长技术
    """
    """
    1. 空洞卷积（Dilated Convolution）：
       - 在卷积核元素间插入空洞
       - 增大感受野而不增加参数
    
    2. 转置卷积（Transposed Convolution）：
       - 用于上采样
       - 增加空间维度
    """
    
    import torch
    import torch.nn as nn
    
    # 空洞卷积示例
    dilated_conv = nn.Conv2d(3, 64, kernel_size=3, padding=2, dilation=2)
    x = torch.randn(1, 3, 32, 32)
    print(f"普通3×3卷积输出: {nn.Conv2d(3, 64, 3)(x).shape}")
    print(f"空洞卷积(dilation=2)输出: {dilated_conv(x).shape}")
    
    # 转置卷积示例（上采样）
    transpose_conv = nn.ConvTranspose2d(64, 3, kernel_size=3, stride=2, padding=1, output_padding=1)
    x_features = torch.randn(1, 64, 16, 16)
    print(f"转置卷积(上采样)输出: {transpose_conv(x_features).shape}")

advanced_stride_techniques()

def pooling_principle():
    """
    池化操作的基本原理
    """
    """
    池化操作的目的：
    
    1. 降维（Downsampling）：
       - 减少特征图的空间尺寸
       - 降低计算复杂度
    
    2. 平移不变性（Translation Invariance）：
       - 对小的平移变化不敏感
       - 提高鲁棒性
    
    3. 特征选择（Feature Selection）：
       - 保留最重要的特征
       - 抑制噪声
    """
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    x = torch.randn(1, 64, 32, 32)
    
    # 最大池化
    max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
    avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
    
    print("池化操作对比:")
    print(f"输入: {x.shape}")
    print(f"最大池化: {max_pool(x).shape}")
    print(f"平均池化: {avg_pool(x).shape}")
    
    # 全局池化
    global_max_pool = nn.AdaptiveMaxPool2d((1, 1))
    global_avg_pool = nn.AdaptiveAvgPool2d((1, 1))
    
    print(f"全局最大池化: {global_max_pool(x).shape}")
    print(f"全局平均池化: {global_avg_pool(x).shape}")

pooling_principle()

def pooling_methods_comparison():
    """
    不同池化方法的对比分析
    """
    """
    池化方法对比：
    
    1. 最大池化（Max Pooling）：
       - 优点：保留最强特征，对噪声鲁棒
       - 缺点：可能丢失重要信息
    
    2. 平均池化（Average Pooling）：
       - 优点：保留整体信息，平滑效果
       - 缺点：可能削弱强特征
    
    3. 全局池化（Global Pooling）：
       - 用于特征聚合
       - 常用于分类头
    
    4. 自适应池化（Adaptive Pooling）：
       - 自动调整池化窗口
       - 保证输出尺寸固定
    """
    
    import torch
    import torch.nn as nn
    
    # 创建示例数据
    x = torch.randn(1, 64, 16, 16)
    
    class PoolingComparison(nn.Module):
        def __init__(self):
            super().__init__()
            
            # 固定大小池化
            self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
            self.avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
            self.adaptive_max_pool = nn.AdaptiveMaxPool2d((8, 8))
            self.adaptive_avg_pool = nn.AdaptiveAvgPool2d((8, 8))
            
            # 全局池化
            self.global_max_pool = nn.AdaptiveMaxPool2d((1, 1))
            self.global_avg_pool = nn.AdaptiveAvgPool2d((1, 1))
        
        def forward(self, x):
            return {
                'max_pool': self.max_pool(x),
                'avg_pool': self.avg_pool(x),
                'adaptive_max': self.adaptive_max_pool(x),
                'adaptive_avg': self.adaptive_avg_pool(x),
                'global_max': self.global_max_pool(x),
                'global_avg': self.global_avg_pool(x)
            }
    
    model = PoolingComparison()
    results = model(x)
    
    print("不同池化方法输出对比:")
    for name, result in results.items():
        print(f"{name}: {result.shape}")
    
    # 池化对特征的影响分析
    def analyze_pooling_effects():
        """
        分析池化对特征统计特性的影响
        """
        # 创建一个有明显峰值的特征图
        x_peak = torch.zeros(1, 1, 8, 8)
        x_peak[0, 0, 3:5, 3:5] = 10  # 中心区域有高值
        x_peak += torch.randn(1, 1, 8, 8) * 0.1  # 添加噪声
        
        print("\n池化对峰值特征的影响:")
        print(f"原始特征 - 均值: {x_peak.mean():.3f}, 最大值: {x_peak.max():.3f}")
        
        max_pooled = nn.MaxPool2d(2, 2)(x_peak)
        avg_pooled = nn.AvgPool2d(2, 2)(x_peak)
        
        print(f"最大池化 - 均值: {max_pooled.mean():.3f}, 最大值: {max_pooled.max():.3f}")
        print(f"平均池化 - 均值: {avg_pooled.mean():.3f}, 最大值: {avg_pooled.max():.3f}")

analyze_pooling_effects()

pooling_methods_comparison()

def advanced_pooling_techniques():
    """
    高级池化技术
    """
    """
    1. 随机池化（Stochastic Pooling）：
       - 按概率选择池化区域的值
       - 增加随机性，防止过拟合
    
    2. 重叠池化（Overlapping Pooling）：
       - 池化窗口重叠
       - 减少过拟合
    
    3. 空间金字塔池化（Spatial Pyramid Pooling）：
       - 多尺度池化
       - 适应不同输入尺寸
    """
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    # 空间金字塔池化示例
    class SpatialPyramidPooling(nn.Module):
        """
        空间金字塔池化层
        """
        def __init__(self, pool_sizes=[1, 2, 4]):
            super().__init__()
            self.pool_sizes = pool_sizes
        
        def forward(self, x):
            batch_size, channels, height, width = x.size()
            pooled_features = []
            
            for pool_size in self.pool_sizes:
                # 计算每个池化窗口的大小
                kernel_h = height // pool_size
                kernel_w = width // pool_size
                stride_h = kernel_h
                stride_w = kernel_w
                
                # 执行池化
                pooled = F.max_pool2d(x, kernel_size=(kernel_h, kernel_w), 
                                    stride=(stride_h, stride_w))
                pooled = pooled.view(batch_size, channels, -1)
                pooled_features.append(pooled)
            
            # 拼接所有尺度的特征
            return torch.cat(pooled_features, dim=2).view(batch_size, -1)
    
    # 示例使用
    x = torch.randn(1, 64, 16, 16)
    spp = SpatialPyramidPooling()
    spp_output = spp(x)
    print(f"SPP输出尺寸: {spp_output.shape}")
    
    # 自定义池化函数
    class LearnablePooling(nn.Module):
        """
        可学习的池化操作
        """
        def __init__(self, kernel_size=2, stride=2):
            super().__init__()
            self.kernel_size = kernel_size
            self.stride = stride
            # 学习池化权重
            self.weights = nn.Parameter(torch.ones(kernel_size, kernel_size) / (kernel_size * kernel_size))
        
        def forward(self, x):
            # 使用可学习权重进行池化
            batch_size, channels, height, width = x.size()
            
            # 展开操作
            unfold = nn.Unfold(kernel_size=self.kernel_size, stride=self.stride)
            patches = unfold(x)  # (batch, channels*kernel_h*kernel_w, n_patches)
            
            # 应用可学习权重
            weights_flat = self.weights.view(-1).repeat(channels)
            weighted_patches = patches * weights_flat.unsqueeze(1)
            
            # 求和得到池化结果
            pooled = weighted_patches.sum(dim=1)  # (batch, n_patches)
            
            # 重塑为特征图
            out_h = (height - self.kernel_size) // self.stride + 1
            out_w = (width - self.kernel_size) // self.stride + 1
            output = pooled.view(batch_size, channels, out_h, out_w)
            
            return output

def pooling_for_different_tasks():
    """
    不同任务中的池化应用
    """
    """
    分类任务：
    - 全局平均池化（GAP）：用于分类头
    - 最大池化：特征提取过程中的下采样
    
    检测任务：
    - 保持空间信息：较少使用全局池化
    - 多尺度池化：FPN等结构
    
    分割任务：
    - 保持空间分辨率：避免过度池化
    - 注意力池化：自适应特征选择
    """
    
    import torch
    import torch.nn as nn
    
    class TaskSpecificPooling(nn.Module):
        def __init__(self, task_type='classification'):
            super().__init__()
            self.task_type = task_type
            
            if task_type == 'classification':
                # 分类任务：全局池化
                self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
                self.classifier = nn.Linear(256, 1000)
            elif task_type == 'detection':
                # 检测任务：保持空间结构
                self.downsample = nn.MaxPool2d(2, 2)
            elif task_type == 'segmentation':
                # 分割任务：上采样池化
                self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
        
        def forward(self, x):
            if self.task_type == 'classification':
                x = self.global_pool(x)
                x = x.view(x.size(0), -1)
                return self.classifier(x)
            elif self.task_type == 'detection':
                return self.downsample(x)
            elif self.task_type == 'segmentation':
                return self.upsample(x)

# 演示池化操作
def demonstrate_pooling_operations():
    """
    演示各种池化操作
    """
    import torch
    import torch.nn as nn
    
    x = torch.randn(1, 64, 32, 32)
    
    print("池化操作演示:")
    print(f"输入尺寸: {x.shape}")
    
    # 标准池化
    max_pool = nn.MaxPool2d(2, 2)
    avg_pool = nn.AvgPool2d(2, 2)
    print(f"最大池化输出: {max_pool(x).shape}")
    print(f"平均池化输出: {avg_pool(x).shape}")
    
    # 自适应池化
    adaptive_pool = nn.AdaptiveMaxPool2d((16, 16))
    print(f"自适应池化输出: {adaptive_pool(x).shape}")
    
    # 全局池化
    global_pool = nn.AdaptiveAvgPool2d((1, 1))
    print(f"全局池化输出: {global_pool(x).shape}")

demonstrate_pooling_operations()

def receptive_field_basics():
    """
    感受野的基本概念和计算
    """
    """
    感受野（Receptive Field）定义：
    - 输出特征图上单个点对应输入图像的区域大小
    - 表示该输出点"看到"的输入范围
    
    感受野的重要性：
    - 决定模型的感受范围
    - 影响对上下文的理解能力
    - 关系到模型的表达能力
    """
    
    def calculate_receptive_field(layers_info):
        """
        计算累积感受野
        layers_info: [(kernel_size, stride), ...]
        """
        rf = 1  # 初始感受野
        effective_stride = 1  # 有效步长
        
        print("逐层感受野计算:")
        print(f"{'层':<4} {'核大小':<6} {'步长':<6} {'累积RF':<8} {'有效步长':<10}")
        print("-" * 40)
        
        for i, (k, s) in enumerate(layers_info):
            rf = rf + (k - 1) * effective_stride
            effective_stride = effective_stride * s
            print(f"{i+1:<4} {k:<6} {s:<6} {rf:<8} {effective_stride:<10}")
        
        return rf, effective_stride
    
    # 示例：ResNet-like结构
    layers = [
        (7, 2),  # 7×7卷积，步长2
        (3, 2),  # 3×3卷积，步长2  
        (3, 1),  # 3×3卷积，步长1
        (3, 1),  # 3×3卷积，步长1
    ]
    
    print("ResNet-like结构感受野计算:")
    final_rf, final_stride = calculate_receptive_field(layers)
    print(f"\n最终感受野: {final_rf}")
    print(f"最终有效步长: {final_stride}")

receptive_field_basics()

def receptive_field_calculation():
    """
    感受野的详细计算方法
    """
    """
    感受野计算公式：
    
    设第i层的感受野为RF_i，步长为S_i，核大小为K_i
    
    RF_{i+1} = RF_i + (K_{i+1} - 1) * S_1 * S_2 * ... * S_i
    
    或者：
    RF_{i+1} = RF_i + (K_{i+1} - 1) * cumulative_stride_i
    """
    
    class ReceptiveFieldCalculator:
        def __init__(self):
            self.layers = []
        
        def add_layer(self, kernel_size, stride, padding=0):
            self.layers.append({
                'kernel_size': kernel_size,
                'stride': stride,
                'padding': padding
            })
        
        def calculate_all(self):
            rf = 1
            effective_stride = 1
            effective_padding = 0
            
            print("感受野计算详情:")
            print(f"{'层':<4} {'核大小':<6} {'步长':<6} {'感受野':<8} {'有效步长':<10} {'有效填充':<10}")
            print("-" * 60)
            
            for i, layer in enumerate(self.layers):
                old_rf = rf
                old_stride = effective_stride
                
                # 更新感受野
                rf = rf + (layer['kernel_size'] - 1) * effective_stride
                # 更新有效步长
                effective_stride = effective_stride * layer['stride']
                # 更新有效填充
                effective_padding = effective_padding + (layer['padding'] * effective_stride // old_stride)
                
                print(f"{i+1:<4} {layer['kernel_size']:<6} {layer['stride']:<6} "
                      f"{rf:<8} {effective_stride:<10} {effective_padding:<10}")
            
            return rf, effective_stride, effective_padding
    
    # 构建一个简单的CNN结构
    calc = ReceptiveFieldCalculator()
    
    # 典型的CNN结构
    calc.add_layer(kernel_size=7, stride=2, padding=3)  # 初始大卷积
    calc.add_layer(kernel_size=3, stride=2, padding=1)  # 下采样
    calc.add_layer(kernel_size=3, stride=1, padding=1)  # 特征提取
    calc.add_layer(kernel_size=3, stride=1, padding=1)  # 特征提取
    calc.add_layer(kernel_size=3, stride=1, padding=1)  # 特征提取
    
    final_rf, final_stride, final_padding = calc.calculate_all()
    print(f"\n最终感受野: {final_rf}")
    print(f"最终有效步长: {final_stride}")
    print(f"最终有效填充: {final_padding}")

receptive_field_calculation()

def receptive_field_optimization():
    """
    感受野的优化策略
    """
    """
    感受野优化策略：
    
    1. 使用空洞卷积（Dilated Convolution）：
       - 增大感受野而不增加参数
       - 保持空间分辨率
    
    2. 渐进式增大感受野：
       - 逐层增加感受野
       - 平衡计算效率和感受范围
    
    3. 多尺度感受野：
       - 并行不同感受野的路径
       - 捕获多尺度信息
    """
    
    import torch
    import torch.nn as nn
    
    # 空洞卷积示例
    class DilatedConvolution(nn.Module):
        """
        使用空洞卷积增大感受野
        """
        def __init__(self, in_channels, out_channels, dilation_rates=[1, 2, 4, 8]):
            super().__init__()
            self.convs = nn.ModuleList()
            
            for rate in dilation_rates:
                conv = nn.Conv2d(in_channels, out_channels//len(dilation_rates), 
                               kernel_size=3, padding=rate, dilation=rate)
                self.convs.append(conv)
        
        def forward(self, x):
            outputs = []
            for conv in self.convs:
                outputs.append(conv(x))
            return torch.cat(outputs, dim=1)
    
    # 多尺度感受野示例
    class MultiScaleReceptiveField(nn.Module):
        """
        多尺度感受野模块
        """
        def __init__(self, in_channels, out_channels):
            super().__init__()
            
            # 不同尺度的卷积路径
            self.path_1x1 = nn.Conv2d(in_channels, out_channels//4, 1)
            self.path_3x3 = nn.Conv2d(in_channels, out_channels//4, 3, padding=1)
            self.path_5x5 = nn.Conv2d(in_channels, out_channels//4, 5, padding=2)
            self.path_7x7 = nn.Conv2d(in_channels, out_channels//4, 7, padding=3)
        
        def forward(self, x):
            out1 = self.path_1x1(x)
            out2 = self.path_3x3(x)
            out3 = self.path_5x5(x)
            out4 = self.path_7x7(x)
            return torch.cat([out1, out2, out3, out4], dim=1)
    
    # 感受野可视化辅助函数
    def visualize_receptive_field_effect():
        """
        感受野效果可视化
        """
        print("感受野大小对模型性能的影响:")
        print("小感受野 (<10): 捕获局部细节，但缺乏上下文")
        print("中等感受野 (10-50): 平衡局部和全局信息")
        print("大感受野 (>50): 捕获全局上下文，但可能忽略细节")
        print("超大感受野 (>100): 可能导致过拟合特定模式")
    
    visualize_receptive_field_effect()

receptive_field_optimization()

def receptive_field_applications():
    """
    感受野在实际应用中的考虑
    """
    """
    不同任务对感受野的需求：
    
    1. 图像分类：
       - 需要足够大的感受野覆盖整个物体
       - 通常最终层感受野应覆盖大部分输入
    
    2. 目标检测：
       - 需要平衡局部精度和全局上下文
       - 不同层级需要不同大小的感受野
    
    3. 语义分割：
       - 需要在保持空间精度的同时有足够感受野
       - 通常使用跳跃连接平衡两者
    """
    
    import torch
    import torch.nn as nn
    
    class TaskSpecificReceptiveField(nn.Module):
        """
        针对不同任务的接收野设计
        """
        def __init__(self, task_type='classification', input_size=224):
            super().__init__()
            self.task_type = task_type
            
            if task_type == 'classification':
                # 分类：逐步增大感受野
                self.features = nn.Sequential(
                    nn.Conv2d(3, 64, 7, stride=2, padding=3),  # 大感受野开始
                    nn.ReLU(inplace=True),
                    nn.MaxPool2d(3, stride=2, padding=1),      # 进一步下采样
                    nn.Conv2d(64, 128, 3, padding=1),         # 保持感受野增长
                    nn.ReLU(inplace=True),
                )
            elif task_type == 'detection':
                # 检测：多尺度感受野
                self.backbone = nn.Sequential(
                    nn.Conv2d(3, 32, 3, stride=2, padding=1),
                    nn.ReLU(inplace=True),
                    nn.Conv2d(32, 64, 3, stride=2, padding=1),
                    nn.ReLU(inplace=True),
                )
                # 多尺度头部
                self.heads = nn.ModuleDict({
                    'small': nn.Conv2d(64, 4, 3, padding=1),   # 小物体检测
                    'medium': nn.Conv2d(64, 4, 5, padding=2), # 中等物体检测
                    'large': nn.Conv2d(64, 4, 7, padding=3),  # 大物体检测
                })
            elif task_type == 'segmentation':
                # 分割：保持空间精度
                self.encoder = nn.Sequential(
                    nn.Conv2d(3, 64, 3, padding=1),
                    nn.ReLU(inplace=True),
                    nn.Conv2d(64, 128, 3, stride=2, padding=1),  # 下采样
                    nn.ReLU(inplace=True),
                )
                self.decoder = nn.Sequential(
                    nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1),  # 上采样
                    nn.ReLU(inplace=True),
                    nn.Conv2d(64, 1, 3, padding=1),  # 保持空间精度
                )
    
        def forward(self, x):
            if self.task_type == 'classification':
                x = self.features(x)
                return nn.functional.adaptive_avg_pool2d(x, (1, 1)).view(x.size(0), -1)
            elif self.task_type == 'detection':
                features = self.backbone(x)
                outputs = {}
                for name, head in self.heads.items():
                    outputs[name] = head(features)
                return outputs
            elif self.task_type == 'segmentation':
                encoded = self.encoder(x)
                decoded = self.decoder(encoded)
                return nn.functional.interpolate(decoded, size=x.shape[2:], mode='bilinear')

def practical_receptive_field_examples():
    """
    实际网络中的感受野示例
    """
    # ResNet感受野分析
    resnet_layers = [
        (7, 2),  # conv1
        (3, 2),  # maxpool
        (3, 1),  # conv2_x
        (3, 2),  # conv3_x
        (3, 2),  # conv4_x
        (3, 2),  # conv5_x
    ]
    
    calc = ReceptiveFieldCalculator()
    for k, s in resnet_layers:
        calc.add_layer(k, s)
    
    rf, stride, padding = calc.calculate_all()
    print(f"ResNet感受野分析 - 最终感受野: {rf}, 有效步长: {stride}")

practical_receptive_field_examples()

class EfficientConvModule(nn.Module):
    """
    高效卷积模块设计
    """
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, 
                 dilation=1, groups=1, use_bn=True, use_relu=True):
        super().__init__()
        
        # 计算padding
        padding = dilation * (kernel_size - 1) // 2
        
        # 基础卷积层
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, 
                            stride=stride, padding=padding, 
                            dilation=dilation, groups=groups, bias=not use_bn)
        
        # 批归一化
        self.bn = nn.BatchNorm2d(out_channels) if use_bn else nn.Identity()
        
        # 激活函数
        self.relu = nn.ReLU(inplace=True) if use_relu else nn.Identity()
    
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x

class BottleneckBlock(nn.Module):
    """
    改进的瓶颈块
    """
    def __init__(self, in_channels, bottleneck_channels, out_channels, 
                 stride=1, expansion=4):
        super().__init__()
        
        self.expansion = expansion
        expanded_channels = bottleneck_channels * expansion
        
        # 1x1降维
        self.conv1 = EfficientConvModule(in_channels, bottleneck_channels, 
                                       kernel_size=1)
        
        # 3x3主卷积
        self.conv2 = EfficientConvModule(bottleneck_channels, bottleneck_channels, 
                                       kernel_size=3, stride=stride)
        
        # 1x1升维
        self.conv3 = EfficientConvModule(bottleneck_channels, out_channels, 
                                       kernel_size=1)
        
        # 残差连接
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, 
                         stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
        
        self.relu = nn.ReLU(inplace=True)
    
    def forward(self, x):
        identity = x
        
        out = self.conv1(x)
        out = self.conv2(out)
        out = self.conv3(out)
        
        out += self.shortcut(identity)
        out = self.relu(out)
        
        return out

def design_guidelines():
    """
    卷积层设计指南
    """
    """
    设计原则：
    
    1. 感受野规划：
       - 根据任务需求规划各层感受野
       - 逐步增大感受野
    
    2. 参数效率：
       - 优先使用小卷积核堆叠
       - 合理使用1x1卷积降维
       - 考虑深度可分离卷积
    
    3. 计算平衡：
       - 平衡精度和速度
       - 考虑硬件限制
       - 优化内存使用
    """
    
    print("卷积层设计最佳实践:")
    print("✓ 使用3×3卷积核堆叠替代大卷积核")
    print("✓ 在降维层使用1×1卷积")
    print("✓ 合理设置步长进行下采样")
    print("✓ 使用批归一化稳定训练")
    print("✓ 考虑使用空洞卷积增大感受野")
    print("✓ 根据任务特点调整感受野大小")

design_guidelines()