#!/usr/bin/env python3
"""
Phase 4A Task-specific GCA 配置分析
分析 multitask_BEV2X_phase4a_stage1_task_gca.yaml 的网络架构和特征尺寸
"""

import yaml
import math

def analyze_phase4a_gca_config():
    """分析Phase 4A Task-specific GCA配置"""

    print("=" * 80)
    print("🚀 BEVFusion Phase 4A - Task-specific GCA 架构分析")
    print("=" * 80)

    # 读取配置文件
    config_path = "configs/nuscenes/det/transfusion/secfpn/camera+lidar/swint_v0p075/multitask_BEV2X_phase4a_stage1_task_gca.yaml"

    with open(config_path, 'r', encoding='utf-8') as f:
        config = yaml.safe_load(f)

    print(f"📁 配置文件: {config_path}")
    print()

    # ========== 1. 输入规格分析 ==========
    print("📊 1. 输入规格分析")
    print("-" * 40)

    voxel_size = config['voxel_size']
    point_cloud_range = config['point_cloud_range']
    image_size = config.get('image_size', [256, 704])  # 从_base_继承

    print(f"🔹 LiDAR体素尺寸: {voxel_size}")
    print(f"🔹 点云范围: {point_cloud_range}")
    print(f"🔹 图像尺寸: {image_size}")
    print()

    # 计算BEV网格尺寸
    bev_width = int((point_cloud_range[3] - point_cloud_range[0]) / voxel_size[0])
    bev_height = int((point_cloud_range[4] - point_cloud_range[1]) / voxel_size[1])
    bev_depth = int((point_cloud_range[5] - point_cloud_range[2]) / voxel_size[2])

    print(f"🔹 BEV网格尺寸: {bev_width}×{bev_height}×{bev_depth}")
    print(f"   ├── 宽度: {bev_width} ({point_cloud_range[0]}m ~ {point_cloud_range[3]}m)")
    print(f"   ├── 高度: {bev_height} ({point_cloud_range[1]}m ~ {point_cloud_range[4]}m)")
    print(f"   └── 深度: {bev_depth} ({point_cloud_range[2]}m ~ {point_cloud_range[5]}m)")
    print()

    # ========== 2. 编码器分析 ==========
    print("🏗️ 2. 编码器架构分析")
    print("-" * 40)

    model = config['model']
    encoders = model['encoders']

    # Camera Encoder
    print("📷 Camera Encoder:")
    camera = encoders['camera']
    backbone = camera['backbone']

    print(f"   ├── Backbone: {backbone['type']}")
    print(f"   ├── embed_dims: {backbone['embed_dims']}")
    print(f"   ├── depths: {backbone['depths']} (总层数: {sum(backbone['depths'])})")
    print(f"   ├── num_heads: {backbone['num_heads']}")
    print(f"   ├── out_indices: {backbone['out_indices']}")

    neck = camera['neck']
    print(f"   ├── Neck: {neck['type']}")
    print(f"   │   ├── in_channels: {neck['in_channels']}")
    print(f"   │   ├── out_channels: {neck['out_channels']}")
    print(f"   │   └── num_outs: {neck['num_outs']}")

    vtransform = camera['vtransform']
    print(f"   └── VTransform: {vtransform['type']}")
    print(f"       ├── in_channels: {vtransform['in_channels']}")
    print(f"       ├── out_channels: {vtransform['out_channels']}")
    print(f"       ├── image_size: {vtransform['image_size']}")
    print(f"       ├── feature_size: {vtransform['feature_size']}")
    print(f"       └── downsample: {vtransform['downsample']}")
    print()

    # LiDAR Encoder
    print("🔍 LiDAR Encoder:")
    lidar = encoders['lidar']
    voxelize = lidar['voxelize']

    print(f"   ├── Voxelize:")
    print(f"   │   ├── max_num_points: {voxelize['max_num_points']}")
    print(f"   │   ├── voxel_size: {voxelize['voxel_size']}")
    print(f"   │   ├── max_voxels: {voxelize['max_voxels']}")
    print(f"   │   └── point_cloud_range: {voxelize['point_cloud_range']}")

    backbone_lidar = lidar['backbone']
    print(f"   └── Backbone: {backbone_lidar['type']}")
    print(f"       ├── in_channels: {backbone_lidar['in_channels']}")
    print(f"       ├── output_channels: {backbone_lidar['output_channels']}")
    print(f"       ├── sparse_shape: {backbone_lidar['sparse_shape']}")
    print(f"       └── encoder_channels: {backbone_lidar['encoder_channels']}")
    print()

    # Fuser
    print("🔗 Fuser:")
    fuser = model['fuser']
    print(f"   ├── Type: {fuser['type']}")
    print(f"   ├── in_channels: {fuser['in_channels']} (Camera + LiDAR)")
    print(f"   └── out_channels: {fuser['out_channels']}")
    print()

    # ========== 3. 解码器分析 ==========
    print("📈 3. 解码器架构分析")
    print("-" * 40)

    decoder = model['decoder']

    # Backbone
    backbone_dec = decoder['backbone']
    print("🔧 Decoder Backbone:")
    print(f"   ├── Type: {backbone_dec['type']}")
    print(f"   ├── in_channels: {backbone_dec['in_channels']}")
    print(f"   ├── out_channels: {backbone_dec['out_channels']}")
    print(f"   └── layer_nums: {backbone_dec['layer_nums']}")

    # Neck
    neck_dec = decoder['neck']
    print(f"🔧 Decoder Neck:")
    print(f"   ├── Type: {neck_dec['type']}")
    print(f"   ├── in_channels: {neck_dec['in_channels']}")
    print(f"   ├── out_channels: {neck_dec['out_channels']}")
    print(f"   └── upsample_strides: {neck_dec['upsample_strides']}")
    print()

    # ========== 4. Task-specific GCA 分析 ==========
    print("🎯 4. Task-specific GCA 机制")
    print("-" * 40)

    task_gca = model['task_specific_gca']
    print("✨ Task-specific GCA 配置:")
    print(f"   ├── enabled: {task_gca['enabled']}")
    print(f"   ├── in_channels: {task_gca['in_channels']} (原始BEV通道数)")
    print(f"   ├── reduction: {task_gca['reduction']}")
    print(f"   ├── use_max_pool: {task_gca['use_max_pool']}")
    print(f"   ├── object_reduction: {task_gca['object_reduction']} (检测GCA)")
    print(f"   └── map_reduction: {task_gca['map_reduction']} (分割GCA)")
    print()

    print("📋 GCA机制说明:")
    print("   • 检测GCA: 从512通道中选择对检测最有益的特征")
    print("     - 强化: 物体边界、中心点、空间关系")
    print("     - 抑制: 语义纹理、全局语义")
    print("   • 分割GCA: 从512通道中选择对分割最有益的特征")
    print("     - 强化: 语义纹理、连续性、全局语义")
    print("     - 抑制: 物体边界(精确)、中心点")
    print("   • 结果: 各取所需，性能最大化 ✅")
    print()

    # ========== 5. 头部分析 ==========
    print("🎯 5. 任务头部分析")
    print("-" * 40)

    heads = model['heads']

    # Object Head (3D Detection)
    object_head = heads['object']
    print("🚗 3D检测头 (Object Head):")
    print(f"   ├── in_channels: {object_head['in_channels']}")
    print(f"   ├── train_cfg.grid_size: {object_head['train_cfg']['grid_size']}")
    print(f"   └── test_cfg.grid_size: {object_head['test_cfg']['grid_size']}")
    print()

    # Map Head (BEV Segmentation)
    map_head = heads['map']
    print("🗺️ BEV分割头 (Map Head):")
    print(f"   ├── Type: {map_head['type']}")
    print(f"   ├── in_channels: {map_head['in_channels']}")
    print(f"   ├── classes: {config.get('map_classes', '6 classes')}")
    print(f"   ├── loss: {map_head['loss']}")
    print(f"   ├── deep_supervision: {map_head['deep_supervision']}")
    print(f"   ├── use_dice_loss: {map_head['use_dice_loss']}")
    print(f"   ├── dice_weight: {map_head['dice_weight']}")
    print(f"   ├── focal_alpha: {map_head['focal_alpha']}")
    print(f"   ├── focal_gamma: {map_head['focal_gamma']}")
    print(f"   ├── decoder_channels: {map_head['decoder_channels']}")
    print(f"   ├── use_internal_gca: {map_head['use_internal_gca']}")
    print(f"   ├── adaptive_multiscale: {map_head['adaptive_multiscale']}")
    print(f"   └── adaptive_dilation_rates: {map_head['adaptive_dilation_rates']}")

    # Grid Transform
    grid_transform = map_head['grid_transform']
    input_scope = grid_transform['input_scope']
    output_scope = grid_transform['output_scope']

    input_res = input_scope[0][2]  # xbound resolution
    output_res = output_scope[0][2]  # xbound resolution

    input_width = int((input_scope[0][1] - input_scope[0][0]) / input_res)
    input_height = int((input_scope[0][3] - input_scope[0][2]) / input_res) if len(input_scope[0]) > 3 else input_width

    output_width = int((output_scope[0][1] - output_scope[0][0]) / output_res)
    output_height = int((output_scope[0][3] - output_scope[0][2]) / output_res) if len(output_scope[0]) > 3 else output_width

    print(f"   └── Grid Transform:")
    print(f"       ├── 输入范围: {input_scope}")
    print(f"       │   ├── 分辨率: {input_res}m/pixel")
    print(f"       │   └── 尺寸: {input_width}×{input_height}")
    print(f"       ├── 输出范围: {output_scope}")
    print(f"       │   ├── 分辨率: {output_res}m/pixel")
    print(f"       │   └── 尺寸: {output_width}×{output_height}")
    print(f"       └── 缩放倍数: {input_res/output_res:.1f}x 上采样")
    print()

    # ========== 6. 特征尺寸计算 ==========
    print("📏 6. 特征尺寸计算")
    print("-" * 40)

    print("🌊 特征流尺寸变化:")
    print()

    # Camera特征流
    print("📷 Camera特征流:")
    print(f"   ├── 输入图像: {image_size[0]}×{image_size[1]}×3")
    print(f"   ├── Swin输出特征: Stage1: {image_size[0]//4}×{image_size[1]//4}×192")
    print(f"   │                  Stage2: {image_size[0]//8}×{image_size[1]//8}×384")
    print(f"   │                  Stage3: {image_size[0]//16}×{image_size[1]//16}×768")
    print(f"   │                  Stage4: {image_size[0]//32}×{image_size[1]//32}×768")
    print(f"   ├── LSS FPN输出: {vtransform['feature_size'][0]}×{vtransform['feature_size'][1]}×256")
    print(f"   └── VTransform输出: {bev_width}×{bev_height}×80")
    print()

    # LiDAR特征流
    print("🔍 LiDAR特征流:")
    print(f"   ├── 稀疏输入: {bev_width}×{bev_height}×{bev_depth}")
    print(f"   └── SparseEncoder输出: {bev_width}×{bev_height}×128")
    print()

    # 融合和解码
    print("🔗 融合与解码:")
    print(f"   ├── ConvFuser输入: Camera(80ch) + LiDAR(128ch) = 208ch")
    print(f"   ├── ConvFuser输出: {bev_width}×{bev_height}×256")
    print(f"   ├── SECOND Backbone: {bev_width}×{bev_height}×256 → {bev_width//2}×{bev_height//2}×256")
    print(f"   ├── SECONDFPN输出: {bev_width}×{bev_height}×512 (融合多尺度)")
    print(f"   └── Task-specific GCA: {bev_width}×{bev_height}×512 → 任务特定特征")
    print()

    # 分割头详细尺寸
    print("🗺️ 分割头特征尺寸:")
    print(f"   ├── 输入BEV: {bev_width}×{bev_height}×512")
    print(f"   ├── 4层渐进上采样 (512→256→256→128→128):")
    print(f"   │   ├── Layer1: {bev_width}×{bev_height}×512 → {bev_width}×{bev_height}×256")
    print(f"   │   ├── Layer2: {bev_width}×{bev_height}×256 → {bev_width}×{bev_height}×256")
    print(f"   │   ├── Layer3: {bev_width}×{bev_height}×256 → {bev_width}×{bev_height}×128")
    print(f"   │   └── Layer4: {bev_width}×{bev_height}×128 → {bev_width}×{bev_height}×128")
    print(f"   ├── 自适应多尺度融合: {map_head['adaptive_multiscale']}")
    print(f"   ├── 空洞率: {map_head['adaptive_dilation_rates']}")
    print(f"   └── 最终输出: {output_width}×{output_height}×{len(config.get('map_classes', []))} (6类别)")
    print()

    # ========== 7. 内存占用估计 ==========
    print("💾 7. 内存占用估计")
    print("-" * 40)

    # 计算主要特征图的内存占用
    bev_pixels = bev_width * bev_height
    seg_pixels = output_width * output_height

    # 主要特征图内存 (FP32, 4 bytes per float)
    bev_512ch = bev_pixels * 512 * 4 / (1024**3)  # GB
    bev_256ch = bev_pixels * 256 * 4 / (1024**3)  # GB
    seg_output = seg_pixels * 6 * 4 / (1024**3)   # GB

    print(f"🔹 BEV特征图 (1440×1440×512ch): {bev_512ch:.2f} GB")
    print(f"🔹 BEV特征图 (1440×1440×256ch): {bev_256ch:.2f} GB")
    print(f"🔹 分割输出 (598×598×6ch): {seg_output:.2f} GB")
    print(f"🔹 总计主要特征: {bev_512ch + bev_256ch + seg_output:.2f} GB")
    print()

    # ========== 8. 关键创新点 ==========
    print("🚀 8. Phase 4A 关键创新点")
    print("-" * 40)

    innovations = [
        "✨ Task-specific GCA: 检测和分割各自选择最优特征",
        "🎯 避免统一特征选择的折中问题",
        "🔧 自适应多尺度融合 (adaptive_multiscale)",
        "📏 渐进式4层解码器 (512→256→256→128→128)",
        "🎨 动态空洞率学习 (adaptive_dilation_rates: [1,3,6,12])",
        "📊 分割分辨率: 598×598 @ 0.167m/pixel",
        "🏗️ 检测使用完整1440×1440 BEV特征"
    ]

    for innovation in innovations:
        print(f"   {innovation}")
    print()

    # ========== 9. 训练配置摘要 ==========
    print("⚙️ 9. 训练配置摘要")
    print("-" * 40)

    print(f"🔹 训练轮数: {config['max_epochs']}")
    print(f"🔹 学习率: {config['optimizer']['lr']}")
    print(f"🔹 权重衰减: {config['optimizer']['weight_decay']}")
    print(f"🔹 梯度裁剪: {config['optimizer_config']['grad_clip']['max_norm']}")
    print(f"🔹 FP16初始scale: {config['fp16']['loss_scale']['init_scale']}")
    print(f"🔹 验证间隔: {config['evaluation']['interval']}")
    print(f"🔹 数据采样: val.load_interval = {config['data']['val']['load_interval']}")
    print()

    print("=" * 80)
    print("✅ Phase 4A Task-specific GCA 配置分析完成")
    print("=" * 80)

if __name__ == "__main__":
    analyze_phase4a_gca_config()