import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import torchvision.transforms as transforms

class DeepLearningFoundation:
    def __init__(self):
        self.learning_paradigms = {
            "传统机器学习": {
                "特征工程": "手工设计特征",
                "模型": "浅层模型（SVM、决策树等）",
                "优点": ["可解释性强", "训练快速", "数据需求少"],
                "缺点": ["特征设计困难", "表达能力有限", "泛化能力差"]
            },
            "深度学习": {
                "特征工程": "自动学习特征表示",
                "模型": "多层神经网络",
                "优点": ["端到端学习", "强大表达能力", "自动特征提取"],
                "缺点": ["需要大量数据", "计算资源消耗大", "黑盒模型"]
            }
        }
    
    def compare_paradigms(self):
        """比较学习范式"""
        print("机器学习范式比较:")
        print("=" * 50)
        
        for paradigm, details in self.learning_paradigms.items():
            print(f"\n{paradigm}:")
            for key, value in details.items():
                if isinstance(value, list):
                    print(f"  {key}: {', '.join(value)}")
                else:
                    print(f"  {key}: {value}")
    
    def deep_learning_workflow(self):
        """深度学习工作流程"""
        workflow = {
            "1. 数据准备": [
                "数据收集和清理",
                "数据增强和预处理",
                "训练/验证/测试集划分"
            ],
            "2. 模型设计": [
                "网络架构设计",
                "损失函数选择",
                "优化器配置"
            ],
            "3. 模型训练": [
                "前向传播",
                "损失计算",
                "反向传播",
                "参数更新"
            ],
            "4. 模型评估": [
                "验证集性能评估",
                "过拟合检测",
                "超参数调优"
            ],
            "5. 模型部署": [
                "模型优化",
                "推理加速",
                "生产环境部署"
            ]
        }
        
        print("\n深度学习工作流程:")
        print("=" * 30)
        for stage, steps in workflow.items():
            print(f"\n{stage}:")
            for step in steps:
                print(f"  - {step}")
        
        return workflow

# 示例使用
foundation = DeepLearningFoundation()
foundation.compare_paradigms()
workflow = foundation.deep_learning_workflow()

import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import matplotlib.dates as mdates

class ObjectDetectionHistory:
    def __init__(self):
        self.timeline = {
            2001: {"算法": "Viola-Jones", "类型": "传统方法", "突破": "实时人脸检测"},
            2005: {"算法": "HOG", "类型": "传统方法", "突破": "方向梯度直方图特征"},
            2008: {"算法": "DPM", "类型": "传统方法", "突破": "可变形部件模型"},
            2012: {"算法": "AlexNet", "类型": "深度学习", "突破": "CNN在图像分类上的突破"},
            2014: {"算法": "R-CNN", "类型": "两阶段", "突破": "CNN用于目标检测"},
            2015: {"算法": "Fast R-CNN", "类型": "两阶段", "突破": "端到端训练"},
            2015: {"算法": "YOLO v1", "类型": "一阶段", "突破": "实时目标检测"},
            2016: {"算法": "SSD", "类型": "一阶段", "突破": "多尺度检测"},
            2016: {"算法": "Faster R-CNN", "类型": "两阶段", "突破": "RPN网络"},
            2017: {"算法": "RetinaNet", "类型": "一阶段", "突破": "Focal Loss"},
            2017: {"算法": "Mask R-CNN", "类型": "两阶段", "突破": "实例分割"},
            2018: {"算法": "YOLO v3", "类型": "一阶段", "突破": "多尺度预测"},
            2020: {"算法": "EfficientDet", "类型": "一阶段", "突破": "高效架构设计"},
            2020: {"算法": "DETR", "类型": "Transformer", "突破": "端到端Transformer检测"}
        }
    
    def create_timeline_visualization(self):
        """创建发展时间线可视化"""
        years = list(self.timeline.keys())
        algorithms = [self.timeline[year]["算法"] for year in years]
        types = [self.timeline[year]["类型"] for year in years]
        
        # 颜色映射
        color_map = {
            "传统方法": "red",
            "深度学习": "blue", 
            "两阶段": "green",
            "一阶段": "orange",
            "Transformer": "purple"
        }
        
        colors = [color_map[t] for t in types]
        
        # 创建时间线图
        fig, ax = plt.subplots(figsize=(15, 8))
        
        # 绘制时间线
        ax.scatter(years, range(len(years)), c=colors, s=100, alpha=0.7)
        
        # 添加算法标签
        for i, (year, alg) in enumerate(zip(years, algorithms)):
            ax.annotate(f"{alg}\n({year})", 
                       (year, i),
                       xytext=(10, 0), 
                       textcoords='offset points',
                       ha='left',
                       fontsize=10,
                       bbox=dict(boxstyle='round,pad=0.3', 
                                facecolor=colors[i], 
                                alpha=0.3))
        
        # 设置图形属性
        ax.set_xlabel("年份", fontsize=12)
        ax.set_ylabel("发展阶段", fontsize=12)
        ax.set_title("目标检测算法发展时间线", fontsize=14, fontweight='bold')
        ax.grid(True, alpha=0.3)
        
        # 添加图例
        legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
                                     markerfacecolor=color, markersize=10, 
                                     label=method)
                          for method, color in color_map.items()]
        ax.legend(handles=legend_elements, loc='upper left')
        
        return fig
    
    def development_phases(self):
        """发展阶段分析"""
        phases = {
            "传统方法时代 (2001-2012)": {
                "特点": [
                    "基于手工特征设计",
                    "使用传统机器学习算法",
                    "计算效率高但精度有限"
                ],
                "代表算法": ["Viola-Jones", "HOG+SVM", "DPM"],
                "主要贡献": "建立了目标检测的基础框架"
            },
            "深度学习兴起 (2012-2014)": {
                "特点": [
                    "CNN在图像分类上的突破",
                    "为目标检测引入深度学习",
                    "开始端到端学习"
                ],
                "代表算法": ["AlexNet", "R-CNN"],
                "主要贡献": "证明了深度学习在视觉任务上的优势"
            },
            "两阶段方法完善 (2014-2017)": {
                "特点": [
                    "候选区域 + 分类回归",
                    "追求高精度",
                    "速度相对较慢"
                ],
                "代表算法": ["R-CNN", "Fast R-CNN", "Faster R-CNN", "Mask R-CNN"],
                "主要贡献": "确立了两阶段检测的标准范式"
            },
            "一阶段方法发展 (2015-2020)": {
                "特点": [
                    "端到端直接预测",
                    "追求速度与精度平衡",
                    "适合实时应用"
                ],
                "代表算法": ["YOLO", "SSD", "RetinaNet"],
                "主要贡献": "实现了实时高精度目标检测"
            },
            "新架构探索 (2020-)": {
                "特点": [
                    "Transformer架构引入",
                    "自注意力机制",
                    "端到端无锚框检测"
                ],
                "代表算法": ["DETR", "DETR系列"],
                "主要贡献": "探索新的网络架构可能性"
            }
        }
        
        print("目标检测发展阶段分析:")
        print("=" * 50)
        
        for phase, details in phases.items():
            print(f"\n{phase}:")
            print(f"  特点:")
            for feature in details["特点"]:
                print(f"    - {feature}")
            print(f"  代表算法: {', '.join(details['代表算法'])}")
            print(f"  主要贡献: {details['主要贡献']}")
        
        return phases

# 使用示例
history = ObjectDetectionHistory()

# 创建时间线图
# timeline_fig = history.create_timeline_visualization()
# plt.show()

# 发展阶段分析
phases = history.development_phases()

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt

class YOLOv1Philosophy:
    def __init__(self):
        self.core_concepts = {
            "统一检测": {
                "理念": "将目标检测重新定义为单一回归问题",
                "对比": "传统方法需要候选区域生成+分类两个步骤",
                "优势": "端到端训练，架构简单"
            },
            "全局推理": {
                "理念": "看整张图像进行预测",
                "对比": "滑动窗口只看局部信息",
                "优势": "减少背景误检，利用全局上下文"
            },
            "实时检测": {
                "理念": "单次前向传播完成检测",
                "性能": "45 FPS on Titan X",
                "意义": "首次实现实时高精度目标检测"
            },
            "网格预测": {
                "理念": "将图像分割为S×S网格",
                "责任": "每个网格负责检测中心落在其中的目标",
                "简化": "避免复杂的候选区域生成"
            }
        }
    
    def paradigm_shift(self):
        """检测范式转变分析"""
        traditional_vs_yolo = {
            "传统两阶段方法": {
                "流程": ["候选区域生成", "特征提取", "分类", "回归"],
                "优点": ["精度高", "成熟稳定"],
                "缺点": ["速度慢", "系统复杂", "优化困难"],
                "代表": "R-CNN系列"
            },
            "YOLO一阶段方法": {
                "流程": ["单一CNN", "直接输出检测结果"],
                "优点": ["速度快", "端到端", "全局优化"],
                "缺点": ["精度略低", "小目标困难"],
                "突破": "重新定义检测问题"
            }
        }
        
        print("目标检测范式转变:")
        print("=" * 40)
        
        for paradigm, details in traditional_vs_yolo.items():
            print(f"\n{paradigm}:")
            for key, value in details.items():
                if isinstance(value, list):
                    print(f"  {key}: {' -> '.join(value)}")
                else:
                    print(f"  {key}: {value}")
        
        return traditional_vs_yolo
    
    def detection_as_regression(self):
        """检测作为回归问题"""
        regression_formulation = {
            "问题重定义": {
                "输入": "H×W×3 图像",
                "输出": "S×S×(B×5+C) 张量",
                "含义": "每个网格预测B个边界框和C个类别概率"
            },
            "输出解释": {
                "边界框": "(x, y, w, h) 相对坐标",
                "置信度": "P(Object) × IoU(pred, truth)",
                "类别概率": "P(Class_i | Object)",
                "最终预测": "P(Class_i) × P(Object) × IoU"
            },
            "网格责任": {
                "原则": "目标中心所在网格负责预测该目标",
                "优势": "避免重复检测同一目标",
                "限制": "每个网格最多检测一个目标"
            }
        }
        
        print("检测作为回归问题:")
        print("=" * 30)
        
        for aspect, details in regression_formulation.items():
            print(f"\n{aspect}:")
            for key, value in details.items():
                print(f"  {key}: {value}")
        
        return regression_formulation

# 使用示例
yolo_philosophy = YOLOv1Philosophy()

# 核心概念
print("YOLO v1 核心概念:")
print("=" * 25)
for concept, details in yolo_philosophy.core_concepts.items():
    print(f"\n{concept}:")
    for key, value in details.items():
        print(f"  {key}: {value}")

# 范式转变
paradigm_comparison = yolo_philosophy.paradigm_shift()

# 回归问题重定义
regression_details = yolo_philosophy.detection_as_regression()

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class YOLOv2Improvements:
    def __init__(self):
        self.improvements = {
            "批归一化": {
                "作用": "加速收敛，提升稳定性",
                "位置": "每个卷积层后",
                "效果": "mAP提升2%，去除Dropout"
            },
            "高分辨率分类器": {
                "预训练": "448×448分类任务",
                "效果": "mAP提升4%",
                "原理": "适应高分辨率输入"
            },
            "锚框机制": {
                "思想": "预定义边界框形状",
                "数量": "5个锚框",
                "效果": "召回率从81%提升到88%"
            },
            "维度聚类": {
                "方法": "K-means聚类选择锚框",
                "距离": "1-IoU作为距离度量",
                "结果": "更适合数据集的锚框"
            },
            "直接位置预测": {
                "问题": "锚框可能出现在图像任意位置",
                "解决": "使用sigmoid约束偏移",
                "稳定": "训练更稳定"
            },
            "细粒度特征": {
                "方法": "passthrough层",
                "融合": "26×26特征与13×13特征",
                "效果": "小目标检测改善"
            },
            "多尺度训练": {
                "尺寸": "320-608像素，32像素间隔",
                "频率": "每10个batch改变尺寸",
                "泛化": "提升不同尺度泛化能力"
            }
        }
    
    def anchor_mechanism(self):
        """锚框机制详解"""
        
        class AnchorGenerator:
            def __init__(self, anchor_sizes, grid_size=13):
                self.anchor_sizes = anchor_sizes  # [(w1,h1), (w2,h2), ...]
                self.grid_size = grid_size
            
            def generate_anchors(self):
                """生成所有锚框"""
                anchors = []
                
                for i in range(self.grid_size):
                    for j in range(self.grid_size):
                        for w, h in self.anchor_sizes:
                            # 锚框中心在网格中心
                            cx = (j + 0.5) / self.grid_size
                            cy = (i + 0.5) / self.grid_size
                            
                            anchors.append([cx, cy, w, h])
                
                return np.array(anchors)
            
            def kmeans_anchors(self, boxes, k=5):
                """K-means聚类生成锚框"""
                # 提取宽高
                widths = boxes[:, 2] - boxes[:, 0]
                heights = boxes[:, 3] - boxes[:, 1]
                sizes = np.column_stack([widths, heights])
                
                # K-means聚类
                from sklearn.cluster import KMeans
                kmeans = KMeans(n_clusters=k, random_state=42)
                kmeans.fit(sizes)
                
                # 返回聚类中心作为锚框尺寸
                anchor_sizes = kmeans.cluster_centers_
                
                # 按面积排序
                areas = anchor_sizes[:, 0] * anchor_sizes[:, 1]
                sorted_indices = np.argsort(areas)
                
                return anchor_sizes[sorted_indices]
        
        # 位置预测改进
        def direct_location_prediction():
            """直接位置预测"""
            
            # YOLO v1问题：预测 (x, y) 可能不稳定
            # YOLO v2解决：预测偏移量，用sigmoid约束
            
            def predict_bbox(tx, ty, tw, th, anchor_w, anchor_h, grid_x, grid_y, grid_size):
                """
                tx, ty, tw, th: 网络预测值
                anchor_w, anchor_h: 锚框尺寸
                grid_x, grid_y: 网格坐标
                """
                # 中心点预测（sigmoid约束在网格内）
                bx = torch.sigmoid(tx) + grid_x
                by = torch.sigmoid(ty) + grid_y
                
                # 宽高预测（指数变换）
                bw = anchor_w * torch.exp(tw)
                bh = anchor_h * torch.exp(th)
                
                # 归一化到[0,1]
                bx = bx / grid_size
                by = by / grid_size
                
                return bx, by, bw, bh
            
            return predict_bbox
        
        print("YOLO v2 锚框机制:")
        print("=" * 25)
        
        # 示例锚框生成
        anchor_sizes = [(1.3221, 1.73145), (3.19275, 4.00944), (5.05587, 8.09892), 
                       (9.47112, 4.84053), (11.2364, 10.0071)]
        
        anchor_gen = AnchorGenerator(anchor_sizes)
        anchors = anchor_gen.generate_anchors()
        
        print(f"锚框数量: {len(anchors)}")
        print(f"前5个锚框: {anchors[:5]}")
        
        return AnchorGenerator, direct_location_prediction()
    
    def passthrough_layer(self):
        """Passthrough层实现"""
        
        class PassthroughLayer(nn.Module):
            def __init__(self, stride=2):
                super(PassthroughLayer, self).__init__()
                self.stride = stride
            
            def forward(self, x):
                """
                将26×26×512的特征图重新组织为13×13×2048
                """
                batch_size, channels, height, width = x.size()
                
                # 确保尺寸可以被stride整除
                assert height % self.stride == 0 and width % self.stride == 0
                
                new_height = height // self.stride
                new_width = width // self.stride
                
                # 重新组织张量
                x = x.view(batch_size, channels, new_height, self.stride, new_width, self.stride)
                x = x.permute(0, 1, 3, 5, 2, 4).contiguous()
                x = x.view(batch_size, channels * self.stride * self.stride, new_height, new_width)
                
                return x
        
        # 特征融合示例
        def feature_fusion_example():
            """特征融合示例"""
            
            # 高分辨率特征（26×26×512）
            high_res_feat = torch.randn(1, 512, 26, 26)
            
            # 低分辨率特征（13×13×1024）
            low_res_feat = torch.randn(1, 1024, 13, 13)
            
            # Passthrough层
            passthrough = PassthroughLayer(stride=2)
            transformed_feat = passthrough(high_res_feat)
            
            print(f"高分辨率特征: {high_res_feat.shape}")
            print(f"Passthrough后: {transformed_feat.shape}")
            print(f"低分辨率特征: {low_res_feat.shape}")
            
            # 特征融合
            fused_feat = torch.cat([low_res_feat, transformed_feat], dim=1)
            print(f"融合后特征: {fused_feat.shape}")
            
            return fused_feat
        
        return PassthroughLayer, feature_fusion_example
    
    def multi_scale_training(self):
        """多尺度训练"""
        
        class MultiScaleTraining:
            def __init__(self, min_size=320, max_size=608, step=32):
                self.min_size = min_size
                self.max_size = max_size
                self.step = step
                self.scales = list(range(min_size, max_size + step, step))
                self.current_scale = 416  # 默认尺寸
            
            def get_random_scale(self):
                """随机选择训练尺寸"""
                return np.random.choice(self.scales)
            
            def resize_batch(self, images, targets, new_size):
                """调整batch尺寸"""
                # 图像尺寸调整
                resized_images = F.interpolate(images, size=(new_size, new_size), 
                                             mode='bilinear', align_corners=False)
                
                # 目标坐标调整
                scale_factor = new_size / images.size(-1)
                
                if targets is not None:
                    # 假设targets格式为 [batch_idx, class, x, y, w, h]
                    targets[:, 2:] *= scale_factor
                
                return resized_images, targets
            
            def training_step(self, model, images, targets, step_count):
                """训练步骤（包含尺寸调整）"""
                
                # 每10个batch调整一次尺寸
                if step_count % 10 == 0:
                    self.current_scale = self.get_random_scale()
                    print(f"切换到尺寸: {self.current_scale}")
                
                # 调整输入尺寸
                resized_images, resized_targets = self.resize_batch(
                    images, targets, self.current_scale)
                
                # 模型前向传播
                outputs = model(resized_images)
                
                return outputs, resized_targets
        
        multi_scale_benefits = {
            "鲁棒性": "适应不同尺寸的输入",
            "泛化能力": "提升在不同分辨率下的性能",
            "实用性": "同一模型适用于多种应用场景",
            "效率": "可根据精度要求调整推理尺寸"
        }
        
        print("多尺度训练优势:")
        print("=" * 20)
        for benefit, desc in multi_scale_benefits.items():
            print(f"  {benefit}: {desc}")
        
        return MultiScaleTraining, multi_scale_benefits

# 使用示例
yolo_v2 = YOLOv2Improvements()

print("YOLO v2 主要改进:")
print("=" * 25)
for improvement, details in yolo_v2.improvements.items():
    print(f"\n{improvement}:")
    for key, value in details.items():
        print(f"  {key}: {value}")

# 锚框机制
AnchorGenerator, bbox_prediction = yolo_v2.anchor_mechanism()

# Passthrough层
PassthroughLayer, feature_fusion = yolo_v2.passthrough_layer()

# 多尺度训练
MultiScaleTraining, benefits = yolo_v2.multi_scale_training()

# 演示特征融合
print("\n特征融合演示:")
print("-" * 15)
fused_features = feature_fusion()

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

class YOLOv6Features:
    """YOLO v6特性分析"""
    
    def __init__(self):
        self.key_innovations = {
            "骨干网络": "EfficientRep - 高效重参数化设计",
            "颈部网络": "Rep-PAN - 重参数化路径聚合网络", 
            "检测头": "Efficient Decoupled Head - 高效解耦头",
            "训练策略": "Self-Distillation - 自蒸馏训练",
            "锚框策略": "Anchor-free + SimOTA标签分配",
            "损失函数": "VFL + DFL + GIoU Loss组合"
        }
        
        self.model_variants = {
            "YOLOv6-N": {"mAP": 37.5, "Speed": "1187 FPS", "Params": "4.7M"},
            "YOLOv6-T": {"mAP": 41.3, "Speed": "425 FPS", "Params": "15.0M"},
            "YOLOv6-S": {"mAP": 45.0, "Speed": "373 FPS", "Params": "18.5M"},
            "YOLOv6-M": {"mAP": 50.0, "Speed": "231 FPS", "Params": "34.9M"},
            "YOLOv6-L": {"mAP": 52.8, "Speed": "161 FPS", "Params": "59.6M"}
        }

# EfficientRep骨干网络
class RepBlock(nn.Module):
    """重参数化块"""
    
    def __init__(self, in_channels, out_channels, stride=1):
        super(RepBlock, self).__init__()
        self.stride = stride
        self.in_channels = in_channels
        self.out_channels = out_channels
        
        # 训练时的多分支结构
        if stride == 1 and in_channels == out_channels:
            self.identity = nn.BatchNorm2d(in_channels)
        else:
            self.identity = None
        
        self.conv_3x3 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        
        self.conv_1x1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 1, stride, 0, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        
        self.activation = nn.ReLU(inplace=True)
        
        # 推理时的单分支结构
        self.deploy = False
        self.rep_conv = None
    
    def forward(self, x):
        if self.deploy:
            return self.activation(self.rep_conv(x))
        
        # 训练时多分支
        out = self.conv_3x3(x) + self.conv_1x1(x)
        if self.identity is not None:
            out += self.identity(x)
        
        return self.activation(out)
    
    def switch_to_deploy(self):
        """转换为部署模式的单分支结构"""
        if self.deploy:
            return
        
        # 获取等效的3x3卷积参数
        kernel, bias = self._get_equivalent_kernel_bias()
        
        # 创建重参数化卷积
        self.rep_conv = nn.Conv2d(
            self.in_channels, self.out_channels, 3, self.stride, 1, bias=True
        )
        self.rep_conv.weight.data = kernel
        self.rep_conv.bias.data = bias
        
        # 删除原分支
        self.__delattr__('conv_3x3')
        self.__delattr__('conv_1x1')
        if hasattr(self, 'identity'):
            self.__delattr__('identity')
        
        self.deploy = True
    
    def _get_equivalent_kernel_bias(self):
        """计算等效的卷积核和偏置"""
        # 获取3x3分支的参数
        kernel_3x3, bias_3x3 = self._fuse_bn_tensor(self.conv_3x3)
        
        # 获取1x1分支的参数（填充为3x3）
        kernel_1x1, bias_1x1 = self._fuse_bn_tensor(self.conv_1x1)
        kernel_1x1 = F.pad(kernel_1x1, [1, 1, 1, 1])
        
        # 身份映射分支
        kernel_id, bias_id = 0, 0
        if self.identity is not None:
            kernel_id, bias_id = self._fuse_bn_tensor(self.identity)
            # 创建身份映射的3x3卷积核
            kernel_id = F.pad(torch.eye(self.in_channels).view(self.in_channels, self.in_channels, 1, 1), [1, 1, 1, 1])
        
        # 合并所有分支
        return kernel_3x3 + kernel_1x1 + kernel_id, bias_3x3 + bias_1x1 + bias_id
    
    def _fuse_bn_tensor(self, branch):
        """融合BN层参数"""
        if isinstance(branch, nn.Sequential):
            kernel = branch[0].weight
            running_mean = branch[1].running_mean
            running_var = branch[1].running_var
            gamma = branch[1].weight
            beta = branch[1].bias
            eps = branch[1].eps
        else:  # BatchNorm only
            kernel = torch.eye(self.in_channels).view(self.in_channels, self.in_channels, 1, 1)
            running_mean = branch.running_mean
            running_var = branch.running_var
            gamma = branch.weight
            beta = branch.bias
            eps = branch.eps
        
        std = (running_var + eps).sqrt()
        t = (gamma / std).reshape(-1, 1, 1, 1)
        
        return kernel * t, beta - running_mean * gamma / std

# EfficientRep骨干网络
class EfficientRep(nn.Module):
    """EfficientRep骨干网络"""
    
    def __init__(self, channels_list=[64, 128, 256, 512, 1024], num_repeats=[1, 6, 12, 18, 6]):
        super(EfficientRep, self).__init__()
        
        # Stem
        self.stem = nn.Sequential(
            RepBlock(3, channels_list[0]//2, 2),
            RepBlock(channels_list[0]//2, channels_list[0]//2, 1),
            RepBlock(channels_list[0]//2, channels_list[0], 1)
        )
        
        # 构建各个stage
        self.stages = nn.ModuleList()
        in_channels = channels_list[0]
        
        for i, (out_channels, num_repeat) in enumerate(zip(channels_list[1:], num_repeats[1:])):
            stage = []
            
            # 下采样
            stage.append(RepBlock(in_channels, out_channels, 2))
            
            # 重复块
            for _ in range(num_repeat):
                stage.append(RepBlock(out_channels, out_channels, 1))
            
            self.stages.append(nn.Sequential(*stage))
            in_channels = out_channels
    
    def forward(self, x):
        outputs = []
        
        x = self.stem(x)
        
        for stage in self.stages:
            x = stage(x)
            outputs.append(x)
        
        # 返回最后三个stage的输出用于FPN
        return outputs[-3:]

# SimOTA标签分配
class SimOTA:
    """SimOTA动态标签分配"""
    
    def __init__(self, center_radius=2.5, candidate_topk=10):
        self.center_radius = center_radius
        self.candidate_topk = candidate_topk
    
    def assign(self, pred_scores, pred_bboxes, gt_bboxes, gt_labels):
        """
        动态标签分配
        pred_scores: (num_anchors, num_classes)
        pred_bboxes: (num_anchors, 4)  
        gt_bboxes: (num_gt, 4)
        gt_labels: (num_gt,)
        """
        num_gt = gt_bboxes.size(0)
        num_anchors = pred_scores.size(0)
        
        if num_gt == 0:
            # 没有GT，所有anchor都是负样本
            return torch.zeros(num_anchors, dtype=torch.long), \
                   torch.zeros(num_anchors, num_gt, dtype=torch.float)
        
        # 1. 计算几何约束（中心先验）
        is_in_centers = self._get_in_centers_info(pred_bboxes, gt_bboxes)
        
        # 2. 计算cost matrix
        cost_matrix = self._compute_cost_matrix(
            pred_scores, pred_bboxes, gt_bboxes, gt_labels, is_in_centers
        )
        
        # 3. 动态k值选择
        dynamic_ks = self._get_dynamic_k(cost_matrix, gt_bboxes)
        
        # 4. 执行匹配
        matched_gt_inds, matched_labels = self._dynamic_k_matching(
            cost_matrix, dynamic_ks, num_gt
        )
        
        return matched_gt_inds, matched_labels
    
    def _get_in_centers_info(self, anchors, gt_bboxes):
        """获取中心先验信息"""
        num_anchors = anchors.size(0)
        num_gt = gt_bboxes.size(0)
        
        # 计算anchor中心点
        anchor_centers = (anchors[:, :2] + anchors[:, 2:]) / 2  # (num_anchors, 2)
        
        # 计算GT中心点
        gt_centers = (gt_bboxes[:, :2] + gt_bboxes[:, 2:]) / 2  # (num_gt, 2)
        
        # 计算距离
        distances = torch.cdist(anchor_centers, gt_centers)  # (num_anchors, num_gt)
        
        # 判断是否在中心区域内
        is_in_centers = distances < self.center_radius
        
        return is_in_centers
    
    def _compute_cost_matrix(self, pred_scores, pred_bboxes, gt_bboxes, gt_labels, is_in_centers):
        """计算cost matrix"""
        num_anchors = pred_scores.size(0)
        num_gt = gt_bboxes.size(0)
        
        # 分类cost
        cls_cost = -pred_scores[:, gt_labels]  # (num_anchors, num_gt)
        
        # 回归cost (IoU)
        ious = self._compute_iou(pred_bboxes[:, None, :], gt_bboxes[None, :, :])
        reg_cost = -ious  # (num_anchors, num_gt)
        
        # 总cost
        cost_matrix = cls_cost + 3.0 * reg_cost
        
        # 应用几何约束
        cost_matrix = cost_matrix * is_in_centers.float() + \
                     1e8 * (~is_in_centers).float()
        
        return cost_matrix
    
    def _compute_iou(self, boxes1, boxes2):
        """计算IoU"""
        # boxes1: (num_anchors, 1, 4)
        # boxes2: (1, num_gt, 4)
        
        # 计算交集
        lt = torch.max(boxes1[..., :2], boxes2[..., :2])
        rb = torch.min(boxes1[..., 2:], boxes2[..., 2:])
        
        wh = (rb - lt).clamp(min=0)
        intersection = wh[..., 0] * wh[..., 1]
        
        # 计算面积
        area1 = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])
        area2 = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])
        
        union = area1 + area2 - intersection
        iou = intersection / union.clamp(min=1e-8)
        
        return iou
    
    def _get_dynamic_k(self, cost_matrix, gt_bboxes):
        """动态计算每个GT的k值"""
        num_gt = gt_bboxes.size(0)
        dynamic_ks = []
        
        for gt_idx in range(num_gt):
            # 选择cost最小的topk个anchor
            _, topk_indices = torch.topk(
                cost_matrix[:, gt_idx], k=self.candidate_topk, largest=False
            )
            
            # 计算这些anchor的IoU
            ious = self._compute_iou(
                cost_matrix.new_zeros(self.candidate_topk, 4),
                gt_bboxes[gt_idx:gt_idx+1]
            )
            
            # 动态k值为IoU总和的整数部分
            dynamic_k = int(ious.sum().item())
            dynamic_k = max(1, dynamic_k)  # 至少为1
            
            dynamic_ks.append(dynamic_k)
        
        return dynamic_ks
    
    def _dynamic_k_matching(self, cost_matrix, dynamic_ks, num_gt):
        """执行动态k匹配"""
        num_anchors = cost_matrix.size(0)
        
        matched_gt_inds = torch.zeros(num_anchors, dtype=torch.long) - 1
        matched_labels = torch.zeros(num_anchors, num_gt, dtype=torch.float)
        
        for gt_idx in range(num_gt):
            k = dynamic_ks[gt_idx]
            
            # 选择cost最小的k个anchor
            _, topk_indices = torch.topk(
                cost_matrix[:, gt_idx], k=k, largest=False
            )
            
            # 分配标签
            matched_gt_inds[topk_indices] = gt_idx
            matched_labels[topk_indices, gt_idx] = 1.0
        
        return matched_gt_inds, matched_labels

# 自蒸馏训练
class SelfDistillation:
    """自蒸馏训练策略"""
    
    def __init__(self, teacher_model, student_model, temperature=4.0, alpha=0.7):
        self.teacher_model = teacher_model
        self.student_model = student_model
        self.temperature = temperature
        self.alpha = alpha
        
        # 冻结教师模型
        for param in self.teacher_model.parameters():
            param.requires_grad = False
    
    def compute_distillation_loss(self, student_outputs, teacher_outputs, targets):
        """计算蒸馏损失"""
        # 1. 原始任务损失
        task_loss = self._compute_task_loss(student_outputs, targets)
        
        # 2. 知识蒸馏损失
        kd_loss = self._compute_kd_loss(student_outputs, teacher_outputs)
        
        # 3. 组合损失
        total_loss = self.alpha * task_loss + (1 - self.alpha) * kd_loss
        
        return total_loss, task_loss, kd_loss
    
    def _compute_task_loss(self, outputs, targets):
        """计算原始任务损失"""
        # 简化实现
        return F.mse_loss(outputs, targets)
    
    def _compute_kd_loss(self, student_outputs, teacher_outputs):
        """计算知识蒸馏损失"""
        # 软化预测
        student_soft = F.softmax(student_outputs / self.temperature, dim=-1)
        teacher_soft = F.softmax(teacher_outputs / self.temperature, dim=-1)
        
        # KL散度
        kd_loss = F.kl_div(
            student_soft.log(), teacher_soft, reduction='batchmean'
        ) * (self.temperature ** 2)
        
        return kd_loss

# 演示YOLOv6的使用
def demonstrate_yolov6_features():
    """演示YOLOv6的特性"""
    print("YOLOv6关键特性:")
    
    features = YOLOv6Features()
    
    print("\n核心创新:")
    for innovation, description in features.key_innovations.items():
        print(f"  {innovation}: {description}")
    
    print(f"\n模型变体性能:")
    print("-" * 60)
    print(f"{'模型':<12}{'mAP':<8}{'速度':<12}{'参数量':<10}")
    print("-" * 60)
    
    for model, specs in features.model_variants.items():
        print(f"{model:<12}{specs['mAP']:<8}{specs['Speed']:<12}{specs['Params']:<10}")
    
    # 重参数化演示
    print(f"\n重参数化演示:")
    rep_block = RepBlock(64, 64, 1)
    
    # 训练模式
    x = torch.randn(1, 64, 32, 32)
    train_output = rep_block(x)
    print(f"训练模式输出形状: {train_output.shape}")
    
    # 部署模式
    rep_block.switch_to_deploy()
    deploy_output = rep_block(x)
    print(f"部署模式输出形状: {deploy_output.shape}")
    print(f"输出差异: {torch.mean(torch.abs(train_output - deploy_output)):.6f}")

# 运行演示
demonstrate_yolov6_features()

import os
import json
import xml.etree.ElementTree as ET
from pathlib import Path
import numpy as np
import cv2

class DatasetInfo:
    """数据集信息管理"""
    
    def __init__(self):
        self.datasets = {
            "COCO": {
                "description": "Common Objects in Context",
                "classes": 80,
                "train_images": 118287,
                "val_images": 5000,
                "annotation_format": "JSON",
                "download_size": "~20GB",
                "use_case": "通用目标检测、分割"
            },
            "PASCAL VOC": {
                "description": "Visual Object Classes",
                "classes": 20,
                "train_images": 16551,
                "val_images": 4952,
                "annotation_format": "XML",
                "download_size": "~2GB",
                "use_case": "经典目标检测基准"
            },
            "Open Images": {
                "description": "Google开源大规模数据集",
                "classes": 600,
                "train_images": 1743042,
                "val_images": 41620,
                "annotation_format": "CSV",
                "download_size": "~500GB",
                "use_case": "大规模预训练"
            }
        }
    
    def print_dataset_info(self):
        """打印数据集信息"""
        print("常用目标检测数据集:")
        print("=" * 60)
        
        for name, info in self.datasets.items():
            print(f"\n{name}:")
            print(f"  描述: {info['description']}")
            print(f"  类别数: {info['classes']}")
            print(f"  训练图像: {info['train_images']:,}")
            print(f"  验证图像: {info['val_images']:,}")
            print(f"  标注格式: {info['annotation_format']}")
            print(f"  数据大小: {info['download_size']}")
            print(f"  使用场景: {info['use_case']}")

# COCO类别定义
COCO_CLASSES = [
    'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
    'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
    'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
    'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
    'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
    'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
    'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
    'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
    'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
    'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
    'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
    'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock',
    'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]

# VOC类别定义
VOC_CLASSES = [
    'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
    'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse',
    'motorbike', 'person', 'pottedplant', 'sheep', 'sofa',
    'train', 'tvmonitor'
]

dataset_info = DatasetInfo()
dataset_info.print_dataset_info()

from ultralytics import YOLO
import torch
import yaml
from pathlib import Path
import matplotlib.pyplot as plt

class TrainingSetup:
    """训练环境设置"""
    
    def __init__(self):
        self.device = self.get_device()
        self.setup_reproducibility()
    
    def get_device(self):
        """获取训练设备"""
        if torch.cuda.is_available():
            device = 'cuda'
            print(f"Using GPU: {torch.cuda.get_device_name()}")
            print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
        else:
            device = 'cpu'
            print("Using CPU for training")
        return device
    
    def setup_reproducibility(self, seed=42):
        """设置随机种子保证可重复性"""
        torch.manual_seed(seed)
        if torch.cuda.is_available():
            torch.cuda.manual_seed(seed)
        print(f"Random seed set to {seed}")
    
    def create_training_config(self, data_path, model_size='n'):
        """创建训练配置"""
        config = {
            'model': f'yolov8{model_size}.pt',
            'data': data_path,
            'epochs': 100,
            'batch_size': 16,
            'imgsz': 640,
            'lr0': 0.01,
            'lrf': 0.01,
            'momentum': 0.937,
            'weight_decay': 0.0005,
            'warmup_epochs': 3.0,
            'warmup_momentum': 0.8,
            'warmup_bias_lr': 0.1,
            'box': 7.5,
            'cls': 0.5,
            'dfl': 1.5,
            'pose': 12.0,
            'kobj': 2.0,
            'label_smoothing': 0.0,
            'nbs': 64,
            'overlap_mask': True,
            'mask_ratio': 4,
            'dropout': 0.0,
            'val': True,
            'plots': True,
            'save': True,
            'save_period': -1,
            'cache': False,
            'device': self.device,
            'workers': 8,
            'project': 'runs/train',
            'name': 'exp',
            'exist_ok': False,
            'pretrained': True,
            'optimizer': 'SGD',
            'verbose': True,
            'seed': 0,
            'deterministic': True,
            'single_cls': False,
            'rect': False,
            'cos_lr': False,
            'close_mosaic': 10,
            'resume': False,
            'amp': True,
            'fraction': 1.0,
            'profile': False,
            'freeze': None,
        }
        return config

# 初始化训练设置
trainer = TrainingSetup()
training_config = trainer.create_training_config('data.yaml')
print("训练环境准备完成")