from typing import List, Dict, Any, Optional
from dataclasses import dataclass, field
import numpy as np


@dataclass
class GPUNode:
    """GPU计算节点"""
    gpu_type: str  # "H100", "H800", "A100", "昇腾910B", "寒武纪MLU370"
    gpu_count: int
    memory_per_gpu: int  # GB
    compute_tflops: float  # FP16 TFLOPS
    interconnect: str  # "NVLink", "HCCS", "PCIe"
    power_watts: int


@dataclass
class DataCenterCluster:
    """数据中心集群"""
    name: str
    location: str
    nodes: List[GPUNode]
    total_gpus: int = 0
    total_memory: int = 0  # TB
    total_compute: float = 0  # PetaFLOPS
    
    def __post_init__(self):
        for node in self.nodes:
            self.total_gpus += node.gpu_count
            self.total_memory += node.gpu_count * node.memory_per_gpu / 1024
            self.total_compute += node.gpu_count * node.compute_tflops / 1000
    
    def capacity_summary(self) -> Dict[str, Any]:
        return {
            "name": self.name,
            "location": self.location,
            "total_gpus": self.total_gpus,
            "total_memory_tb": self.total_memory,
            "total_compute_petaflops": self.total_compute,
            "estimated_daily_inference_tokens": self._estimate_daily_throughput()
        }
    
    def _estimate_daily_throughput(self) -> int:
        """
        估算每日推理吞吐量（token数）
        假设：每GPU每秒处理1000 tokens（中位数），利用率70%
        """
        tokens_per_second_per_gpu = 1000
        utilization = 0.7
        return int(self.total_gpus * tokens_per_second_per_gpu * 86400 * utilization)


class InferenceLoadBalancer:
    """
    推理负载均衡器
    支持多数据中心、多GPU类型的请求分发
    """
    def __init__(self, clusters: List[DataCenterCluster]):
        self.clusters = clusters
        self.cluster_weights = self._compute_weights()
    
    def _compute_weights(self) -> Dict[str, float]:
        """根据各集群算力计算权重"""
        total_compute = sum(c.total_compute for c in clusters)
        return {c.name: c.total_compute / total_compute for c in clusters}
    
    def dispatch_request(self, request: Dict[str, Any]) -> Dict[str, Any]:
        """
        分发推理请求到最优集群
        
        考虑因素：
        1. 集群负载
        2. 模型大小
        3. 延迟要求
        4. 成本优化
        """
        import random
        
        # 基于权重选择集群
        cluster_names = list(self.cluster_weights.keys())
        weights = list(self.cluster_weights.values())
        selected_cluster = random.choices(cluster_names, weights=weights, k=1)[0]
        
        return {
            "request_id": request.get("request_id", ""),
            "dispatched_to": selected_cluster,
            "estimated_latency_ms": random.randint(50, 200),
            "model": request.get("model", "unknown")
        }
    
    def get_cluster_stats(self) -> Dict[str, Any]:
        """获取各集群统计信息"""
        stats = {}
        for cluster in self.clusters:
            summary = cluster.capacity_summary()
            stats[cluster.name] = summary
        return stats


# 模拟中国AI推理数据中心集群
chinese_clusters = [
    DataCenterCluster(
        name="华东-临港",
        location="上海",
        nodes=[
            GPUNode("H800", 8000, 80, 989, "NVLink", 700),
            GPUNode("昇腾910B", 4000, 64, 512, "HCCS", 500),
        ]
    ),
    DataCenterCluster(
        name="华北-乌兰察布",
        location="内蒙古",
        nodes=[
            GPUNode("H800", 12000, 80, 989, "NVLink", 700),
            GPUNode("A100", 6000, 80, 312, "NVLink", 400),
        ]
    ),
    DataCenterCluster(
        name="华南-深圳",
        location="广东",
        nodes=[
            GPUNode("H800", 6000, 80, 989, "NVLink", 700),
            GPUNode("昇腾910B", 8000, 64, 512, "HCCS", 500),
            GPUNode("寒武纪MLU370", 2000, 24, 256, "PCIe", 250),
        ]
    ),
    DataCenterCluster(
        name="西南-贵安",
        location="贵州",
        nodes=[
            GPUNode("H800", 4000, 80, 989, "NVLink", 700),
            GPUNode("A100", 8000, 80, 312, "NVLink", 400),
        ]
    ),
]

# 模拟美国AI推理数据中心集群
us_clusters = [
    DataCenterCluster(
        name="US-West-Oregon",
        location="Oregon",
        nodes=[
            GPUNode("H100", 10000, 80, 989, "NVLink", 700),
            GPUNode("H200", 4000, 141, 989, "NVLink", 700),
        ]
    ),
    DataCenterCluster(
        name="US-East-Virginia",
        location="Virginia",
        nodes=[
            GPUNode("H100", 8000, 80, 989, "NVLink", 700),
            GPUNode("H200", 2000, 141, 989, "NVLink", 700),
        ]
    ),
]

class InferenceOptimizer:
    """
    推理优化器
    集成多种推理加速技术
    """
    def __init__(self, model_name: str, model_size_b: float):
        self.model_name = model_name
        self.model_size_b = model_size_b  # 模型大小（10亿参数）
        self.optimizations = []
    
    def apply_quantization(self, bits: int = 4) -> Dict[str, Any]:
        """
        应用量化压缩
        
        FP16模型大小: model_size_b * 2 GB
        INT4模型大小: model_size_b * 0.5 GB
        压缩比: 4x
        """
        fp16_size = self.model_size_b * 2  # GB
        quantized_size = self.model_size_b * bits / 8  # GB
        compression_ratio = fp16_size / quantized_size
        
        result = {
            "technique": f"INT{bits} quantization",
            "fp16_size_gb": fp16_size,
            "quantized_size_gb": quantized_size,
            "compression_ratio": compression_ratio,
            "speedup_estimate": 2.0 if bits == 4 else 1.5
        }
        self.optimizations.append(result)
        return result
    
    def apply_speculative_decoding(self, draft_model_size_b: float = 0.5) -> Dict[str, Any]:
        """
        应用投机解码（Speculative Decoding）
        
        使用小型草稿模型生成候选token，主模型验证
        典型加速比: 2-3x
        """
        acceptance_rate = 0.8  # 草稿token被接受的概率
        draft_speed_tokens_per_s = 500  # 草稿模型生成速度
        main_speed_tokens_per_s = 100  # 主模型生成速度
        
        # 投机解码理论加速比
        # E[加速比] = 1 / (1/draft_speed + acceptance_rate/main_speed)
        expected_speedup = 1.0 / (1.0 / draft_speed_tokens_per_s + acceptance_rate / main_speed_tokens_per_s)
        
        result = {
            "technique": "speculative_decoding",
            "draft_model_size_b": draft_model_size_b,
            "acceptance_rate": acceptance_rate,
            "expected_speedup": round(expected_speedup, 2)
        }
        self.optimizations.append(result)
        return result
    
    def apply_kv_cache_optimization(self, context_length: int = 32768) -> Dict[str, Any]:
        """
        KV Cache优化
        
        1. 缓存共享（Prefix Cache）
        2. 缓存量化（KV Cache Quantization）
        3. 缓存淘汰（Cache Eviction）
        """
        # 标准KV Cache大小
        # 每层: 2 * num_heads * head_dim * context_length * 2 bytes
        num_layers = int(self.model_size_b * 2)  # 近似层数
        num_heads = int(self.model_size_b * 4)  # 近似头数
        head_dim = 128
        
        standard_cache_gb = 2 * num_layers * num_heads * head_dim * context_length * 2 / 1e9
        
        # 优化后（INT8量化 + 共享）
        optimized_cache_gb = standard_cache_gb * 0.5 * 0.7  # INT8量化 * 共享比例
        
        result = {
            "technique": "kv_cache_optimization",
            "standard_cache_gb": round(standard_cache_gb, 2),
            "optimized_cache_gb": round(optimized_cache_gb, 2),
            "memory_saving_pct": round((1 - optimized_cache_gb / standard_cache_gb) * 100, 1)
        }
        self.optimizations.append(result)
        return result
    
    def apply_batch_scheduling(self, max_batch_size: int = 64) -> Dict[str, Any]:
        """
        动态批处理调度
        
        将多个请求合并为batch，提高GPU利用率
        """
        result = {
            "technique": "dynamic_batching",
            "max_batch_size": max_batch_size,
            "throughput_improvement": f"{max_batch_size * 0.7:.0f}x" if max_batch_size > 1 else "1x"
        }
        self.optimizations.append(result)
        return result
    
    def full_optimization_pipeline(self) -> Dict[str, Any]:
        """运行完整优化流水线"""
        self.apply_quantization(4)
        self.apply_speculative_decoding(0.5)
        self.apply_kv_cache_optimization(32768)
        self.apply_batch_scheduling(64)
        
        # 计算综合加速比
        total_speedup = 1.0
        for opt in self.optimizations:
            if "speedup_estimate" in opt:
                total_speedup *= opt["speedup_estimate"]
            elif "expected_speedup" in opt:
                total_speedup *= opt["expected_speedup"]
        
        return {
            "model": self.model_name,
            "original_size_gb": self.model_size_b * 2,
            "optimizations": self.optimizations,
            "total_speedup": round(total_speedup, 2),
            "estimated_cost_reduction": f"{round((1 - 1/total_speedup) * 100, 1)}%"
        }

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from typing import Optional, Callable


class KnowledgeDistillation:
    """
    知识蒸馏框架
    将教师模型（Teacher）的知识蒸馏到学生模型（Student）
    """
    def __init__(
        self,
        teacher_model: nn.Module,
        student_model: nn.Module,
        temperature: float = 4.0,
        alpha: float = 0.5,  # 蒸馏损失权重
        beta: float = 0.5,   # 学生损失权重
        distillation_loss_fn: Optional[Callable] = None
    ):
        """
        Args:
            teacher_model: 教师模型（大模型）
            student_model: 学生模型（小模型）
            temperature: 蒸馏温度，越高越关注软标签的分布
            alpha: 蒸馏损失权重
            beta: 学生损失（硬标签）权重
        """
        self.teacher = teacher_model
        self.student = student_model
        self.temperature = temperature
        self.alpha = alpha
        self.beta = beta
        self.distillation_loss_fn = distillation_loss_fn or self._kl_div_loss
    
    def _kl_div_loss(
        self, 
        student_logits: torch.Tensor, 
        teacher_logits: torch.Tensor
    ) -> torch.Tensor:
        """
        KL散度蒸馏损失
        L_distill = T² * KL(softmax(teacher/T) || softmax(student/T))
        """
        student_soft = F.log_softmax(student_logits / self.temperature, dim=-1)
        teacher_soft = F.softmax(teacher_logits / self.temperature, dim=-1)
        
        kl_loss = F.kl_div(student_soft, teacher_soft, reduction='batchmean')
        return self.temperature ** 2 * kl_loss
    
    def train_step(
        self,
        batch: Dict[str, torch.Tensor],
        optimizer: torch.optim.Optimizer
    ) -> Dict[str, float]:
        """
        单步蒸馏训练
        
        Args:
            batch: {"input_ids", "attention_mask", "labels"}
            optimizer: 优化器
        Returns:
            losses: {"total_loss", "distill_loss", "student_loss"}
        """
        input_ids = batch["input_ids"]
        attention_mask = batch.get("attention_mask")
        labels = batch.get("labels")
        
        # 教师模型前向（不计算梯度）
        self.teacher.eval()
        with torch.no_grad():
            teacher_outputs = self.teacher(
                input_ids=input_ids,
                attention_mask=attention_mask
            )
            teacher_logits = teacher_outputs.logits
        
        # 学生模型前向
        self.student.train()
        student_outputs = self.student(
            input_ids=input_ids,
            attention_mask=attention_mask
        )
        student_logits = student_outputs.logits
        
        # 蒸馏损失（软标签）
        distill_loss = self.distillation_loss_fn(student_logits, teacher_logits)
        
        # 学生损失（硬标签）
        student_loss = 0.0
        if labels is not None:
            student_loss = F.cross_entropy(
                student_logits.view(-1, student_logits.size(-1)),
                labels.view(-1)
            )
        
        # 总损失
        total_loss = self.alpha * distill_loss + self.beta * student_loss
        
        # 反向传播
        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()
        
        return {
            "total_loss": total_loss.item(),
            "distill_loss": distill_loss.item(),
            "student_loss": student_loss.item() if isinstance(student_loss, torch.Tensor) else 0.0
        }
    
    def train_epoch(
        self,
        dataloader: DataLoader,
        optimizer: torch.optim.Optimizer,
        device: torch.device
    ) -> Dict[str, float]:
        """训练一个epoch"""
        epoch_losses = {"total_loss": 0.0, "distill_loss": 0.0, "student_loss": 0.0}
        num_batches = 0
        
        for batch in dataloader:
            batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
            losses = self.train_step(batch, optimizer)
            
            for k, v in losses.items():
                epoch_losses[k] += v
            num_batches += 1
        
        return {k: v / num_batches for k, v in epoch_losses.items()}


class SequenceLevelDistillation:
    """
    序列级蒸馏（SeqKD）
    不仅蒸馏logits分布，还蒸馏序列生成策略
    """
    def __init__(
        self,
        teacher_model,
        student_model,
        temperature: float = 1.0,
        length_penalty: float = 0.6
    ):
        self.teacher = teacher_model
        self.student = student_model
        self.temperature = temperature
        self.length_penalty = length_penalty
    
    def distill_generation(
        self,
        prompt: str,
        max_length: int = 512,
        num_beams: int = 4
    ) -> Dict[str, Any]:
        """
        蒸馏生成策略
        
        教师模型生成的序列被用作学生模型的训练目标
        """
        # 教师模型生成
        self.teacher.eval()
        with torch.no_grad():
            teacher_output = self.teacher.generate(
                prompt,
                max_length=max_length,
                num_beams=num_beams,
                temperature=self.temperature,
                return_dict_in_generate=True,
                output_scores=True
            )
        
        teacher_sequence = teacher_output.sequences
        teacher_scores = teacher_output.scores
        
        # 学生模型基于教师序列进行训练
        self.student.train()
        student_output = self.student(
            input_ids=teacher_sequence[:, :-1],
            labels=teacher_sequence[:, 1:]
        )
        
        loss = student_output.loss
        
        return {
            "teacher_sequence": teacher_sequence,
            "teacher_avg_score": torch.mean(torch.stack(teacher_scores)).item(),
            "student_loss": loss.item()
        }


class MixtureOfDistillationStrategies:
    """
    混合蒸馏策略
    结合多种蒸馏方法，适应不同场景
    """
    STRATEGIES = {
        "logit_matching": "蒸馏logits分布，保留知识多样性",
        "sequence_level": "蒸馏生成序列，保留推理模式",
        "feature_matching": "蒸馏中间层特征表示",
        "contrastive": "对比蒸馏，区分正负样本",
        "self_distillation": "自蒸馏，模型自我提升"
    }
    
    def __init__(self, base_model, strategy_weights: Optional[Dict[str, float]] = None):
        self.base_model = base_model
        self.strategy_weights = strategy_weights or {
            "logit_matching": 0.4,
            "sequence_level": 0.3,
            "feature_matching": 0.2,
            "contrastive": 0.1
        }
    
    def compute_combined_loss(
        self,
        student_outputs: Dict[str, torch.Tensor],
        teacher_outputs: Dict[str, torch.Tensor],
        batch: Dict[str, torch.Tensor]
    ) -> torch.Tensor:
        """
        计算组合蒸馏损失
        """
        total_loss = 0.0
        
        for strategy, weight in self.strategy_weights.items():
            if strategy == "logit_matching":
                loss = self._logit_matching_loss(
                    student_outputs["logits"],
                    teacher_outputs["logits"]
                )
            elif strategy == "sequence_level":
                loss = self._sequence_level_loss(
                    student_outputs["logits"],
                    teacher_outputs["logits"],
                    batch.get("labels")
                )
            elif strategy == "feature_matching":
                loss = self._feature_matching_loss(
                    student_outputs["hidden_states"],
                    teacher_outputs["hidden_states"]
                )
            elif strategy == "contrastive":
                loss = self._contrastive_loss(
                    student_outputs["logits"],
                    teacher_outputs["logits"]
                )
            else:
                continue
            
            total_loss += weight * loss
        
        return total_loss

class DistillationEconomicAnalysis:
    """蒸馏经济效益分析"""
    def __init__(self, teacher_cost: float, student_cost: float, 
                 teacher_quality: float, student_quality: float):
        """
        Args:
            teacher_cost: 教师模型每百万token成本
            student_cost: 学生模型每百万token成本
            teacher_quality: 教师模型质量基准 (1.0)
            student_quality: 学生模型相对质量 (0-1)
        """
        self.teacher_cost = teacher_cost
        self.student_cost = student_cost
        self.teacher_quality = teacher_quality
        self.student_quality = student_quality
    
    def compute_roi(self, daily_tokens: int = 33_000_000_000_000) -> Dict[str, Any]:
        """计算蒸馏的投资回报率"""
        daily_tokens_m = daily_tokens / 1e6
        
        # 全部使用教师模型的成本
        teacher_daily_cost = daily_tokens_m * self.teacher_cost
        teacher_annual_cost = teacher_daily_cost * 365
        
        # 全部使用学生模型的成本
        student_daily_cost = daily_tokens_m * self.student_cost
        student_annual_cost = student_daily_cost * 365
        
        # 混合策略：70%学生 + 30%教师
        mixed_daily_cost = daily_tokens_m * (0.7 * self.student_cost + 0.3 * self.teacher_cost)
        mixed_annual_cost = mixed_daily_cost * 365
        
        savings = {
            "vs_all_teacher": {
                "daily_savings": teacher_daily_cost - mixed_daily_cost,
                "annual_savings": teacher_annual_cost - mixed_annual_cost,
                "savings_pct": f"{round((1 - mixed_daily_cost / teacher_daily_cost) * 100, 1)}%"
            },
            "vs_all_student": {
                "quality_gap": f"{round((1 - self.student_quality) * 100, 1)}%",
                "quality_improvement": f"{round((self.teacher_quality * 0.3 + self.student_quality * 0.7 - self.student_quality) * 100, 1)}%"
            }
        }
        
        return {
            "teacher_annual_cost": f"${teacher_annual_cost:,.0f}",
            "student_annual_cost": f"${student_annual_cost:,.0f}",
            "mixed_annual_cost": f"${mixed_annual_cost:,.0f}",
            "savings": savings
        }

class APIPricingAnalyzer:
    """API定价分析器"""
    def __init__(self):
        self.pricing_data = {
            "china": {
                "deepseek_v3": {"input": 0.14, "output": 0.28, "per_million": True},
                "kimi_k3": {"input": 0.20, "output": 0.40, "per_million": True},
                "qwen3_235b": {"input": 0.10, "output": 0.20, "per_million": True},
                "glm_5_52b": {"input": 0.08, "output": 0.16, "per_million": True},
            },
            "us": {
                "gpt_5_6_sol": {"input": 15.00, "output": 60.00, "per_million": True},
                "claude_fable_5": {"input": 12.00, "output": 48.00, "per_million": True},
                "gpt_4_1": {"input": 2.00, "output": 8.00, "per_million": True},
                "claude_opus_5": {"input": 10.00, "output": 40.00, "per_million": True},
            }
        }
    
    def compare_pricing(self, model_type: str = "flagship") -> Dict[str, Any]:
        """
        对比中美旗舰模型定价
        
        Returns:
            价格对比分析
        """
        china_models = self.pricing_data["china"]
        us_models = self.pricing_data["us"]
        
        # 计算平均价格
        china_avg_input = np.mean([m["input"] for m in china_models.values()])
        china_avg_output = np.mean([m["output"] for m in china_models.values()])
        us_avg_input = np.mean([m["input"] for m in us_models.values()])
        us_avg_output = np.mean([m["output"] for m in us_models.values()])
        
        return {
            "china_avg_input_per_m": china_avg_input,
            "china_avg_output_per_m": china_avg_output,
            "us_avg_input_per_m": us_avg_input,
            "us_avg_output_per_m": us_avg_output,
            "price_ratio_input": f"1:{round(us_avg_input / china_avg_input, 1)}",
            "price_ratio_output": f"1:{round(us_avg_output / china_avg_output, 1)}",
            "analysis": f"中国API平均价格仅为美国的1/{round(us_avg_input / china_avg_input)}"
        }

class APIGateway:
    """
    AI API网关
    支持多模型路由、负载均衡、速率限制、成本优化
    """
    def __init__(self, models: Dict[str, Any]):
        self.models = models
        self.request_count = 0
        self.total_tokens = 0
        self.latency_histogram = []
    
    def route_request(
        self,
        model: str,
        prompt: str,
        max_tokens: int = 1024,
        priority: str = "standard"
    ) -> Dict[str, Any]:
        """
        路由API请求
        
        路由策略：
        1. 简单任务 -> 学生模型（低成本）
        2. 中等难度 -> 中等模型
        3. 高难度 -> 教师模型（高成本）
        """
        start_time = time.time()
        
        # 任务难度评估
        difficulty = self._estimate_difficulty(prompt)
        
        # 选择模型
        if difficulty < 0.3:
            selected_model = "deepseek_v3"  # 学生模型
        elif difficulty < 0.7:
            selected_model = "qwen3_235b"  # 中等模型
        else:
            selected_model = "kimi_k3"  # 教师模型
        
        # 实际调用模型
        response = self.models[selected_model](prompt, max_tokens)
        
        latency = time.time() - start_time
        self.request_count += 1
        self.total_tokens += len(prompt.split()) + max_tokens
        self.latency_histogram.append(latency)
        
        return {
            "model": selected_model,
            "difficulty": difficulty,
            "latency_ms": round(latency * 1000, 2),
            "response": response,
            "cost": self._estimate_cost(selected_model, prompt, max_tokens)
        }
    
    def _estimate_difficulty(self, prompt: str) -> float:
        """
        估计任务难度
        
        基于：
        1. Prompt长度
        2. 推理关键词
        3. 代码/数学标记
        """
        import re
        
        score = 0.0
        
        # 长度因子
        length = len(prompt)
        score += min(length / 2000, 0.3)
        
        # 推理关键词
        reasoning_keywords = ["explain", "reason", "analyze", "compare", "why", "how",
                             "证明", "推导", "分析", "对比", "为什么"]
        for kw in reasoning_keywords:
            if kw in prompt.lower():
                score += 0.05
                break
        
        # 代码/数学标记
        if re.search(r'```|def |class |import |function|const |var ', prompt):
            score += 0.2
        if re.search(r'\$.*\$|\\frac|\\sum|\\int|\\alpha|\\beta|\\theta', prompt):
            score += 0.2
        
        return min(score, 1.0)
    
    def _estimate_cost(self, model: str, prompt: str, max_tokens: int) -> float:
        """估算请求成本"""
        cost_table = {
            "deepseek_v3": 0.14 / 1e6,
            "qwen3_235b": 0.10 / 1e6,
            "kimi_k3": 0.20 / 1e6,
        }
        input_tokens = len(prompt.split())
        cost = (input_tokens + max_tokens) * cost_table.get(model, 0.15 / 1e6)
        return round(cost, 6)
    
    def get_statistics(self) -> Dict[str, Any]:
        """获取API网关统计信息"""
        if not self.latency_histogram:
            return {"total_requests": 0}
        
        return {
            "total_requests": self.request_count,
            "total_tokens": self.total_tokens,
            "avg_latency_ms": round(np.mean(self.latency_histogram) * 1000, 2),
            "p50_latency_ms": round(np.percentile(self.latency_histogram, 50) * 1000, 2),
            "p95_latency_ms": round(np.percentile(self.latency_histogram, 95) * 1000, 2),
            "p99_latency_ms": round(np.percentile(self.latency_histogram, 99) * 1000, 2),
        }

class GlobalAICompetitionAnalyzer:
    """全球AI竞争力分析器"""
    
    DIMENSIONS = {
        "model_capability": {
            "weight": 0.25,
            "china": 85,
            "us": 95,
            "description": "模型能力（MMLU、HumanEval等基准）"
        },
        "inference_cost": {
            "weight": 0.20,
            "china": 95,
            "us": 70,
            "description": "推理成本优势（越低越好，反向评分）"
        },
        "api_ecosystem": {
            "weight": 0.15,
            "china": 90,
            "us": 85,
            "description": "API生态完善度"
        },
        "open_source": {
            "weight": 0.15,
            "china": 90,
            "us": 80,
            "description": "开源贡献"
        },
        "talent_pool": {
            "weight": 0.15,
            "china": 80,
            "us": 95,
            "description": "人才储备"
        },
        "hardware_supply": {
            "weight": 0.10,
            "china": 60,
            "us": 90,
            "description": "硬件供应链"
        }
    }
    
    @classmethod
    def compute_overall_score(cls) -> Dict[str, Any]:
        """计算综合竞争力得分"""
        china_score = 0.0
        us_score = 0.0
        
        breakdown = {}
        for dim, info in cls.DIMENSIONS.items():
            w = info["weight"]
            china_score += w * info["china"]
            us_score += w * info["us"]
            breakdown[dim] = {
                "china": info["china"],
                "us": info["us"],
                "weight": w,
                "description": info["description"]
            }
        
        return {
            "china_overall": round(china_score, 1),
            "us_overall": round(us_score, 1),
            "gap": f"{round(us_score - china_score, 1)} points (US领先)",
            "breakdown": breakdown,
            "assessment": "中国在推理成本和开源生态方面领先，美国在模型能力和硬件供应链方面领先。综合差距正在缩小。"
        }