# 使用 AutoGPTQ 量化 DeepSeek 模型
pip install auto-gptq

# 量化脚本核心代码
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer

quantize_config = BaseQuantizeConfig(
    bits=4,                      # 量化比特数
    group_size=128,              # 分组大小
    damp_percent=0.01,           # 阻尼系数
    desc_act=False,              # 是否按激活值排序
    sym=True,                    # 对称量化
    true_sequential=True,        # 逐层顺序量化
)

model = AutoGPTQForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V3-Base",
    quantize_config,
    trust_remote_code=True,
    device_map="auto",
)

# 准备校准数据
calib_texts = [...]  # 从训练集中采样 128 条
model.quantize(calib_texts, use_triton=True)

# 保存量化模型
model.save_quantized("./deepseek-v3-4bit-g128")

# 评估量化前后的模型输出差异
import torch
from transformers import AutoTokenizer

def evaluate_quantization_impact(original_model, quantized_model, test_prompts):
    tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3-Base")

    total_kl_div = 0
    total_cos_sim = 0

    for prompt in test_prompts:
        inputs = tokenizer(prompt, return_tensors="pt")

        with torch.no_grad():
            orig_logits = original_model(**inputs).logits
            quant_logits = quantized_model(**inputs).logits

        # KL 散度
        orig_probs = torch.softmax(orig_logits, dim=-1)
        quant_probs = torch.softmax(quant_logits, dim=-1)
        kl_div = torch.sum(orig_probs * torch.log(orig_probs / (quant_probs + 1e-10)))

        # Cosine 相似度
        cos_sim = torch.nn.functional.cosine_similarity(
            orig_logits.flatten(), quant_logits.flatten(), dim=0
        )

        total_kl_div += kl_div.item()
        total_cos_sim += cos_sim.item()

    return {
        "avg_kl_divergence": total_kl_div / len(test_prompts),
        "avg_cos_similarity": total_cos_sim / len(test_prompts),
    }

# deploy_deepseek_vllm.py
from vllm import LLM, SamplingParams
from vllm.distributed import distributed_init

# 配置模型加载参数
model_path = "./deepseek-v3-4bit-g128"

llm = LLM(
    model=model_path,
    tensor_parallel_size=8,       # 8 卡张量并行
    dtype="float16",              # 计算时使用 FP16
    quantization="gptq",          # 使用 GPTQ 量化
    trust_remote_code=True,       # DeepSeek 需要
    max_model_len=8192,           # 最大上下文长度
    gpu_memory_utilization=0.90,  # 显存利用率
    enforce_eager=False,          # 使用 CUDA graph 优化
    max_num_batched_tokens=4096,  # 批处理 Token 上限
    max_num_seqs=128,             # 最大并发序列数
    enable_prefix_caching=True,   # 启用前缀缓存
    distributed_executor_backend="ray",  # 分布式后端
)

# 采样参数配置
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=2048,
    stop=["</s>", "User:", "###"],
)

# 推理执行
outputs = llm.generate(prompts, sampling_params)

# 使用 SGLang 部署 DeepSeek-R1
from sglang import function, system, user, assistant, gen, set_default_backend, Runtime

runtime = Runtime(
    model_path="./deepseek-v3-4bit-g128",
    tp_size=8,
    trust_remote_code=True,
    enable_moe_ep=True,          # 启用 Expert Parallelism
    enable_moe_ep_mp=True,      # 启用混合 EP+TP
    schedule_policy="lpm",       # 使用最短处理时间优先调度
    attention_backend="flashinfer",  # 使用 FlashInfer 后端
    mem_fraction_static=0.85,    # 静态显存分配比例
    max_total_tokens=16384,
    chunked_prefill_size=4096,   # 分块 Prefill 大小
)

@function
def deepseek_chat(system_prompt, user_message):
    system(system_prompt)
    user(user_message)
    assistant(gen(
        "response",
        max_tokens=4096,
        temperature=0.6,
        top_p=0.95,
    ))
    return {"response": response}

# vLLM 中启用 KV Cache 量化
llm = LLM(
    model=model_path,
    kv_cache_dtype="fp8_e5m2",         # FP8 KV Cache
    quantization_param_path="./kv_cache_scale.json",  # 缩放因子
)

# 自定义 KV Cache 量化策略
from vllm.model_executor.layers.quantization import KV_CACHE_SCHEMA

# 对 attention 层的关键通道使用更高精度
custom_kv_config = {
    "attention": {
        "num_heads": 128,
        "head_dim": 128,
        "k_proj": {"dtype": "fp8_e4m3", "channels": "all"},
        "v_proj": {"dtype": "fp8_e5m2", "channels": "all"},
    }
}

# vLLM 的前缀缓存配置
llm = LLM(
    model=model_path,
    enable_prefix_caching=True,
    max_num_batched_tokens=8192,
    # 自动缓存长度超过 512 Token 的公共前缀
)

# 实际效果检验
def test_prefix_caching_effect():
    shared_prefix = "你是一个专业的技术助手，请用中文回答以下问题..."

    prompts = [
        shared_prefix + "什么是 KV Cache？",
        shared_prefix + "什么是 Flash Attention？",
        shared_prefix + "什么是 MoE？",
    ]

    # 第一次请求（无缓存）
    # 第二次和第三次请求（共享前缀命中缓存）
    # 理论上可以节省 60-70% 的 Prefill 时间
    outputs = llm.generate(prompts, sampling_params)

# vLLM 的连续批处理机制
llm = LLM(
    model=model_path,
    max_num_seqs=256,               # 并发序列数
    max_num_batched_tokens=8192,    # 最大批处理 Token 数
    scheduling_policy="fcfs",       # 先来先服务调度
)

# 实时监控批处理状态
from vllm.metrics import MetricsCollector
from vllm.utils import get_open_port

metrics = MetricsCollector(
    llm.llm_engine,
    port=get_open_port(),
)
metrics.start()

from vllm import LLM, SamplingParams

llm = LLM(
    model=model_path,
    speculative_model="self",       # 自投机模式
    num_speculative_tokens=5,       # 每次猜测 5 个 Token
    speculative_draft_tp=1,         # 草稿模型用 1 张卡
    speculative_verify_tp=8,        # 验证模型用 8 张卡
)

# 预期加速比：1.5x - 2.0x

# Medusa 的加速效果通常比 Self-Speculation 更好
# 但需要额外训练 head，适合固定部署场景
from vllm.model_executor.models.medusa import MedusaModel

# 加载训练好的 Medusa head
medusa_model = MedusaModel.from_pretrained(
    model_path,
    medusa_num_heads=4,
    medusa_num_layers=1,
)

# 1. 在 MaaS 上创建推理服务端
maas-cli service create \
    --name deepseek-r1-demo \
    --model-path obs://models/deepseek-r1-4bit-g128/ \
    --engine vllm \
    --instance-type flexus-x-4p \    # Flexus X 实例规格
    --instance-count 2 \              # 两个实例做负载均衡
    --max-model-len 16384 \
    --tensor-parallel-size 4 \        # 4 卡张量并行
    --quantization gptq

# 2. 配置自动扩缩容
maas-cli autoscale create \
    --service deepseek-r1-demo \
    --min-instances 1 \
    --max-instances 8 \
    --target-gpu-util 80 \            # GPU 利用率目标
    --cooldown-seconds 300

# 3. 部署 API 端点
maas-cli endpoint create \
    --service deepseek-r1-demo \
    --type chat \
    --routing least-connections

# dify-deepseek-integration.yaml
# Dify 模型提供者配置
model_providers:
  - provider: huawei_maas
    models:
      - name: deepseek-r1-chat
        type: llm
        config:
          endpoint: https://maas-api.huaweicloud.com/v1
          api_key: ${MAAS_API_KEY}
          deployment_id: deepseek-r1-demo
          parameters:
            temperature: 0.7
            max_tokens: 4096
            top_p: 0.95

# RAG 知识库配置
  - provider: huawei_maas
    embedding:
      model: deepseek-embedding
      dimension: 2048

# 工作流配置
workflows:
  - name: deepseek-rag-agent
    nodes:
      - type: llm
        model: deepseek-r1-chat
        system_prompt: "你是基于 DeepSeek-R1 的智能助手..."
      - type: knowledge_retrieval
        top_k: 5
      - type: code_executor
        language: python

# 模型预热脚本
def warmup_model(llm, num_warmup=5):
    """使用空请求预热模型"""
    warmup_prompt = "你好"
    warmup_params = SamplingParams(
        max_tokens=1,      # 只生成一个 Token
        temperature=0,
    )

    print("执行模型预热...")
    for i in range(num_warmup):
        llm.generate([warmup_prompt], warmup_params)
        print(f"  预热轮次 {i+1}/{num_warmup} 完成")
    print("模型预热完成 ✓")

# 安装依赖
pip install torch==2.4.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
pip install vllm==0.6.2 transformers auto-gptq

# 验证 GPU 环境
nvidia-smi
python -c "import torch; print(f'CUDA可用: {torch.cuda.is_available()}'); print(f'GPU数: {torch.cuda.device_count()}')"

# 下载 DeepSeek-V3 原始模型（约 1.3TB FP16）
huggingface-cli download deepseek-ai/DeepSeek-V3-Base --local-dir ./models/DeepSeek-V3-Base

# 执行 GPTQ INT4 量化
python quantize_deepseek.py \
    --model-path ./models/DeepSeek-V3-Base \
    --output-path ./models/DeepSeek-V3-4bit \
    --bits 4 \
    --group-size 128

echo "量化完成！模型大小: $(du -sh ./models/DeepSeek-V3-4bit | cut -f1)"

# serve_deepseek.py
from vllm import AsyncEngineArgs, AsyncLLMEngine
from vllm.entrypoints.openai.api_server import run_server
import uvicorn

# 配置服务参数
engine_args = AsyncEngineArgs(
    model="./models/DeepSeek-V3-4bit",
    tensor_parallel_size=8,
    quantization="gptq",
    trust_remote_code=True,
    max_model_len=8192,
    gpu_memory_utilization=0.90,
    enable_prefix_caching=True,
)

# 启动 OpenAI 兼容的 API 服务
if __name__ == "__main__":
    uvicorn.run(
        run_server(engine_args),
        host="0.0.0.0",
        port=8000,
    )

# test_deepseek_api.py
import openai

client = openai.OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="sk-"  # vLLM 不验证 API Key
)

response = client.chat.completions.create(
    model="deepseek-v3",
    messages=[
        {"role": "system", "content": "你是一个专业的技术顾问"},
        {"role": "user", "content": "请用通俗的语言解释 MoE 架构的工作原理"}
    ],
    temperature=0.7,
    max_tokens=2048,
    stream=True,
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)