#经典CNN架构剖析：LeNet到DenseNet的里程碑演进与核心创新

"""
LeNet-5架构详解：

输入层 (32×32) → C1卷积层(6个5×5核) → S2池化层 → C3卷积层(16个5×5核) → S4池化层 → C5全连接卷积层 → F6全连接层 → 输出层

核心创新：
- 首次引入卷积层和池化层
- 参数共享机制
- 局部连接特性
"""

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

class LeNet5(nn.Module):
    """
    LeNet-5网络实现
    """
    def __init__(self, num_classes=10):
        super(LeNet5, self).__init__()
        
        # C1: 卷积层 - 6个5×5卷积核
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
        # S2: 平均池化层 - 2×2窗口
        self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C3: 卷积层 - 16个5×5卷积核
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
        # S4: 平均池化层 - 2×2窗口
        self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C5: 全连接卷积层 - 120个5×5卷积核
        self.conv3 = nn.Conv2d(16, 120, kernel_size=5)
        # F6: 全连接层 - 84个神经元
        self.fc1 = nn.Linear(120, 84)
        # 输出层 - 10个神经元（对应10个数字类别）
        self.fc2 = nn.Linear(84, num_classes)
        
        # 激活函数
        self.tanh = nn.Tanh()
    
    def forward(self, x):
        # C1: 卷积 + 激活
        x = self.tanh(self.conv1(x))
        # S2: 池化
        x = self.pool1(x)
        # C3: 卷积 + 激活
        x = self.tanh(self.conv2(x))
        # S4: 池化
        x = self.pool2(x)
        # C5: 卷积 + 激活
        x = self.tanh(self.conv3(x))
        # 展平
        x = x.view(x.size(0), -1)
        # F6: 全连接 + 激活
        x = self.tanh(self.fc1(x))
        # 输出层
        x = self.fc2(x)
        return x

def analyze_lenet_architecture():
    """
    分析LeNet架构特点
    """
    print("LeNet-5架构分析:")
    print("输入: 32×32灰度图像")
    print("C1: 6×(5×5)+1=151参数")
    print("S2: 2×2平均池化")
    print("C3: 16×6×(5×5)+1=2,401参数") 
    print("S4: 2×2平均池化")
    print("C5: 120×16×(5×5)+1=48,001参数")
    print("F6: 120×84+84=10,164参数")
    print("Output: 84×10+10=850参数")
    print("总参数量: ~61,567")

analyze_lenet_architecture()

def lenet_innovations():
    """
    LeNet的核心创新点分析
    """
    """
    1. 卷积层（Convolutional Layer）：
       - 参数共享机制
       - 局部连接特性
       - 平移不变性
    
    2. 池化层（Pooling Layer）：
       - 特征降维
       - 平移不变性增强
       - 参数减少
    
    3. 层次化特征提取：
       - 低层提取边缘特征
       - 高层提取抽象特征
    """
    
    # LeNet对现代CNN的影响
    modern_impact = {
        "Architecture": "奠定了CNN基础架构",
        "Parameter Sharing": "启发了现代参数共享机制", 
        "Hierarchical Features": "奠定了特征层次化思想",
        "Local Connectivity": "启发了现代局部连接设计"
    }
    
    print("LeNet对现代CNN的影响:")
    for key, value in modern_impact.items():
        print(f"  {key}: {value}")

lenet_innovations()

"""
AlexNet架构详解：

输入: 224×224 RGB图像
特征提取部分:
  Conv1: 96个11×11卷积核，步长4
  MaxPool1: 3×3窗口，步长2
  Conv2: 256个5×5卷积核，分组卷积
  MaxPool2: 3×3窗口，步长2
  Conv3: 384个3×3卷积核
  Conv4: 384个3×3卷积核，分组卷积
  Conv5: 256个3×3卷积核，分组卷积
  MaxPool3: 3×3窗口，步长2
分类部分:
  FC1: 4096个神经元
  FC2: 4096个神经元
  FC3: 1000个神经元（ImageNet类别数）

关键创新：
- 使用ReLU激活函数
- 引入Dropout正则化
- 使用GPU加速训练
- 数据增强技术
- 重叠池化
"""

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    """
    AlexNet网络实现
    """
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        
        # 特征提取部分
        self.features = nn.Sequential(
            # Conv1: 96个11×11卷积核，步长4
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            # MaxPool1: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv2: 256个5×5卷积核（原论文为256个5×5，这里简化为64）
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            # MaxPool2: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv3: 384个3×3卷积核
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv4: 384个3×3卷积核
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv5: 256个3×3卷积核
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            # MaxPool3: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        
        # 自适应平均池化
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        
        # 分类器部分
        self.classifier = nn.Sequential(
            # Dropout: 丢弃率0.5
            nn.Dropout(p=0.5),
            # FC1: 4096个神经元
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            # Dropout: 丢弃率0.5
            nn.Dropout(p=0.5),
            # FC2: 4096个神经元
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            # FC3: 1000个神经元
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

def alexnet_analysis():
    """
    AlexNet架构分析
    """
    print("AlexNet关键创新:")
    print("1. ReLU激活函数: 解决梯度消失问题，加速训练")
    print("2. Dropout正则化: 防止过拟合")
    print("3. GPU并行计算: 使用2个GPU训练")
    print("4. 重叠池化: 3×3窗口，步长2（原尺寸为3×3，步长2）")
    print("5. 数据增强: 随机裁剪、颜色扰动")
    print("6. 局部响应归一化(LRN): 增强泛化能力")

alexnet_analysis()

def alexnet_technical_innovations():
    """
    AlexNet技术创新详解
    """
    """
    1. ReLU激活函数：
       - f(x) = max(0, x)
       - 解决梯度消失问题
       - 训练速度比tanh和sigmoid快
    
    2. Dropout正则化：
       - 训练时随机丢弃神经元
       - 防止过拟合
       - 提高泛化能力
    
    3. 数据增强：
       - 随机裁剪256×256→224×224
       - 水平翻转
       - PCA颜色扰动
    
    4. LRN（局部响应归一化）：
       - 仿照生物神经网络侧抑制机制
       - 增强泛化能力
    """
    
    # ReLU vs 其他激活函数对比
    import numpy as np
    import matplotlib.pyplot as plt
    
    x = np.linspace(-5, 5, 100)
    relu = np.maximum(0, x)
    sigmoid = 1 / (1 + np.exp(-x))
    tanh = np.tanh(x)
    
    print("激活函数对比:")
    print("ReLU: 计算简单，梯度恒为1（x>0），无饱和区")
    print("Sigmoid: 易饱和，梯度消失，输出非零中心")
    print("Tanh: 零中心，但仍有饱和问题")
    
    # 计算复杂度分析
    def calculate_complexity():
        """
        计算AlexNet参数量
        """
        conv1_params = 11 * 11 * 3 * 96 + 96  # 96个11×11×3卷积核
        conv2_params = 5 * 5 * 96 * 256 + 256  # 256个5×5×96卷积核
        conv3_params = 3 * 3 * 256 * 384 + 384  # 384个3×3×256卷积核
        conv4_params = 3 * 3 * 384 * 384 + 384  # 384个3×3×384卷积核
        conv5_params = 3 * 3 * 384 * 256 + 256  # 256个3×3×384卷积核
        
        fc1_params = 9216 * 4096 + 4096  # 4096个神经元（6×6×256=9216）
        fc2_params = 4096 * 4096 + 4096  # 4096个神经元
        fc3_params = 4096 * 1000 + 1000  # 1000个神经元
        
        total_params = (conv1_params + conv2_params + conv3_params + 
                       conv4_params + conv5_params + fc1_params + 
                       fc2_params + fc3_params)
        
        print(f"AlexNet参数量分析:")
        print(f"  Conv1: {conv1_params:,} 参数")
        print(f"  Conv2: {conv2_params:,} 参数")
        print(f"  Conv3: {conv3_params:,} 参数")
        print(f"  Conv4: {conv4_params:,} 参数")
        print(f"  Conv5: {conv5_params:,} 参数")
        print(f"  FC1: {fc1_params:,} 参数")
        print(f"  FC2: {fc2_params:,} 参数")
        print(f"  FC3: {fc3_params:,} 参数")
        print(f"  总计: {total_params:,} 参数 (~60M)")

calculate_complexity()

alexnet_technical_innovations()

"""
VGGNet架构特点：

统一性设计：
- 所有卷积层使用3×3卷积核
- 所有池化层使用2×2窗口，步长2
- 通道数随深度翻倍

深度版本：
- VGG-11: 8个卷积层 + 3个全连接层
- VGG-13: 10个卷积层 + 3个全连接层  
- VGG-16: 13个卷积层 + 3个全连接层
- VGG-19: 16个卷积层 + 3个全连接层

核心思想：
- 两个3×3卷积核的感受野 = 一个5×5卷积核
- 三个3×3卷积核的感受野 = 一个7×7卷积核
- 参数更少，非线性更强
"""

import torch
import torch.nn as nn

class VGG(nn.Module):
    """
    VGG网络实现
    """
    def __init__(self, features, num_classes=1000, init_weights=True):
        super(VGG, self).__init__()
        self.features = features
        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

def make_layers(cfg, batch_norm=False):
    """
    根据配置创建VGG层
    """
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)

# VGG配置
cfgs = {
    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],  # VGG-11
    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],  # VGG-13
    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],  # VGG-16
    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],  # VGG-19
}

def vgg16(pretrained=False, **kwargs):
    """
    VGG-16网络
    """
    if pretrained:
        kwargs['init_weights'] = False
    model = VGG(make_layers(cfgs['D']), **kwargs)
    return model

def vgg_innovation_analysis():
    """
    VGG创新点分析
    """
    print("VGGNet核心创新:")
    print("1. 统一架构设计: 全部使用3×3卷积核")
    print("2. 深度堆叠: 证明深度对性能的重要性")
    print("3. 感受野等价: 两个3×3 = 一个5×5感受野")
    print("4. 参数效率: 小卷积核堆叠比大卷积核参数少")
    print("5. 特征层次化: 从边缘→纹理→物体部件→整体物体")

vgg_innovation_analysis()

def vgg_advantages():
    """
    VGGNet架构优势分析
    """
    """
    1. 架构统一性：
       - 所有卷积层使用3×3核
       - 简化设计和理解
       - 易于扩展和修改
    
    2. 参数效率：
       - 两个3×3卷积核参数 = 2×(3×3) = 18
       - 一个5×5卷积核参数 = 5×5 = 25
       - 参数减少28%，非线性增加
    
    3. 感受野计算：
       - n个3×3卷积核串联 = (3-1)×n + 1 = 2n+1 感受野
       - 两个3×3 = 5感受野
       - 三个3×3 = 7感受野
    
    4. 梯度传播：
       - 更多非线性激活
       - 梯度传播路径更长
       - 表达能力更强
    """
    
    # 参数对比计算
    def compare_convolution_params():
        """
        对比不同卷积核的参数量
        """
        print("卷积核参数量对比:")
        
        # 一个5×5卷积核
        conv_5x5_params = 5 * 5 + 1  # 26 (含偏置)
        print(f"单个5×5卷积核: {conv_5x5_params} 参数")
        
        # 两个3×3卷积核
        conv_3x3_twice_params = 2 * (3 * 3 + 1)  # 20 (含偏置)
        print(f"两个3×3卷积核: {conv_3x3_twice_params} 参数")
        
        # 三个3×3卷积核
        conv_3x3_triple_params = 3 * (3 * 3 + 1)  # 30 (含偏置)
        print(f"三个3×3卷积核: {conv_3x3_triple_params} 参数")
        
        print(f"参数节省: {(conv_5x5_params - conv_3x3_twice_params) / conv_5x5_params * 100:.1f}%")
    
    compare_convolution_params()

vgg_advantages()

"""
ResNet核心创新：残差学习

传统网络：y = F(x)
残差网络：y = F(x) + x

其中F(x)是残差函数，学习的是输入x到期望输出的差异
如果理想输出就是输入x，则F(x)=0，网络自动学习恒等映射

残差块类型：
1. 基础残差块：用于较浅网络
2. 瓶颈残差块：用于较深网络
"""

import torch
import torch.nn as nn

class BasicBlock(nn.Module):
    """
    基础残差块（用于ResNet-18, ResNet-34）
    """
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

class Bottleneck(nn.Module):
    """
    瓶颈残差块（用于ResNet-50, ResNet-101, ResNet-152）
    """
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

class ResNet(nn.Module):
    """
    ResNet网络
    """
    def __init__(self, block, layers, num_classes=1000):
        super(ResNet, self).__init__()
        self.inplanes = 64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)

    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x

def resnet18(**kwargs):
    """
    ResNet-18
    """
    return ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)

def resnet50(**kwargs):
    """
    ResNet-50
    """
    return ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)

def resnet_innovation_explanation():
    """
    ResNet创新点详解
    """
    print("ResNet核心创新:")
    print("1. 残差连接: 解决梯度消失和网络退化")
    print("2. 恒等映射: 简化学习目标")
    print("3. 深度可扩展: 支持数百层网络")
    print("4. 批归一化: 稳定训练过程")

resnet_innovation_explanation()

def residual_learning_math():
    """
    残差学习的数学原理解析
    """
    """
    网络退化问题：
    理论上更深的网络应该至少不比浅层网络差
    但实际上训练误差反而增加
    
    残差学习解决方案：
    假设期望输出为H(x)，直接学习H(x)困难
    转为学习残差F(x) = H(x) - x
    网络输出为y = F(x) + x
    
    优势：
    1. 如果最优解是恒等映射H(x)=x，则F(x)=0，容易学习
    2. 梯度可以直接回传到浅层
    3. 网络可以选择性地学习有用的特征变换
    """
    
    # 梯度分析
    print("梯度传播分析:")
    print("传统网络: ∂L/∂x = ∂L/∂y * ∂y/∂x")
    print("残差网络: ∂L/∂x = ∂L/∂y * (∂F/∂x + 1)")
    print("残差网络确保梯度不会消失（至少有恒等映射路径）")

residual_learning_math()

"""
DenseNet核心创新：密集连接

传统网络：x(l+1) = Hl(x(l))
DenseNet：x(l+1) = Hl([x(0), x(1), ..., x(l)])

其中[x(0), x(1), ..., x(l)]表示特征图的拼接
Hl表示复合函数（BN-ReLU-Conv）

核心优势：
1. 最大化信息流动
2. 特征重用
3. 减少参数数量
4. 缓解梯度消失
"""

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

class _DenseLayer(nn.Sequential):
    """
    DenseNet层
    """
    def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
        super(_DenseLayer, self).__init__()
        self.add_module('norm1', nn.BatchNorm2d(num_input_features)),
        self.add_module('relu1', nn.ReLU(inplace=True)),
        self.add_module('conv1', nn.Conv2d(num_input_features, bn_size *
                                           growth_rate, kernel_size=1, stride=1,
                                           bias=False)),
        self.add_module('norm2', nn.BatchNorm2d(bn_size * growth_rate)),
        self.add_module('relu2', nn.ReLU(inplace=True)),
        self.add_module('conv2', nn.Conv2d(bn_size * growth_rate, growth_rate,
                                           kernel_size=3, stride=1, padding=1,
                                           bias=False)),
        self.drop_rate = drop_rate

    def forward(self, x):
        new_features = super(_DenseLayer, self).forward(x)
        if self.drop_rate > 0:
            new_features = F.dropout(new_features, p=self.drop_rate,
                                   training=self.training)
        return torch.cat([x, new_features], 1)

class _DenseBlock(nn.Sequential):
    """
    DenseNet块
    """
    def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate):
        super(_DenseBlock, self).__init__()
        for i in range(num_layers):
            layer = _DenseLayer(num_input_features + i * growth_rate,
                               growth_rate, bn_size, drop_rate)
            self.add_module('denselayer%d' % (i + 1), layer)

class _Transition(nn.Sequential):
    """
    过渡层
    """
    def __init__(self, num_input_features, num_output_features):
        super(_Transition, self).__init__()
        self.add_module('norm', nn.BatchNorm2d(num_input_features))
        self.add_module('relu', nn.ReLU(inplace=True))
        self.add_module('conv', nn.Conv2d(num_input_features, num_output_features,
                                          kernel_size=1, stride=1, bias=False))
        self.add_module('pool', nn.AvgPool2d(kernel_size=2, stride=2))

class DenseNet(nn.Module):
    """
    DenseNet网络
    """
    def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
                 num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000):
        super(DenseNet, self).__init__()

        # 初始卷积层
        self.features = nn.Sequential(OrderedDict([
            ('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2,
                                padding=3, bias=False)),
            ('norm0', nn.BatchNorm2d(num_init_features)),
            ('relu0', nn.ReLU(inplace=True)),
            ('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
        ]))

        # Dense blocks
        num_features = num_init_features
        for i, num_layers in enumerate(block_config):
            block = _DenseBlock(num_layers=num_layers,
                               num_input_features=num_features,
                               bn_size=bn_size,
                               growth_rate=growth_rate,
                               drop_rate=drop_rate)
            self.features.add_module('denseblock%d' % (i + 1), block)
            num_features = num_features + num_layers * growth_rate
            if i != len(block_config) - 1:
                trans = _Transition(num_input_features=num_features,
                                   num_output_features=num_features // 2)
                self.features.add_module('transition%d' % (i + 1), trans)
                num_features = num_features // 2

        # Final batch norm
        self.features.add_module('norm5', nn.BatchNorm2d(num_features))

        # Linear layer
        self.classifier = nn.Linear(num_features, num_classes)

        # Official init from torch repo.
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.constant_(m.bias, 0)

    def forward(self, x):
        features = self.features(x)
        out = F.relu(features, inplace=True)
        out = F.adaptive_avg_pool2d(out, (1, 1))
        out = torch.flatten(out, 1)
        out = self.classifier(out)
        return out

def densenet_innovation_analysis():
    """
    DenseNet创新点分析
    """
    print("DenseNet核心创新:")
    print("1. 密集连接: 每层连接到后续所有层")
    print("2. 特征重用: 最大化特征利用率")
    print("3. 参数效率: 减少参数数量")
    print("4. 梯度流动: 缓解梯度消失问题")
    print("5. 特征传播: 促进信息流动")

densenet_innovation_analysis()

def architecture_comparison():
    """
    经典CNN架构对比分析
    """
    architectures = {
        "LeNet": {
            "Year": 1998,
            "Depth": 5,
            "Params": "60K",
            "Key Innovation": "CNN基础架构",
            "Use Case": "手写数字识别"
        },
        "AlexNet": {
            "Year": 2012,
            "Depth": 8,
            "Params": "60M", 
            "Key Innovation": "ReLU, Dropout, GPU",
            "Use Case": "ImageNet竞赛突破"
        },
        "VGG": {
            "Year": 2014,
            "Depth": 16-19,
            "Params": "138M",
            "Key Innovation": "统一架构, 小卷积核",
            "Use Case": "特征提取骨干网"
        },
        "ResNet": {
            "Year": 2015,
            "Depth": 50-152,
            "Params": "25M",
            "Key Innovation": "残差连接",
            "Use Case": "深度网络训练"
        },
        "DenseNet": {
            "Year": 2016,
            "Depth": 121-201,
            "Params": "8M",
            "Key Innovation": "密集连接",
            "Use Case": "特征重用优化"
        }
    }
    
    print("经典CNN架构对比:")
    print(f"{'架构':<10} {'年份':<6} {'深度':<8} {'参数量':<10} {'核心创新':<20} {'应用场景':<15}")
    print("-" * 80)
    for name, info in architectures.items():
        print(f"{name:<10} {info['Year']:<6} {info['Depth']:<8} {info['Params']:<10} {info['Key Innovation']:<20} {info['Use Case']:<15}")

architecture_comparison()

def architectural_evolution_insights():
    """
    CNN架构演进的深层洞察
    """
    """
    1. 从浅到深：
       - LeNet: 5层
       - AlexNet: 8层  
       - VGG: 16-19层
       - ResNet: 50-152层
       - DenseNet: 121-201层
    
    2. 从大核到小核：
       - LeNet/AlexNet: 大卷积核
       - VGG+: 小卷积核堆叠
    
    3. 从直连到跳连：
       - 传统网络: 逐层直连
       - ResNet: 残差连接
       - DenseNet: 密集连接
    
    4. 从单一到复合：
       - 基础卷积+池化
       + 批归一化+激活+正则化
    """
    
    # 每个时代解决的核心问题
    era_problems = {
        "1998-2012": "证明CNN可行性",
        "2012-2014": "解决训练深度网络",
        "2014-2015": "优化网络深度利用", 
        "2015-2016": "解决梯度消失退化",
        "2016-至今": "最大化特征利用"
    }
    
    print("CNN架构演进解决的核心问题:")
    for era, problem in era_problems.items():
        print(f"  {era}: {problem}")

architectural_evolution_insights()

def modern_practice_recommendations():
    """
    2026年现代CNN实践建议
    """
    """
    任务导向架构选择：
    
    1. 图像分类：
       - 预训练ResNet: 平衡性能和效率
       - EfficientNet: 参数效率最优
       - Vision Transformer: 最新SOTA
    
    2. 目标检测：
       - ResNet: 作为骨干网络
       - CSPDarknet: YOLO系列
       - Swin Transformer: 最新架构
    
    3. 实时应用：
       - MobileNet: 移动端优化
       - ShuffleNet: 计算受限场景
       - EfficientNet: 平衡精度效率
    
    4. 研究前沿：
       - Vision Transformer: 注意力机制
       - ConvNeXt: 纯卷积现代化
       - Swin Transformer: 层次化设计
    """
    
    # 实践建议总结
    recommendations = [
        "1. 优先使用预训练模型进行迁移学习",
        "2. 根据硬件资源选择合适的模型大小",
        "3. 考虑模型压缩和量化技术",
        "4. 关注最新的架构创新",
        "5. 结合任务特点选择最优架构"
    ]
    
    print("2026年CNN实践建议:")
    for rec in recommendations:
        print(f"  {rec}")

modern_practice_recommendations()