大模型微调成本分析：LoRA/QLoRA/全参数的费用对比

总成本 = 训练成本 + 存储成本 + 部署成本 + 人力成本
         (GPU)     (模型存储)   (推理)     (工程)

class MemoryEstimator:
    """估算不同微调方法的显存需求"""
    
    def estimate(self, model_size_b: float, method: str):
        # 基础模型显存（bfloat16）
        base_memory = model_size_b * 2  # 2 bytes per param (bf16)
        
        # 训练状态显存（梯度 + 优化器状态）
        if method == "full":
            # Adam: 2x params for optimizer states + 1x for gradients
            training_overhead = base_memory * 3  # 8 bytes/param total
        elif method == "lora":
            # 只有 LoRA 参数需要梯度+优化器（约 0.5% 的参数）
            trainable_ratio = 0.005
            training_overhead = base_memory * trainable_ratio * 3
        elif method == "qlora":
            # 基础模型量化到 4bit
            base_memory = model_size_b * 0.5  # 0.5 bytes per param (4bit)
            trainable_ratio = 0.005
            training_overhead = base_memory * trainable_ratio * 3
        
        # 激活值显存（与 batch_size 和 seq_length 相关）
        activation_memory = self._estimate_activation(model_size_b, method)
        
        total = base_memory + training_overhead + activation_memory
        
        return {
            "base_model": base_memory,
            "training_overhead": training_overhead,
            "activation": activation_memory,
            "total": total,
            "total_gb": total / 1024
        }

class StorageCostAnalyzer:
    def analyze(self, model_size_b: float, method: str):
        if method == "full":
            # 全参数微调：保存完整模型权重
            storage = model_size_b * 2  # bf16
        elif method == "lora":
            # LoRA：只保存适配器权重（约 0.5%）
            storage = model_size_b * 2 * 0.005
        elif method == "qlora":
            # QLoRA：保存量化权重 + LoRA 适配器
            storage = model_size_b * 0.5 + model_size_b * 2 * 0.005
        
        return {
            "model_size_gb": storage / 1024,
            "monthly_storage_cost": storage / 1024 * 0.023,  # S3 价格
            "versions_10": storage / 1024 * 10 * 0.023  # 保存10个版本
        }

class InferenceCostAnalyzer:
    def analyze(self, model_size_b: float, method: str, qps: int = 10):
        # LoRA：可以合并到基础模型，推理无额外开销
        if method == "lora":
            return self._base_inference_cost(model_size_b, qps)
        
        # QLoRA：推理时需要反量化，有约 5-10% 开销
        elif method == "qlora":
            base = self._base_inference_cost(model_size_b, qps)
            return base * 1.08  # 8% overhead
        
        # 全参数：直接推理
        elif method == "full":
            return self._base_inference_cost(model_size_b, qps)
    
    def _base_inference_cost(self, model_size_b: float, qps: int):
        # GPU 需求
        if model_size_b <= 7:
            gpu = "1× A10 24GB"
            cost_per_hour = 0.75
        elif model_size_b <= 14:
            gpu = "1× A100 40GB"
            cost_per_hour = 2.0
        elif model_size_b <= 70:
            gpu = "2× A100 80GB"
            cost_per_hour = 8.0
        
        monthly_hours = 730
        return {
            "gpu_requirement": gpu,
            "hourly_cost": cost_per_hour,
            "monthly_cost": cost_per_hour * monthly_hours,
            "cost_per_1k_requests": cost_per_hour * 1000 / (qps * 3600)
        }

# vLLM 支持 LoRA 动态加载，一个基础模型服务多个 LoRA
"""
vLLM 启动命令：
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-lora \
    --lora-modules \
        medical=./loras/medical \
        legal=./loras/legal \
        finance=./loras/finance \
    --max-loras-per-gpu 4 \
    --max-lora-rank 64

一个 7B 基础模型 + 多个 LoRA 适配器
总显存：~16GB (基础) + 4×0.07GB (LoRA) = ~16.3GB
比部署4个独立模型节省 75% 显存
"""

class CostOptimizer:
    def optimize(self, requirements: dict):
        recommendations = []
        
        # 策略1：选择最经济的微调方法
        if requirements["model_size"] <= 7:
            recommendations.append({
                "strategy": "使用 LoRA + A10 GPU",
                "savings": "比全参数节省 92%",
                "quality_loss": "极小 (<2%)"
            })
        elif requirements["model_size"] <= 70:
            recommendations.append({
                "strategy": "使用 QLoRA + A100 GPU",
                "savings": "比全参数节省 94%",
                "quality_loss": "小 (<5%)"
            })
        
        # 策略2：LoRA 动态加载
        if requirements["num_domains"] > 1:
            recommendations.append({
                "strategy": f"使用 vLLM LoRA 动态加载 {requirements['num_domains']} 个适配器",
                "savings": f"比部署 {requirements['num_domains']} 个模型节省 {100 - 100/requirements['num_domains']}%",
                "quality_loss": "无"
            })
        
        # 策略3：Spot Instance
        recommendations.append({
            "strategy": "使用 Spot Instance 训练",
            "savings": "比按需实例节省 60-70%",
            "risk": "可能被中断，需要支持断点续训"
        })
        
        # 策略4：模型蒸馏替代
        if requirements["model_size"] > 30:
            recommendations.append({
                "strategy": "用大模型蒸馏到 7B 模型",
                "savings": "推理成本降低 80%+",
                "quality_loss": "中等 (5-15%)"
            })
        
        return recommendations

预算 < $100/月？
├─ 是 → QLoRA + 7B 模型 + 单 A10 GPU
└─ 否 → 需要最高质量？
         ├─ 是 → 预算 > $10K/月？
         │        ├─ 是 → 全参数微调
         │        └─ 否 → LoRA + 大模型
         └─ 否 → 多领域？
                  ├─ 是 → LoRA + vLLM 动态加载
                  └─ 否 → LoRA + 单模型