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

"""
全连接层（Fully Connected Layer）简洁计算流程：

输入形状：(H, W, C)  →  展平为长度 n = H*W*C 的向量 x_flat
权重 W 形状：(m, n)  偏置 b 形状：(m,)
输出 y = W @ x_flat + b，形状为 (m,)
"""

import torch
import torch.nn as nn

def count_fc_params(image_h, image_w, image_c, hidden_dims=1000):
    """计算全连接层单隐层的参数量"""
    flat_dim = image_h * image_w * image_c
    # 权重参数量 + 偏置参数量
    return flat_dim * hidden_dims + hidden_dims

# 对比常用图像尺寸（单隐层到 1000 神经元）
image_configs = [
    ("MNIST (28×28×1)", 28, 28, 1),
    ("CIFAR-10 (32×32×3)", 32, 32, 3),
    ("ImageNet (224×224×3)", 224, 224, 3)
]

print("全连接层参数爆炸演示：")
print("-" * 60)
for name, h, w, c in image_configs:
    params = count_fc_params(h, w, c)
    print(f"{name:<25} → 参数量: {params:>13,} ({params/1e6:.2f}M)")

"""
局部连接参数量计算示例：
对比 224×224×3 图像，输出 1000 个结果的情况：
- 全连接：150.53M 参数
- 局部连接（假设每个输出只连接 3×3×3 的窗口）：3×3×3×1000 = 27,000 参数
直接减少了 5000 多倍！
"""

import torch
import torch.nn as nn

def count_conv_params(in_channels, out_channels, kernel_size=3):
    """计算卷积层的参数量"""
    # 卷积核权重：out_channels × in_channels × kernel_size × kernel_size
    # 偏置：out_channels
    return out_channels * in_channels * kernel_size**2 + out_channels

# 对比全连接和卷积（以 CIFAR-10 预处理为例）
fc_params = count_fc_params(32, 32, 3, 64)
conv_params = count_conv_params(3, 64, 3)

print("全连接 vs 卷积参数对比（CIFAR-10 → 64 特征）：")
print("-" * 70)
print(f"全连接单隐层: {fc_params:>13,} ({fc_params/1e6:.2f}M)")
print(f"3×3 卷积层:   {conv_params:>13,} ({conv_params/1e6:.2f}M)")
print(f"参数减少比例:   {(1 - conv_params/fc_params)*100:.1f}%")

import torch

def simple_cross_corr(input_img, kernel):
    """简化的 2D 互相关实现（演示用）"""
    h, w = input_img.shape
    kh, kw = kernel.shape
    oh, ow = h - kh + 1, w - kw + 1  # 输出尺寸
    output = torch.zeros(oh, ow)
    
    for i in range(oh):
        for j in range(ow):
            # 提取输入的局部窗口
            window = input_img[i:i+kh, j:j+kw]
            # 对应元素相乘再求和（内积）
            output[i, j] = (window * kernel).sum()
    return output

# 示例：用 Sobel 核检测竖边
input_img = torch.tensor([
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0]
], dtype=torch.float32)

sobel_vertical = torch.tensor([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
], dtype=torch.float32)

output = simple_cross_corr(input_img, sobel_vertical)
print("Sobel 竖边检测结果：")
print(output)

import torch
import torch.nn as nn

# 极简全连接网络
class SimpleFC(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Flatten(),
            nn.Linear(3*32*32, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )
    
    def forward(self, x):
        return self.layers(x)

# 极简卷积网络
class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.AdaptiveAvgPool2d((1,1))  # 全局池化到 1×1
        )
        self.classifier = nn.Linear(64, 10)
    
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        return self.classifier(x)

# 参数量对比
fc_net = SimpleFC()
cnn_net = SimpleCNN()
fc_params = sum(p.numel() for p in fc_net.parameters())
cnn_params = sum(p.numel() for p in cnn_net.parameters())

print("极简网络参数量对比（CIFAR-10 → 10 类）：")
print("-" * 60)
print(f"极简全连接: {fc_params:>13,} ({fc_params/1e6:.2f}M)")
print(f"极简 CNN:   {cnn_params:>13,} ({cnn_params/1e6:.2f}M)")
print(f"参数减少:     {(1 - cnn_params/fc_params)*100:.1f}%")