🏗️ 大模型架构、训练与部署

2.4.3 高级 Prompt 技术

3. 大模型微调

3.1 微调方法概览

┌─────────────────────────────────────────────────────────┐
│                  微调方法谱系                           │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  按参数更新范围：                                        │
│                                                         │
│  全参数微调 (Full Fine-tuning)                          │
│  ├── 更新所有参数                                       │
│  ├── 效果最好，但成本最高                               │
│  └── 需要大量显存和计算资源                              │
│                                                         │
│  参数高效微调 (PEFT)                                    │
│  ├── LoRA：低秩适配                                     │
│  ├── QLoRA：量化 + LoRA                                 │
│  ├── Prefix Tuning：前缀调优                            │
│  ├── P-Tuning v2：深度提示调优                          │
│  ├── Adapter：适配器层                                  │
│  └── IA3：抑制和放大内部激活                            │
│                                                         │
└─────────────────────────────────────────────────────────┘

3.2 LoRA 详解

LoRA (Low-Rank Adaptation) 是最流行的参数高效微调方法。

┌─────────────────────────────────────────────────────────┐
│                    LoRA 原理                            │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  原始权重矩阵 W (d × k)                                  │
│                                                         │
│       ┌───────────────┐                                │
│  x ──→│   W (冻结)     │──→ y                           │
│       └───────────────┘                                │
│              +                                          │
│       ┌─────┐   ┌─────┐                                │
│  x ──→│  A  │──→│  B  │──→ Δy                          │
│       └─────┘   └─────┘                                │
│       (d × r)   (r × k)                                │
│                                                         │
│  最终输出：y' = Wx + BAx                                │
│                                                         │
│  核心思想：                                              │
│  - 冻结原始权重 W                                        │
│  - 新增低秩矩阵 A、B (r << d, k)                         │
│  - 只训练 A、B，参数量大幅减少                           │
│  - 例：r=8 时，参数量减少 ~10000 倍                      │
│                                                         │
└─────────────────────────────────────────────────────────┘

3.3 微调实践代码

3.3.1 使用 PEFT + LoRA 微调

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
from datasets import load_dataset

# 1. 加载基座模型
model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 2. 配置 LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,                      # 低秩维度
    lora_alpha=32,            # 缩放因子
    lora_dropout=0.1,         # Dropout
    target_modules=[          # 要适配的模块
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
)

# 3. 应用 LoRA
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出：trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.0622

# 4. 准备数据集
dataset = load_dataset("json", data_files="train_data.json")

def format_instruction(example):
    return f"""### 指令：
{example['instruction']}

### 回答：
{example['output']}"""

# 5. 训练配置
training_args = TrainingArguments(
    output_dir="./lora_output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
    warmup_ratio=0.03,
)

# 6. 训练
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    formatting_func=format_instruction,
    max_seq_length=512,
)

trainer.train()

# 7. 保存 LoRA 权重
model.save_pretrained("./lora_weights")

from transformers import BitsAndBytesConfig
import torch

# 4-bit 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto"
)

# 后续与 LoRA 相同...

# Alpaca 格式（最常用）
{
    "instruction": "将以下句子翻译成英文",
    "input": "今天天气很好",
    "output": "The weather is nice today."
}

# ShareGPT 格式（多轮对话）
{
    "conversations": [
        {"from": "human", "value": "你好"},
        {"from": "gpt", "value": "你好！有什么我可以帮助你的吗？"},
        {"from": "human", "value": "介绍一下北京"},
        {"from": "gpt", "value": "北京是中国的首都..."}
    ]
}

# OpenAI 格式
{
    "messages": [
        {"role": "system", "content": "你是一个有帮助的助手"},
        {"role": "user", "content": "你好"},
        {"role": "assistant", "content": "你好！有什么可以帮你的？"}
    ]
}

┌─────────────────────────────────────────────────────────┐
│                 推理优化技术栈                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  🔢 模型压缩                                            │
│  ├── 量化 (Quantization)                               │
│  │   ├── INT8：精度损失小，推理快 2x                    │
│  │   ├── INT4：精度有损，显存省 4x                      │
│  │   └── GPTQ/AWQ/GGUF：不同量化方案                   │
│  ├── 剪枝 (Pruning)                                    │
│  │   └── 移除不重要的参数                               │
│  └── 蒸馏 (Distillation)                               │
│      └── 大模型知识迁移到小模型                          │
│                                                         │
│  ⚡ 推理加速                                            │
│  ├── KV Cache：缓存注意力键值对                         │
│  ├── Flash Attention：高效注意力计算                   │
│  ├── Continuous Batching：动态批处理                   │
│  ├── Speculative Decoding：推测解码                    │
│  └── PagedAttention：分页注意力 (vLLM)                 │
│                                                         │
│  🖥️ 硬件优化                                           │
│  ├── TensorRT：NVIDIA GPU 优化                         │
│  ├── ONNX Runtime：跨平台加速                          │
│  └── 算子融合：减少内存访问                             │
│                                                         │
└─────────────────────────────────────────────────────────┘

# 使用 bitsandbytes 量化加载
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# INT8 量化
model_8bit = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_8bit=True,
    device_map="auto"
)

# INT4 量化
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)
model_4bit = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=bnb_config,
    device_map="auto"
)

# 安装：pip install vllm

from vllm import LLM, SamplingParams

# 1. 加载模型
llm = LLM(
    model="meta-llama/Llama-2-7b-chat-hf",
    tensor_parallel_size=1,  # GPU 数量
    dtype="float16",
    max_model_len=4096,
)

# 2. 设置采样参数
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512,
)

# 3. 推理
prompts = ["请介绍一下人工智能", "Python有什么优点？"]
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

# vLLM 启动 API 服务
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --port 8000 \
    --tensor-parallel-size 1

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 下载并运行模型
ollama pull llama3
ollama run llama3

# 使用 API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "什么是大语言模型？"
}'

# Python 调用 Ollama
import ollama

response = ollama.chat(
    model='llama3',
    messages=[{'role': 'user', 'content': '你好'}]
)
print(response['message']['content'])

┌─────────────────────────────────────────────────────────┐
│              生产级 LLM 部署架构                         │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  用户请求                                               │
│      ↓                                                  │
│  ┌─────────────┐                                       │
│  │   API 网关   │  ← 认证、限流、路由                    │
│  └──────┬──────┘                                       │
│         │                                              │
│         ↓                                              │
│  ┌─────────────┐                                       │
│  │  负载均衡   │  ← 分发请求到不同实例                   │
│  └──────┬──────┘                                       │
│         │                                              │
│    ┌────┴────┐                                         │
│    ↓         ↓                                         │
│ ┌──────┐ ┌──────┐                                     │
│ │推理1 │ │推理2 │  ← vLLM/TGI 实例                     │
│ │(GPU) │ │(GPU) │                                     │
│ └──────┘ └──────┘                                     │
│    ↑         ↑                                         │
│    └────┬────┘                                         │
│         │                                              │
│  ┌─────────────┐                                       │
│  │  模型存储   │  ← S3/本地/模型仓库                    │
│  └─────────────┘                                       │
│                                                         │
│  监控组件：Prometheus + Grafana                         │
│  日志组件：ELK Stack                                    │
│                                                         │
└─────────────────────────────────────────────────────────┘

数据质量金字塔：

        ┌─────────┐
        │ 高质量  │  ← 人工标注、专家校验
        │  数据   │     效果最好，成本最高
        ├─────────┤
        │ 合成数据 │  ← GPT-4 生成、自我指令
        │         │     平衡效果与成本
        ├─────────┤
        │ 网络数据 │  ← CommonCrawl、网页爬取
        │         │     量大质低，需要清洗
        └─────────┘

# 数据处理 Pipeline
data_pipeline = {
    "1. 数据收集": [
        "爬取网页数据",
        "收集开源数据集",
        "生成合成数据"
    ],
    "2. 数据清洗": [
        "去重（MinHash、SimHash）",
        "过滤低质量内容",
        "移除有害/敏感信息",
        "语言检测与分类"
    ],
    "3. 数据处理": [
        "分词 Tokenization",
        "格式标准化",
        "长度裁剪/填充"
    ],
    "4. 数据增强": [
        "回译增强",
        "同义词替换",
        "模型改写"
    ],
    "5. 质量评估": [
        "困惑度评估",
        "人工抽样检查",
        "多样性分析"
    ]
}

# 使用 lm-evaluation-harness 评估
# pip install lm-eval

from lm_eval import evaluator
from lm_eval.models.huggingface import HFLM

# 加载模型
model = HFLM(
    pretrained="meta-llama/Llama-2-7b-hf",
    device="cuda"
)

# 运行评估
results = evaluator.simple_evaluate(
    model=model,
    tasks=["hellaswag", "mmlu", "gsm8k"],
    num_fewshot=5,
    batch_size=8
)

print(results["results"])

# 显存估算公式（近似）
def estimate_memory(params_billion, precision="fp16", training=True):
    """
    params_billion: 参数量（十亿）
    precision: fp32/fp16/int8/int4
    training: 是否训练
    """
    bytes_per_param = {
        "fp32": 4,
        "fp16": 2,
        "bf16": 2,
        "int8": 1,
        "int4": 0.5
    }
    
    # 模型权重
    model_memory = params_billion * bytes_per_param[precision]
    
    if training:
        # 训练时需要额外的优化器状态和梯度
        # AdamW: 参数 + 梯度 + 一阶动量 + 二阶动量 ≈ 4x
        # 加上激活值等，总计约 6-8x
        total_memory = model_memory * 6
    else:
        # 推理时主要是模型权重 + KV Cache
        total_memory = model_memory * 1.2
    
    return f"{total_memory:.1f} GB"

# 示例
print(estimate_memory(7, "fp16", training=True))   # 约 84 GB
print(estimate_memory(7, "fp16", training=False))  # 约 16.8 GB
print(estimate_memory(7, "int4", training=False))  # 约 4.2 GB

┌─────────────────────────────────────────────────────────┐
│                  训练工具生态                           │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  🔧 训练框架                                            │
│  ├── Hugging Face Transformers                         │
│  ├── DeepSpeed                                         │
│  ├── Megatron-LM                                       │
│  ├── ColossalAI                                        │
│  └── LLaMA-Factory                                     │
│                                                         │
│  📊 实验管理                                            │
│  ├── Weights & Biases                                  │
│  ├── MLflow                                            │
│  └── TensorBoard                                       │
│                                                         │
│  🗃️ 数据处理                                           │
│  ├── Datasets (HuggingFace)                            │
│  ├── Apache Spark                                      │
│  └── Dask                                              │
│                                                         │
│  ☁️ 云平台                                              │
│  ├── AWS SageMaker                                     │
│  ├── Google Vertex AI                                  │
│  ├── Azure ML                                          │
│  └── AutoDL / 恒源云（国内）                            │
│                                                         │
└─────────────────────────────────────────────────────────┘

基础 → 实践 → 深入

1️⃣ 基础理论
   • Transformer 架构原理
   • 注意力机制
   • 预训练目标

2️⃣ 动手实践
   • 使用 HuggingFace 微调模型
   • 尝试 LoRA/QLoRA
   • 本地部署 Ollama

3️⃣ 深入优化
   • 分布式训练
   • 推理优化
   • 生产部署