#从全连接到卷积：为什么计算机视觉需要卷积层？

"""
全连接层（Fully Connected Layer）数学表示：

输入向量 x ∈ R^n
权重矩阵 W ∈ R^(m×n) 
偏置向量 b ∈ R^m
输出向量 y ∈ R^m

y = Wx + b

其中每个输出节点都与所有输入节点相连
"""

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

def analyze_fc_parameters(input_size, hidden_size):
    """
    分析全连接层参数数量
    """
    # 参数数量 = 输入维度 × 输出维度 + 偏置项
    weight_params = input_size * hidden_size
    bias_params = hidden_size
    total_params = weight_params + bias_params
    
    return {
        'weight_params': weight_params,
        'bias_params': bias_params,
        'total_params': total_params,
        'param_ratio': weight_params / total_params  # 权重参数占比
    }

# 示例：分析不同图像尺寸的参数数量
image_sizes = [(28, 28), (64, 64), (100, 100), (224, 224)]
hidden_size = 1000

print("全连接层参数分析:")
print("-" * 50)
for h, w in image_sizes:
    params = analyze_fc_parameters(h * w, hidden_size)
    print(f"图像尺寸: {h}×{w}")
    print(f"  输入维度: {h * w}")
    print(f"  参数总量: {params['total_params']:,}")
    print(f"  权重参数: {params['weight_params']:,}")
    print(f"  偏置参数: {params['bias_params']:,}")
    print()

def parameter_explosion_demo():
    """
    演示参数爆炸问题
    """
    # 以常见的图像尺寸为例
    examples = [
        {"name": "MNIST (28×28)", "size": 28*28, "hidden": 1000},
        {"name": "CIFAR-10 (32×32)", "size": 32*32, "hidden": 1000},
        {"name": "Small Image (64×64)", "size": 64*64, "hidden": 1000},
        {"name": "Medium Image (128×128)", "size": 128*128, "hidden": 1000},
        {"name": "Large Image (224×224)", "size": 224*224, "hidden": 1000},
    ]
    
    print("参数爆炸问题分析:")
    print("=" * 60)
    for ex in examples:
        total_params = ex["size"] * ex["hidden"] + ex["hidden"]
        print(f"{ex['name']:<20} - 参数数量: {total_params:,} ({total_params/1e6:.2f}M)")
    
    print("\n问题分析:")
    print("• 224×224图像输入到1000神经元层需要约5000万个参数!")
    print("• 参数过多导致训练困难，容易过拟合")
    print("• 内存消耗巨大，计算效率低下")

parameter_explosion_demo()

def spatial_structure_loss_demo():
    """
    演示全连接层缺乏空间结构感知的问题
    """
    # 创建一个简单的图像模式
    image = torch.tensor([
        [1, 1, 0, 0],
        [1, 1, 0, 0], 
        [0, 0, 1, 1],
        [0, 0, 1, 1]
    ], dtype=torch.float32)
    
    # 展平为一维向量
    flattened = image.flatten()
    
    print("空间结构损失演示:")
    print("原始图像 (4×4):")
    print(image.numpy())
    print("\n展平后的一维向量:")
    print(flattened.numpy())
    print("\n问题：全连接层无法感知像素间的空间关系")
    print("相邻像素和远距离像素被同等对待")

spatial_structure_loss_demo()

def overfitting_risk_analysis():
    """
    分析全连接层的过拟合风险
    """
    """
    过拟合风险因素：
    
    1. 参数数量远超训练样本数量
    2. 缺乏归纳偏置（inductive bias）
    3. 每个参数独立学习，缺乏约束
    4. 无法利用图像的空间局部性
    """
    
    # 计算参数密度
    def calculate_param_density(input_size, hidden_size, dataset_size):
        params = input_size * hidden_size + hidden_size
        density = params / dataset_size
        return {
            'parameters': params,
            'dataset_size': dataset_size,
            'density': density,
            'risk_level': 'High' if density > 10 else 'Medium' if density > 1 else 'Low'
        }
    
    dataset_sizes = [1000, 10000, 50000, 100000]
    input_size = 224 * 224  # 224×224图像
    hidden_size = 1000
    
    print("过拟合风险分析 (224×224 → 1000):")
    print("-" * 50)
    for size in dataset_sizes:
        risk = calculate_param_density(input_size, hidden_size, size)
        print(f"数据集大小: {size:,} | 参数密度: {risk['density']:.1f} | 风险等级: {risk['risk_level']}")

overfitting_risk_analysis()

def parameter_sharing_explained():
    """
    解释卷积层的参数共享机制
    """
    """
    参数共享原理：
    
    全连接层：每个连接都有独立的权重参数
    卷积层：同一卷积核在整个图像上共享参数
    
    举例说明：
    - 全连接：224×224图像 → 1000神经元，需要 50M+ 参数
    - 卷积：32个3×3卷积核，只需要 32×3×3 = 288 参数
    """
    
    def calculate_conv_params(kernel_size, input_channels, output_channels):
        """
        计算卷积层参数数量
        """
        weight_params = kernel_size * kernel_size * input_channels * output_channels
        bias_params = output_channels
        total_params = weight_params + bias_params
        
        return {
            'weight_params': weight_params,
            'bias_params': bias_params,
            'total_params': total_params
        }
    
    print("参数共享优势分析:")
    print("-" * 40)
    
    # 卷积层参数计算示例
    conv_configs = [
        {"name": "32个3×3核", "ks": 3, "ic": 1, "oc": 32},
        {"name": "64个5×5核", "ks": 5, "ic": 32, "oc": 64},
        {"name": "128个3×3核", "ks": 3, "ic": 64, "oc": 128},
    ]
    
    for config in conv_configs:
        params = calculate_conv_params(config["ks"], config["ic"], config["oc"])
        print(f"{config['name']:<15} - 参数数量: {params['total_params']:,}")
    
    print("\n对比全连接层（224×224 → 1000）: 50,177,000 参数")
    print("卷积层参数数量大幅减少！")

parameter_sharing_explained()

def local_connectivity_explained():
    """
    解释卷积层的局部连接特性
    """
    """
    局部连接原理：
    
    全连接：每个输出节点连接所有输入节点
    卷积层：每个输出节点只连接输入的一个局部区域
    
    优势：
    1. 符合图像的局部性原理（相邻像素相关性更强）
    2. 减少参数数量
    3. 保留空间结构信息
    """
    
    import torch
    import torch.nn as nn
    
    # 创建示例网络比较
    class FCNetwork(nn.Module):
        def __init__(self):
            super().__init__()
            self.flatten = nn.Flatten()
            self.fc1 = nn.Linear(28*28, 128)  # 全连接
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(128, 10)
        
        def forward(self, x):
            x = self.flatten(x)
            x = self.fc1(x)
            x = self.relu(x)
            x = self.fc2(x)
            return x
    
    class ConvNetwork(nn.Module):
        def __init__(self):
            super().__init__()
            self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # 局部连接
            self.relu = nn.ReLU()
            self.pool = nn.MaxPool2d(2)
            self.flatten = nn.Flatten()
            self.fc = nn.Linear(32*14*14, 10)
        
        def forward(self, x):
            x = self.conv1(x)
            x = self.relu(x)
            x = self.pool(x)
            x = self.flatten(x)
            x = self.fc(x)
            return x
    
    # 参数对比
    fc_net = FCNetwork()
    conv_net = ConvNetwork()
    
    fc_params = sum(p.numel() for p in fc_net.parameters())
    conv_params = sum(p.numel() for p in conv_net.parameters())
    
    print("局部连接优势分析:")
    print("-" * 30)
    print(f"全连接网络参数: {fc_params:,}")
    print(f"卷积网络参数: {conv_params:,}")
    print(f"参数减少: {(fc_params - conv_params) / fc_params * 100:.1f}%")

local_connectivity_explained()

def translation_invariance_demo():
    """
    演示卷积层的平移不变性
    """
    import torch
    import torch.nn.functional as F
    
    # 创建一个简单的模式
    pattern = torch.zeros(1, 1, 8, 8)
    pattern[0, 0, 2:4, 2:4] = 1  # 在左上角放置一个2×2的方块
    
    # 创建一个卷积核（边缘检测）
    edge_kernel = torch.tensor([[-1, -1, -1],
                                [-1,  8, -1],
                                [-1, -1, -1]], dtype=torch.float32).unsqueeze(0).unsqueeze(0)
    
    # 将模式移动到不同位置
    pattern_shifted = torch.zeros(1, 1, 8, 8)
    pattern_shifted[0, 0, 4:6, 4:6] = 1  # 在右下角放置相同的方块
    
    # 应用卷积
    output1 = F.conv2d(pattern, edge_kernel, padding=1)
    output2 = F.conv2d(pattern_shifted, edge_kernel, padding=1)
    
    print("平移不变性演示:")
    print("原始模式的卷积输出特征图形状:", output1.shape)
    print("平移后模式的卷积输出特征图形状:", output2.shape)
    print("卷积核能够检测相同模式，无论其在图像中的位置")
    print("这就是平移不变性的体现")

translation_invariance_demo()

def convolution_mathematical_definition():
    """
    卷积的数学定义和性质
    """
    """
    连续域卷积定义：
    (f * g)(t) = ∫ f(τ)g(t-τ) dτ
    
    离散域卷积定义：
    (f * g)[n] = Σ f[m]g[n-m]
    
    二维离散卷积定义：
    (I * K)[i,j] = Σ Σ I[m,n]K[i-m,j-n]
    
    在CNN中，通常使用互相关（cross-correlation）：
    (I ⋆ K)[i,j] = Σ Σ I[i+m,j+n]K[m,n]
    """
    
    def discrete_convolution_2d(input_tensor, kernel):
        """
        二维离散卷积的简单实现（演示目的）
        """
        h, w = input_tensor.shape
        kh, kw = kernel.shape
        
        output_h = h - kh + 1
        output_w = w - kw + 1
        
        output = torch.zeros(output_h, output_w)
        
        for i in range(output_h):
            for j in range(output_w):
                # 提取输入区域
                region = input_tensor[i:i+kh, j:j+kw]
                # 计算卷积（对应元素相乘再求和）
                output[i, j] = torch.sum(region * kernel)
        
        return output
    
    # 示例
    input_img = torch.tensor([
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 1, 2, 3],
        [4, 5, 6, 7]
    ], dtype=torch.float32)
    
    kernel = torch.tensor([
        [1, 0, -1],
        [2, 0, -2],
        [1, 0, -1]
    ], dtype=torch.float32)
    
    result = discrete_convolution_2d(input_img, kernel)
    print("自定义卷积实现结果:")
    print(result)

convolution_mathematical_definition()

def convolution_properties():
    """
    卷积的主要性质
    """
    """
    1. 交换律：f * g = g * f
    2. 结合律：(f * g) * h = f * (g * h)  
    3. 分配律：f * (g + h) = f * g + f * h
    4. 与单位脉冲函数的卷积：f * δ = f
    """
    
    import torch
    import torch.nn.functional as F
    
    # 验证卷积的交换律（近似验证）
    def verify_commutativity():
        # 创建两个小矩阵
        f = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)
        g = torch.tensor([[0, 1], [1, 0]], dtype=torch.float32)
        
        # 使用padding确保结果尺寸一致
        f_padded = F.pad(f, (1, 1, 1, 1), mode='constant', value=0)
        g_padded = F.pad(g, (1, 1, 1, 1), mode='constant', value=0)
        
        # 卷积操作
        fg = F.conv2d(f_padded.unsqueeze(0).unsqueeze(0), 
                      g.unsqueeze(0).unsqueeze(0), padding=0)
        gf = F.conv2d(g_padded.unsqueeze(0).unsqueeze(0), 
                      f.unsqueeze(0).unsqueeze(0), padding=0)
        
        print("卷积交换律验证:")
        print("f * g:", fg.squeeze().detach().numpy())
        print("g * f:", gf.squeeze().detach().numpy())
        print("在CNN中通常使用互相关，严格意义上不满足交换律")
    
    verify_commutativity()

convolution_properties()

def convolution_implementation_methods():
    """
    不同的卷积实现方式
    """
    """
    1. 直接卷积：逐个计算每个输出位置
    2. im2col：将图像块转换为列向量，用矩阵乘法实现
    3. FFT：使用快速傅里叶变换加速
    4. Winograd：减少乘法运算的算法
    """
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    # PyTorch中的卷积实现
    def demonstrate_pytorch_conv():
        batch_size, channels, height, width = 1, 3, 32, 32
        input_tensor = torch.randn(batch_size, channels, height, width)
        
        # 不同的卷积配置
        conv_layers = {
            'standard': nn.Conv2d(channels, 64, kernel_size=3, padding=1),
            'stride_2': nn.Conv2d(channels, 64, kernel_size=3, stride=2, padding=1),
            'dilated': nn.Conv2d(channels, 64, kernel_size=3, padding=2, dilation=2),
            'grouped': nn.Conv2d(channels, 64, kernel_size=3, padding=1, groups=channels//2)
        }
        
        print("PyTorch卷积层配置:")
        for name, layer in conv_layers.items():
            output = layer(input_tensor)
            params = sum(p.numel() for p in layer.parameters())
            print(f"{name:<10}: 输入{input_tensor.shape} → 输出{output.shape}, 参数: {params}")
    
    demonstrate_pytorch_conv()

convolution_implementation_methods()

import torch
import torch.nn as nn
import torch.optim as optim

class BasicCNN(nn.Module):
    """
    基础卷积神经网络示例
    """
    def __init__(self, num_classes=10):
        super(BasicCNN, self).__init__()
        
        # 卷积层块
        self.features = nn.Sequential(
            # 第一个卷积块
            nn.Conv2d(3, 32, kernel_size=3, padding=1),  # 3×3卷积，32个输出通道
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 32, kernel_size=3, padding=1), # 3×3卷积，保持32个输出通道
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),       # 2×2最大池化
            
            # 第二个卷积块
            nn.Conv2d(32, 64, kernel_size=3, padding=1), # 64个输出通道
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            # 第三个卷积块
            nn.Conv2d(64, 128, kernel_size=3, padding=1), # 128个输出通道
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d((4, 4))  # 自适应平均池化到4×4
        )
        
        # 分类器
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(128 * 4 * 4, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
    
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

def compare_network_architectures():
    """
    比较全连接网络和卷积网络的参数量
    """
    # 全连接网络
    fc_net = nn.Sequential(
        nn.Flatten(),
        nn.Linear(3 * 32 * 32, 1024),
        nn.ReLU(),
        nn.Linear(1024, 512),
        nn.ReLU(),
        nn.Linear(512, 10)
    )
    
    # 卷积网络
    conv_net = BasicCNN(num_classes=10)
    
    fc_params = sum(p.numel() for p in fc_net.parameters())
    conv_params = sum(p.numel() for p in conv_net.parameters())
    
    print("网络参数量对比:")
    print(f"全连接网络参数: {fc_params:,} ({fc_params/1e6:.2f}M)")
    print(f"卷积网络参数: {conv_params:,} ({conv_params/1e6:.2f}M)")
    print(f"参数减少: {(fc_params - conv_params) / fc_params * 100:.1f}%")

compare_network_architectures()

def visualize_convolution_kernels():
    """
    卷积核的可视化和功能分析
    """
    import matplotlib.pyplot as plt
    import numpy as np
    
    # 常见的卷积核
    kernels = {
        'Edge Detection (Vertical)': np.array([[-1, 0, 1],
                                              [-2, 0, 2],
                                              [-1, 0, 1]]),
        'Edge Detection (Horizontal)': np.array([[-1, -2, -1],
                                                [ 0,  0,  0],
                                                [ 1,  2,  1]]),
        'Sharpen': np.array([[ 0, -1,  0],
                             [-1,  5, -1],
                             [ 0, -1,  0]]),
        'Gaussian Blur': (1/16) * np.array([[1, 2, 1],
                                            [2, 4, 2],
                                            [1, 2, 1]]),
        'Identity': np.array([[0, 0, 0],
                              [0, 1, 0],
                              [0, 0, 0]])
    }
    
    print("常见卷积核及其功能:")
    print("-" * 40)
    for name, kernel in kernels.items():
        print(f"{name}:")
        print(kernel)
        print()
    
    # 分析卷积核特性
    def analyze_kernel(kernel, name):
        print(f"分析 {name}:")
        print(f"  和值: {np.sum(kernel):.3f} (接近0表示边缘检测，接近1表示平滑)")
        print(f"  标准差: {np.std(kernel):.3f}")
        print(f"  范围: [{np.min(kernel):.3f}, {np.max(kernel):.3f}]")
        print()
    
    for name, kernel in kernels.items():
        analyze_kernel(kernel, name)

visualize_convolution_kernels()

def convolution_design_principles():
    """
    卷积层设计的原则和最佳实践
    """
    """
    卷积层设计原则：
    
    1. 感受野设计：
       - 逐步增大感受野以捕获更大范围的上下文信息
       - 使用多个小卷积核代替一个大卷积核
    
    2. 通道数设计：
       - 逐渐增加通道数以捕获更复杂的特征
       - 遵循2的幂次规律（32, 64, 128, 256等）
    
    3. 分辨率设计：
       - 通过池化或步长卷积降低分辨率
       - 保持参数量和计算量的平衡
    
    4. 深度设计：
       - 平衡网络深度和梯度消失问题
       - 使用残差连接等技术加深网络
    """
    
    # 不同设计理念的网络结构
    class ShallowWideNet(nn.Module):
        """浅而宽的网络设计"""
        def __init__(self):
            super().__init__()
            self.conv1 = nn.Conv2d(3, 128, kernel_size=7, padding=3)  # 大卷积核
            self.pool = nn.MaxPool2d(2)
            self.conv2 = nn.Conv2d(128, 256, kernel_size=5, padding=2)
            self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
            self.classifier = nn.Linear(256, 10)
        
        def forward(self, x):
            x = self.pool(torch.relu(self.conv1(x)))
            x = self.global_pool(torch.relu(self.conv2(x)))
            x = x.view(x.size(0), -1)
            x = self.classifier(x)
            return x
    
    class DeepNarrowNet(nn.Module):
        """深而窄的网络设计"""
        def __init__(self):
            super().__init__()
            layers = []
            in_channels = 3
            channels = [32, 64, 128, 256]
            
            for ch in channels:
                layers.extend([
                    nn.Conv2d(in_channels, ch, kernel_size=3, padding=1),
                    nn.ReLU(inplace=True),
                    nn.Conv2d(ch, ch, kernel_size=3, padding=1),
                    nn.ReLU(inplace=True),
                    nn.MaxPool2d(2)
                ])
                in_channels = ch
            
            self.features = nn.Sequential(*layers)
            self.classifier = nn.Linear(256, 10)
        
        def forward(self, x):
            x = self.features(x)
            x = nn.functional.adaptive_avg_pool2d(x, (1, 1))
            x = x.view(x.size(0), -1)
            x = self.classifier(x)
            return x
    
    # 参数对比
    shallow_net = ShallowWideNet()
    deep_net = DeepNarrowNet()
    
    shallow_params = sum(p.numel() for p in shallow_net.parameters())
    deep_params = sum(p.numel() for p in deep_net.parameters())
    
    print("网络设计对比:")
    print(f"浅宽网络参数: {shallow_params:,}")
    print(f"深窄网络参数: {deep_params:,}")
    print("现代CNN倾向于使用更深更窄的设计以获得更好的特征层次化表示")

convolution_design_principles()

class EfficientConvNet(nn.Module):
    """
    高效卷积网络设计
    """
    def __init__(self, num_classes=10, input_channels=3):
        super(EfficientConvNet, self).__init__()
        
        # 使用深度可分离卷积减少参数
        def depthwise_separable_conv(in_channels, out_channels, stride=1):
            return nn.Sequential(
                # 深度卷积：每个输入通道单独卷积
                nn.Conv2d(in_channels, in_channels, kernel_size=3, 
                         stride=stride, padding=1, groups=in_channels, bias=False),
                nn.BatchNorm2d(in_channels),
                nn.ReLU(inplace=True),
                # 点卷积：1×1卷积组合特征
                nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
                nn.BatchNorm2d(out_channels),
                nn.ReLU(inplace=True)
            )
        
        self.features = nn.Sequential(
            # 初始卷积
            nn.Conv2d(input_channels, 32, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            
            # 深度可分离卷积块
            depthwise_separable_conv(32, 64),
            depthwise_separable_conv(64, 128, stride=2),
            depthwise_separable_conv(128, 128),
            depthwise_separable_conv(128, 256, stride=2),
            depthwise_separable_conv(256, 256),
            depthwise_separable_conv(256, 512, stride=2),
            
            nn.AdaptiveAvgPool2d((1, 1))
        )
        
        self.classifier = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(512, num_classes)
        )
    
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

def efficiency_comparison():
    """
    效率对比分析
    """
    standard_net = BasicCNN(num_classes=10)
    efficient_net = EfficientConvNet(num_classes=10)
    
    standard_params = sum(p.numel() for p in standard_net.parameters())
    efficient_params = sum(p.numel() for p in efficient_net.parameters())
    
    print("效率对比分析:")
    print(f"标准CNN参数: {standard_params:,} ({standard_params/1e6:.2f}M)")
    print(f"高效CNN参数: {efficient_params:,} ({efficient_params/1e6:.2f}M)")
    print(f"参数减少: {(standard_params - efficient_params) / standard_params * 100:.1f}%")
    
    # 计算FLOPs（近似）
    def count_flops(model, input_size=(1, 3, 32, 32)):
        from torchprofile import profile_macs
        macs = profile_macs(model, torch.randn(input_size))
        return macs
    
    print("FLOPs对比（需要安装torchprofile）:")
    print("高效设计在保持性能的同时显著减少了参数和计算量")

efficiency_comparison()