GPU选型

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

class GPUSpecifications:
    """GPU规格数据库"""
    
    def __init__(self):
        self.gpu_specs = {
            "H100-SXM": {
                "架构": "Hopper",
                "显存": "80GB HBM3",
                "显存带宽": "3.35TB/s",
                "FP16性能": "1979 TFLOPS",
                "FP8性能": "3958 TFLOPS", 
                "NVLink": "900GB/s",
                "功耗": "700W",
                "适用场景": ["大规模训练", "推理", "多模态"],
                "单价": "$30,000-40,000",
                "性价比": "★★★☆☆"
            },
            
            "A100-SXM": {
                "架构": "Ampere",
                "显存": "80GB HBM2e",
                "显存带宽": "2.04TB/s", 
                "FP16性能": "1248 TFLOPS",
                "Tensor性能": "624 TFLOPS",
                "NVLink": "600GB/s",
                "功耗": "400W",
                "适用场景": ["通用训练", "推理", "数据中心"],
                "单价": "$15,000-20,000",
                "性价比": "★★★★☆"
            },
            
            "L40S": {
                "架构": "Ada Lovelace", 
                "显存": "48GB GDDR6",
                "显存带宽": "864GB/s",
                "FP16性能": "362 TFLOPS",
                "RT Cores": "第3代",
                "PCIe": "PCIe 4.0 x16",
                "功耗": "350W",
                "适用场景": ["推理", "图形渲染", "多媒体"],
                "单价": "$7,000-10,000", 
                "性价比": "★★★★★"
            },
            
            "RTX-4090": {
                "架构": "Ada Lovelace",
                "显存": "24GB GDDR6X",
                "显存带宽": "1008GB/s",
                "FP16性能": "166 TFLOPS",
                "CUDA核心": "16,384",
                "PCIe": "PCIe 4.0 x16",
                "功耗": "450W",
                "适用场景": ["推理", "小模型训练", "开发调试"],
                "单价": "$1,500-2,000",
                "性价比": "★★★★★"
            },
            
            "RTX-3090": {
                "架构": "Ampere",
                "显存": "24GB GDDR6X", 
                "显存带宽": "936GB/s",
                "FP16性能": "71 TFLOPS",
                "CUDA核心": "10,496",
                "PCIe": "PCIe 4.0 x16",
                "功耗": "350W",
                "适用场景": ["推理", "中小模型训练"],
                "单价": "$800-1,200",
                "性价比": "★★★★☆"
            }
        }
    
    def get_performance_comparison(self) -> pd.DataFrame:
        """获取性能对比表"""
        df_data = []
        
        for gpu_name, specs in self.gpu_specs.items():
            df_data.append({
                "GPU型号": gpu_name,
                "显存容量": specs["显存"],
                "FP16性能": specs["FP16性能"],
                "显存带宽": specs["显存带宽"],
                "功耗": specs["功耗"],
                "单价": specs["单价"],
                "性价比": specs["性价比"]
            })
        
        return pd.DataFrame(df_data)
    
    def calculate_memory_requirements(self, model_params: int, precision: str = "fp16") -> Dict[str, Any]:
        """计算显存需求"""
        
        # 每个参数的字节数
        bytes_per_param = {
            "fp32": 4,
            "fp16": 2, 
            "bf16": 2,
            "int8": 1,
            "int4": 0.5
        }
        
        param_bytes = bytes_per_param.get(precision, 2)
        
        # 模型权重内存
        model_memory = model_params * param_bytes / (1024**3)  # GB
        
        # 训练额外内存（优化器状态、梯度、激活值）
        training_overhead = model_memory * 4  # Adam优化器需要约4倍模型内存
        
        # KV缓存内存（推理时）
        # 假设序列长度4K，批大小32
        sequence_length = 4096
        batch_size = 32
        hidden_size = int(np.sqrt(model_params / 12))  # 估算hidden_size
        kv_cache_memory = (2 * sequence_length * batch_size * hidden_size * param_bytes) / (1024**3)
        
        return {
            "model_parameters": f"{model_params/1e9:.1f}B",
            "precision": precision,
            "model_memory_gb": round(model_memory, 2),
            "training_memory_gb": round(model_memory + training_overhead, 2),
            "inference_memory_gb": round(model_memory + kv_cache_memory, 2),
            "recommended_gpu_training": self.recommend_gpu_for_memory(model_memory + training_overhead),
            "recommended_gpu_inference": self.recommend_gpu_for_memory(model_memory + kv_cache_memory)
        }
    
    def recommend_gpu_for_memory(self, required_memory_gb: float) -> List[str]:
        """根据显存需求推荐GPU"""
        gpu_memory = {
            "RTX-4090": 24,
            "RTX-3090": 24,
            "L40S": 48,
            "A100-40GB": 40,
            "A100-80GB": 80,
            "H100-80GB": 80
        }
        
        suitable_gpus = [
            gpu for gpu, memory in gpu_memory.items()
            if memory >= required_memory_gb
        ]
        
        return suitable_gpus or ["需要多卡部署或模型优化"]

# 使用示例
gpu_db = GPUSpecifications()

# 查看性能对比
comparison_df = gpu_db.get_performance_comparison()
print("GPU性能对比:")
print(comparison_df)

# 计算不同模型的显存需求
models_to_check = [
    {"name": "GPT-3.5", "params": 175e9},
    {"name": "Llama-7B", "params": 7e9},
    {"name": "Llama-70B", "params": 70e9},
    {"name": "Claude-3", "params": 200e9}
]

print("\n模型显存需求分析:")
for model in models_to_check:
    requirements = gpu_db.calculate_memory_requirements(
        model["params"], 
        precision="fp16"
    )
    print(f"\n{model['name']} ({requirements['model_parameters']}):")
    print(f"  训练需求: {requirements['training_memory_gb']}GB")
    print(f"  推理需求: {requirements['inference_memory_gb']}GB")
    print(f"  训练推荐: {requirements['recommended_gpu_training']}")
    print(f"  推理推荐: {requirements['recommended_gpu_inference']}")

import matplotlib.pyplot as plt
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class GPUCostAnalysis:
    """GPU成本分析"""
    gpu_name: str
    purchase_price: float  # 采购价格
    monthly_rental: float  # 月租价格  
    power_consumption: float  # 功耗(W)
    training_throughput: float  # 训练吞吐量(tokens/s)
    inference_throughput: float  # 推理吞吐量(tokens/s)
    memory_gb: float  # 显存容量

class GPUCostOptimizer:
    """GPU成本优化分析器"""
    
    def __init__(self):
        self.gpu_options = {
            "H100-80GB": GPUCostAnalysis(
                gpu_name="H100-80GB",
                purchase_price=35000,
                monthly_rental=2000,
                power_consumption=700,
                training_throughput=50000,
                inference_throughput=80000,
                memory_gb=80
            ),
            
            "A100-80GB": GPUCostAnalysis(
                gpu_name="A100-80GB", 
                purchase_price=18000,
                monthly_rental=1200,
                power_consumption=400,
                training_throughput=30000,
                inference_throughput=50000,
                memory_gb=80
            ),
            
            "L40S": GPUCostAnalysis(
                gpu_name="L40S",
                purchase_price=8000,
                monthly_rental=600,
                power_consumption=350,
                training_throughput=15000,
                inference_throughput=35000,
                memory_gb=48
            ),
            
            "RTX-4090": GPUCostAnalysis(
                gpu_name="RTX-4090",
                purchase_price=1800,
                monthly_rental=150,
                power_consumption=450,
                training_throughput=5000,  # 限制较大
                inference_throughput=25000,
                memory_gb=24
            )
        }
        
        self.electricity_cost_per_kwh = 0.12  # 每度电成本
    
    def calculate_tco(self, 
                     gpu_name: str, 
                     usage_period_months: int = 36,
                     usage_hours_per_day: int = 20,
                     scenario: str = "inference") -> Dict[str, Any]:
        """计算总拥有成本 (TCO)"""
        
        if gpu_name not in self.gpu_options:
            return {"error": f"GPU {gpu_name} 不在选项中"}
        
        gpu = self.gpu_options[gpu_name]
        
        # 采购成本
        purchase_cost = gpu.purchase_price
        
        # 电力成本
        daily_power_cost = (
            gpu.power_consumption / 1000 * 
            usage_hours_per_day * 
            self.electricity_cost_per_kwh
        )
        total_power_cost = daily_power_cost * 30 * usage_period_months
        
        # 性能指标
        if scenario == "training":
            throughput = gpu.training_throughput
        else:
            throughput = gpu.inference_throughput
        
        # 计算性价比
        total_cost = purchase_cost + total_power_cost
        performance_per_dollar = throughput / total_cost
        
        return {
            "gpu_name": gpu_name,
            "scenario": scenario,
            "purchase_cost": purchase_cost,
            "power_cost": round(total_power_cost, 2),
            "total_cost": round(total_cost, 2),
            "throughput": throughput,
            "performance_per_dollar": round(performance_per_dollar, 4),
            "daily_operating_cost": round(daily_power_cost, 2),
            "usage_period_months": usage_period_months
        }
    
    def compare_gpus_for_scenario(self, scenario: str = "inference", usage_months: int = 36) -> pd.DataFrame:
        """比较不同GPU在特定场景下的表现"""
        
        comparison_data = []
        
        for gpu_name in self.gpu_options.keys():
            tco_analysis = self.calculate_tco(gpu_name, usage_months, 20, scenario)
            
            if "error" not in tco_analysis:
                comparison_data.append({
                    "GPU": gpu_name,
                    "总成本": f"${tco_analysis['total_cost']:,.0f}",
                    "吞吐量": f"{tco_analysis['throughput']:,} tokens/s",
                    "性价比": f"{tco_analysis['performance_per_dollar']:.4f}",
                    "显存": f"{self.gpu_options[gpu_name].memory_gb}GB",
                    "日运营成本": f"${tco_analysis['daily_operating_cost']:.2f}"
                })
        
        df = pd.DataFrame(comparison_data)
        return df.sort_values("性价比", ascending=False)
    
    def recommend_gpu_configuration(self, 
                                  requirements: Dict[str, Any]) -> Dict[str, Any]:
        """推荐GPU配置"""
        
        model_size_gb = requirements.get("model_size_gb", 7)  # 模型大小
        scenario = requirements.get("scenario", "inference")  # 使用场景
        budget = requirements.get("budget", 50000)  # 预算
        target_throughput = requirements.get("target_throughput", 10000)  # 目标吞吐量
        
        recommendations = []
        
        for gpu_name, gpu_spec in self.gpu_options.items():
            # 检查显存是否足够
            if gpu_spec.memory_gb < model_size_gb:
                continue
            
            # 检查预算
            if gpu_spec.purchase_price > budget:
                continue
            
            # 检查性能
            throughput = gpu_spec.training_throughput if scenario == "training" else gpu_spec.inference_throughput
            
            if throughput >= target_throughput:
                tco = self.calculate_tco(gpu_name, 36, 20, scenario)
                
                recommendations.append({
                    "gpu": gpu_name,
                    "meets_requirements": True,
                    "performance_ratio": throughput / target_throughput,
                    "cost_efficiency": tco["performance_per_dollar"],
                    "total_cost": tco["total_cost"],
                    "reasoning": f"满足{model_size_gb}GB显存需求，{throughput:,} tokens/s吞吐量"
                })
        
        # 多卡方案分析
        if not recommendations:
            multi_gpu_options = self.analyze_multi_gpu_options(requirements)
            recommendations.extend(multi_gpu_options)
        
        # 按性价比排序
        recommendations.sort(key=lambda x: x["cost_efficiency"], reverse=True)
        
        return {
            "requirements": requirements,
            "single_gpu_options": recommendations[:3],  # 前3个选项
            "multi_gpu_analysis": self.analyze_multi_gpu_scaling(requirements),
            "final_recommendation": recommendations[0] if recommendations else None
        }
    
    def analyze_multi_gpu_options(self, requirements: Dict[str, Any]) -> List[Dict[str, Any]]:
        """分析多GPU方案"""
        model_size_gb = requirements.get("model_size_gb", 70)
        budget = requirements.get("budget", 100000)
        
        multi_gpu_configs = []
        
        # 分析不同GPU的多卡配置
        for gpu_name, gpu_spec in self.gpu_options.items():
            # 计算需要的GPU数量
            gpus_needed = max(1, int(np.ceil(model_size_gb / gpu_spec.memory_gb)))
            total_cost = gpu_spec.purchase_price * gpus_needed
            
            if total_cost <= budget:
                total_memory = gpu_spec.memory_gb * gpus_needed
                
                # 估算多卡性能（考虑通信开销）
                if gpu_name in ["H100-80GB", "A100-80GB"]:
                    # NVLink连接，线性扩展
                    scaling_efficiency = 0.9
                else:
                    # PCIe连接，扩展效率降低
                    scaling_efficiency = 0.7
                
                total_throughput = (
                    gpu_spec.inference_throughput * 
                    gpus_needed * 
                    scaling_efficiency
                )
                
                multi_gpu_configs.append({
                    "gpu": f"{gpus_needed}x {gpu_name}",
                    "meets_requirements": True,
                    "total_memory": f"{total_memory}GB",
                    "total_cost": total_cost,
                    "estimated_throughput": int(total_throughput),
                    "scaling_efficiency": f"{scaling_efficiency:.0%}",
                    "reasoning": f"{gpus_needed}张{gpu_name}可提供{total_memory}GB显存"
                })
        
        return multi_gpu_configs
    
    def analyze_multi_gpu_scaling(self, requirements: Dict[str, Any]) -> Dict[str, Any]:
        """分析多GPU扩展性"""
        
        scaling_analysis = {
            "data_parallelism": {
                "description": "数据并行，适合大批量训练",
                "scaling_efficiency": 0.95,
                "memory_requirement": "每卡需要完整模型",
                "suitable_gpus": ["A100", "H100", "RTX-4090"]
            },
            
            "model_parallelism": {
                "description": "模型并行，适合超大模型",
                "scaling_efficiency": 0.8,
                "memory_requirement": "模型分片到多卡",
                "suitable_gpus": ["A100", "H100"],
                "min_gpus": 2
            },
            
            "pipeline_parallelism": {
                "description": "流水线并行，层间分布",
                "scaling_efficiency": 0.85,
                "memory_requirement": "每卡存储部分层",
                "suitable_gpus": ["A100", "H100"],
                "communication_overhead": "中等"
            }
        }
        
        return scaling_analysis
    
    def generate_selection_guide(self, budget_range: str) -> Dict[str, List[str]]:
        """生成选型指南"""
        
        budget_categories = {
            "入门级 (小于$5K)": {
                "training": ["RTX-3090 (小模型)", "RTX-4090 (中等模型)"],
                "inference": ["RTX-3090", "RTX-4090", "多张消费级卡"],
                "use_cases": ["学习研究", "原型开发", "小规模应用"]
            },
            
            "专业级 ($5K-$15K)": {
                "training": ["L40S", "A100-40GB"],
                "inference": ["L40S", "A100-40GB", "2x RTX-4090"],
                "use_cases": ["企业应用", "中等规模训练", "生产推理"]
            },
            
            "企业级 ($15K-$50K)": {
                "training": ["A100-80GB", "H100-80GB"],
                "inference": ["A100-80GB", "多张L40S"],
                "use_cases": ["大规模训练", "高性能推理", "多模态应用"]
            },
            
            "数据中心级 ($50K+)": {
                "training": ["多张H100", "H100集群"],
                "inference": ["H100集群", "混合GPU配置"],
                "use_cases": ["超大模型训练", "商业化服务", "研究机构"]
            }
        }
        
        return budget_categories

# 使用示例
optimizer = GPUCostOptimizer()

# 推理场景对比
print("推理场景GPU对比:")
inference_comparison = optimizer.compare_gpus_for_scenario("inference", 36)
print(inference_comparison)

# 配置推荐
requirements = {
    "model_size_gb": 70,  # 70GB模型
    "scenario": "inference",
    "budget": 25000,
    "target_throughput": 20000
}

recommendations = optimizer.recommend_gpu_configuration(requirements)
print(f"\n推荐配置: {recommendations['final_recommendation']}")

# 选型指南
guide = optimizer.generate_selection_guide("专业级")
print(f"\n专业级预算选型指南: {guide}")

class LLMTrainingGPUSelector:
    """LLM训练GPU选择器"""
    
    def __init__(self):
        self.training_requirements = {
            "7B模型": {
                "min_memory_per_gpu": 16,
                "recommended_gpus": ["RTX-4090", "A100-40GB"],
                "training_time_estimate": "2-5天",
                "data_parallelism": True
            },
            
            "13B模型": {
                "min_memory_per_gpu": 24,
                "recommended_gpus": ["RTX-4090", "A100-40GB", "L40S"],
                "training_time_estimate": "5-10天", 
                "data_parallelism": True
            },
            
            "70B模型": {
                "min_memory_per_gpu": 40,
                "recommended_gpus": ["A100-80GB", "H100-80GB"],
                "training_time_estimate": "2-4周",
                "model_parallelism": True
            },
            
            "175B+模型": {
                "min_memory_per_gpu": 80,
                "recommended_gpus": ["H100-80GB", "多卡A100"],
                "training_time_estimate": "1-3个月",
                "pipeline_parallelism": True,
                "min_gpu_count": 8
            }
        }
    
    def select_training_setup(self, 
                            model_size: str, 
                            budget: float,
                            time_constraint: str = None) -> Dict[str, Any]:
        """选择训练配置"""
        
        if model_size not in self.training_requirements:
            return {"error": f"不支持的模型大小: {model_size}"}
        
        requirements = self.training_requirements[model_size]
        
        # 分析可行的GPU配置
        feasible_configs = []
        
        for gpu_name in requirements["recommended_gpus"]:
            if gpu_name in optimizer.gpu_options:
                gpu_spec = optimizer.gpu_options[gpu_name]
                
                # 计算需要的GPU数量
                if model_size in ["175B+模型"]:
                    min_gpus = requirements.get("min_gpu_count", 4)
                else:
                    min_gpus = 1
                
                total_cost = gpu_spec.purchase_price * min_gpus
                
                if total_cost <= budget:
                    feasible_configs.append({
                        "gpu_config": f"{min_gpus}x {gpu_name}",
                        "total_cost": total_cost,
                        "estimated_training_time": requirements["training_time_estimate"],
                        "memory_total": gpu_spec.memory_gb * min_gpus,
                        "power_consumption": gpu_spec.power_consumption * min_gpus,
                        "parallelism_strategy": self.get_parallelism_strategy(requirements)
                    })
        
        # 排序推荐
        feasible_configs.sort(key=lambda x: x["total_cost"])
        
        return {
            "model_size": model_size,
            "budget": budget,
            "feasible_configurations": feasible_configs,
            "recommended_config": feasible_configs[0] if feasible_configs else None,
            "optimization_suggestions": self.get_optimization_suggestions(model_size, budget)
        }
    
    def get_parallelism_strategy(self, requirements: Dict) -> List[str]:
        """获取并行策略"""
        strategies = []
        
        if requirements.get("data_parallelism"):
            strategies.append("数据并行")
        if requirements.get("model_parallelism"):
            strategies.append("模型并行")  
        if requirements.get("pipeline_parallelism"):
            strategies.append("流水线并行")
        
        return strategies or ["单卡训练"]
    
    def get_optimization_suggestions(self, model_size: str, budget: float) -> List[str]:
        """获取优化建议"""
        suggestions = []
        
        if model_size in ["70B模型", "175B+模型"] and budget < 50000:
            suggestions.append("考虑使用LoRA/QLoRA等PEFT技术减少显存需求")
            suggestions.append("使用梯度检查点降低内存使用")
            suggestions.append("考虑云GPU租赁方案")
        
        if model_size in ["175B+模型"]:
            suggestions.append("建议使用DeepSpeed ZeRO优化内存使用")
            suggestions.append("考虑混合精度训练(FP16/BF16)")
            suggestions.append("使用激活重计算节省内存")
        
        return suggestions

# 使用示例
training_selector = LLMTrainingGPUSelector()

# 选择70B模型的训练配置
training_config = training_selector.select_training_setup(
    model_size="70B模型",
    budget=80000,
    time_constraint="2周内完成"
)

print("70B模型训练配置推荐:")
if training_config.get("recommended_config"):
    config = training_config["recommended_config"]
    print(f"推荐配置: {config['gpu_config']}")
    print(f"总成本: ${config['total_cost']:,}")
    print(f"并行策略: {', '.join(config['parallelism_strategy'])}")
    print(f"优化建议: {training_config['optimization_suggestions']}")

class LLMInferenceGPUSelector:
    """LLM推理GPU选择器"""
    
    def __init__(self):
        self.inference_scenarios = {
            "实时聊天": {
                "latency_requirement": "小于100ms",
                "concurrency": "100-1000用户",
                "memory_efficiency": "重要",
                "recommended_gpus": ["RTX-4090", "L40S", "A100"]
            },
            
            "批量处理": {
                "latency_requirement": "小于5s",
                "concurrency": "高吞吐量",
                "memory_efficiency": "非常重要",
                "recommended_gpus": ["A100", "H100", "多张RTX-4090"]
            },
            
            "API服务": {
                "latency_requirement": "小于500ms",
                "concurrency": "1000+用户",
                "memory_efficiency": "重要",
                "recommended_gpus": ["L40S", "A100", "H100"]
            },
            
            "边缘部署": {
                "latency_requirement": "小于200ms",
                "concurrency": "1-10用户",
                "memory_efficiency": "非常重要",
                "recommended_gpus": ["RTX-4090", "RTX-3090", "移动GPU"]
            }
        }
    
    def calculate_inference_capacity(self, 
                                   gpu_name: str, 
                                   model_size_gb: float,
                                   sequence_length: int = 2048,
                                   batch_size: int = 16) -> Dict[str, Any]:
        """计算推理容量"""
        
        if gpu_name not in optimizer.gpu_options:
            return {"error": f"GPU {gpu_name} 不存在"}
        
        gpu_spec = optimizer.gpu_options[gpu_name]
        
        # 计算显存使用
        model_memory = model_size_gb
        kv_cache_memory = self.estimate_kv_cache_memory(
            sequence_length, batch_size, model_size_gb
        )
        
        total_memory_needed = model_memory + kv_cache_memory + 2  # 2GB系统开销
        
        # 计算最大批大小
        available_memory = gpu_spec.memory_gb - model_memory - 2
        max_batch_size = int(available_memory / (kv_cache_memory / batch_size)) if kv_cache_memory > 0 else batch_size
        
        # 估算吞吐量
        base_throughput = gpu_spec.inference_throughput
        adjusted_throughput = base_throughput * min(max_batch_size / batch_size, 1.0)
        
        return {
            "gpu": gpu_name,
            "model_memory_gb": model_memory,
            "kv_cache_memory_gb": round(kv_cache_memory, 2),
            "total_memory_needed_gb": round(total_memory_needed, 2),
            "memory_utilization": f"{total_memory_needed/gpu_spec.memory_gb:.1%}",
            "max_batch_size": max_batch_size,
            "estimated_throughput": int(adjusted_throughput),
            "memory_sufficient": total_memory_needed <= gpu_spec.memory_gb,
            "cost_per_1k_tokens": self.calculate_inference_cost(gpu_spec, adjusted_throughput)
        }
    
    def estimate_kv_cache_memory(self, sequence_length: int, batch_size: int, model_size_gb: float) -> float:
        """估算KV缓存内存需求"""
        # 简化的KV缓存计算
        # 实际公式：2 * num_layers * num_heads * head_dim * sequence_length * batch_size * bytes_per_element
        
        # 根据模型大小估算层数和头数
        if model_size_gb <= 15:  # 7B模型
            num_layers, num_heads, head_dim = 32, 32, 128
        elif model_size_gb <= 30:  # 13B模型
            num_layers, num_heads, head_dim = 40, 40, 128
        else:  # 70B+模型
            num_layers, num_heads, head_dim = 80, 64, 128
        
        # KV缓存大小（FP16，2字节）
        kv_cache_bytes = 2 * num_layers * num_heads * head_dim * sequence_length * batch_size * 2
        kv_cache_gb = kv_cache_bytes / (1024**3)
        
        return kv_cache_gb
    
    def calculate_inference_cost(self, gpu_spec: GPUCostAnalysis, throughput: float) -> float:
        """计算推理成本"""
        # 每小时成本 = 电费 + 折旧
        hourly_power_cost = gpu_spec.power_consumption / 1000 * optimizer.electricity_cost_per_kwh
        hourly_depreciation = gpu_spec.purchase_price / (3 * 365 * 24)  # 3年折旧
        
        total_hourly_cost = hourly_power_cost + hourly_depreciation
        
        # 每1000 tokens成本
        tokens_per_hour = throughput * 3600
        cost_per_1k_tokens = (total_hourly_cost / tokens_per_hour) * 1000
        
        return round(cost_per_1k_tokens, 6)

# 推理选择器使用示例
inference_selector = LLMInferenceGPUSelector()

# 分析不同GPU的推理能力
models_to_analyze = [
    {"name": "Llama-7B", "size_gb": 14},
    {"name": "Llama-70B", "size_gb": 140},
    {"name": "GPT-3.5", "size_gb": 350}
]

print("推理容量分析:")
for model in models_to_analyze:
    print(f"\n{model['name']} 推理容量:")
    
    for gpu_name in ["RTX-4090", "L40S", "A100-80GB", "H100-80GB"]:
        capacity = inference_selector.calculate_inference_capacity(
            gpu_name, 
            model["size_gb"],
            sequence_length=2048,
            batch_size=16
        )
        
        if capacity.get("memory_sufficient"):
            print(f"  {gpu_name}: ✅ {capacity['estimated_throughput']:,} tokens/s, "
                  f"成本 ${capacity['cost_per_1k_tokens']:.6f}/1K tokens")
        else:
            print(f"  {gpu_name}: ❌ 显存不足 ({capacity['total_memory_needed_gb']:.1f}GB needed)")