2. 训练 vs 推理：真正烧钱的是哪一步

def calculate_training_cost(model_params: int, data_size: int, gpu_count: int, 
                          gpu_cost_per_hour: float, training_days: int) -> float:
    """
    计算训练成本
    
    参数：
    - model_params: 模型参数数量（万亿）
    - data_size: 训练数据量（万亿Token）
    - gpu_count: GPU数量
    - gpu_cost_per_hour: GPU每小时成本（美元）
    - training_days: 训练天数
    
    返回：
    - 训练总成本（美元）
    """
    total_hours = training_days * 24
    total_cost = gpu_count * gpu_cost_per_hour * total_hours
    
    return total_cost

def calculate_inference_cost(model_size_gb: float, context_length: int, 
                             daily_requests: int, gpu_cost_per_hour: float, 
                             batch_size: int, latency_target: float) -> float:
    """
    计算推理成本
    
    参数：
    - model_size_gb: 模型大小（GB）
    - context_length: 上下文长度
    - daily_requests: 每日请求量
    - gpu_cost_per_hour: GPU每小时成本（美元）
    - batch_size: Batch Size
    - latency_target: 延迟目标（秒）
    
    返回：
    - 每日推理成本（美元）
    """
    # 估算每GPU每秒可处理的请求数
    requests_per_gpu_per_second = batch_size / latency_target
    
    # 所需GPU数量
    required_gpus = math.ceil(daily_requests / (requests_per_gpu_per_second * 3600 * 24))
    
    # 每日成本
    daily_cost = required_gpus * gpu_cost_per_hour * 24
    
    return daily_cost

# 来源：vllm/scheduler.py
class Scheduler:
    def __init__(self, max_num_seqs: int, max_num_batched_tokens: int):
        self.max_num_seqs = max_num_seqs
        self.max_num_batched_tokens = max_num_batched_tokens
        self.waiting = []
        self.running = []
        self.swapped = []
    
    def add_request(self, request_id: str, prompt: str, max_tokens: int):
        """添加新请求"""
        request = {
            "request_id": request_id,
            "prompt": prompt,
            "max_tokens": max_tokens,
            "generated_tokens": 0,
            "state": "waiting"
        }
        self.waiting.append(request)
    
    def step(self):
        """执行一个调度步骤"""
        # 1. 将等待的请求添加到运行批次中
        self._add_waiting_to_running()
        
        # 2. 执行模型推理
        self._execute_inference()
        
        # 3. 检查请求完成情况
        self._check_completion()
        
        return self.running
    
    def _add_waiting_to_running(self):
        """将等待的请求添加到运行批次中"""
        while self.waiting and len(self.running) < self.max_num_seqs:
            # 计算当前批次的总Token数
            current_tokens = sum(len(req["prompt"]) + req["generated_tokens"] for req in self.running)
            
            # 获取下一个请求
            next_req = self.waiting[0]
            next_req_tokens = len(next_req["prompt"]) + next_req["generated_tokens"]
            
            # 检查是否超过最大Token数限制
            if current_tokens + next_req_tokens <= self.max_num_batched_tokens:
                # 将请求从等待队列移到运行队列
                self.running.append(self.waiting.pop(0))
                self.running[-1]["state"] = "running"
            else:
                break

from vllm import LLM, SamplingParams

# 配置量化参数
llm = LLM(
    model="meta-llama/Llama-3-70B",
    quantization="AWQ",  # 支持 AWQ, GPTQ, FP8, INT8, INT4
    dtype="float16",
    gpu_memory_utilization=0.9,
)

# 生成文本
sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
prompts = ["Hello, my name is", "The capital of France is"]
outputs = llm.generate(prompts, sampling_params)