AI Infra 知识全景学习笔记

┌─────────────────────────────────────────────────────────┐
│                 AI 应用 / Agent / API                    │
├─────────────────────────────────────────────────────────┤
│ 推理层：Serving / Gateway / Routing / Cache / Autoscale │
├─────────────────────────────────────────────────────────┤
│ 模型层：训练 / 微调 / RL / 评测 / Registry / Artifact   │
├─────────────────────────────────────────────────────────┤
│ 平台层：Kubernetes / Scheduler / MLOps / CI/CD          │
├─────────────────────────────────────────────────────────┤
│ 数据层：Object Storage / File System / Dataset / ETL    │
├─────────────────────────────────────────────────────────┤
│ 资源层：GPU / TPU / NPU / CPU / Memory / Storage        │
├─────────────────────────────────────────────────────────┤
│ 网络与机房：RDMA / RoCE / InfiniBand / Ethernet / DC    │
└─────────────────────────────────────────────────────────┘

横向能力：
Security / Compliance / Observability / FinOps / IAM / Audit

更高 GPU 利用率
+ 更好的 AllReduce/AllToAll 通信效率
+ 更快 checkpoint
+ 故障恢复
+ 大规模并行

TTFT
+ TPOT
+ QPS
+ P95/P99 latency
+ KV Cache 命中率
+ tokens/s/GPU
+ cost / million tokens

芯片计算能力
      ↓
显存容量与显存带宽
      ↓
节点内互联
      ↓
节点间网络
      ↓
Collective 通信库
      ↓
分布式训练实现
      ↓
模型结构
      ↓
真实训练 goodput / 推理 tokens/s

flowchart LR
    A[用户 Prompt] --> B[Prefill 阶段]
    B --> C[生成 KV Cache]
    C --> D[Decode 阶段]
    D --> E[Token 1]
    E --> F[Token 2]
    F --> G[Token N]

Replica 1: Prefill + Decode
Replica 2: Prefill + Decode
Replica 3: Prefill + Decode

                  ┌── Prefill Pool ──┐
Request Router ───┤                  ├── KV Transfer ── Decode Pool
                  └──────────────────┘

模型参数数量 → 需要多少 GPU

模型权重
+ KV Cache
+ 最大上下文
+ 平均输入长度
+ 平均输出长度
+ 并发量
+ Prefix 命中率
+ 精度 / 量化方式
→ 所需 GPU 与网络

权重：FP8 / FP4
KV Cache：FP8
部分敏感算子：BF16
Embedding：BF16
通信：低精度
累加：更高精度

业务代码
   ↓
训练 / Serving Framework
   ↓
Runtime Adapter
   ↓
Scheduler
   ↓
不同 GPU / NPU / TPU

总成本
= GPU 小时
+ CPU 小时
+ 存储
+ 数据读写
+ 公网/跨地域流量
+ 负载均衡
+ 日志与监控
+ 平台费用
+ 平台研发人员
+ GPU 空闲
+ 训练失败重跑

flowchart TB

    U[开发者 / 算法工程师]
    GIT[Git / CI/CD]
    REG[镜像仓库]

    subgraph Data["数据平面"]
        COS[对象存储 COS]
        FS[共享文件系统 CFS / GooseFS]
        META[Dataset Catalog / Metadata]
    end

    subgraph Platform["AI 平台层"]
        NB[Notebook / IDE]
        TRAIN[Distributed Training]
        WF[Workflow / Pipeline]
        MR[Model Registry]
        EVAL[Evaluation]
        SERVE[Model Serving]
    end

    subgraph Compute["计算与调度层"]
        K8S[Kubernetes / TKE]
        SCHED[GPU Scheduler]
        GPU[GPU / NPU / Accelerator Pool]
        HCC[HCC / RDMA Network]
    end

    subgraph Runtime["模型 Runtime"]
        TORCH[PyTorch / DeepSpeed]
        RAY[Ray]
        VLLM[vLLM / SGLang]
        TRT[TensorRT-LLM / Dynamo]
    end

    subgraph Ops["运维与治理"]
        MON[Metrics / Monitoring]
        LOG[Logs / Tracing]
        IAM[IAM / Secret]
        AUDIT[Audit]
        COST[Cost / Quota]
    end

    U --> NB
    U --> GIT
    GIT --> REG

    COS --> TRAIN
    FS --> TRAIN
    META --> WF

    WF --> TRAIN
    TRAIN --> MR
    MR --> EVAL
    EVAL --> SERVE

    TRAIN --> TORCH
    TRAIN --> RAY
    SERVE --> VLLM
    SERVE --> TRT

    K8S --> SCHED
    SCHED --> GPU
    GPU --> HCC

    REG --> K8S

    Platform --> Ops
    Compute --> Ops

GPU
 ↓ NVLink / equivalent
Node
 ↓ RDMA
Top-of-Rack
 ↓ high-bandwidth fabric
Cluster

Cold / Durable
对象存储
COS / S3-like
        ↓
Warm
共享文件系统 / 分布式 Cache
CFS / GooseFS
        ↓
Hot
Local NVMe / Memory Cache

dataset read GB/s
metadata ops/s
checkpoint write GB/s
startup time
cache hit ratio
GPU data stall time

Model Code
   ↓
PyTorch / JAX
   ↓
FSDP / DeepSpeed / Megatron-like Parallelism
   ↓
NCCL / Collective Runtime
   ↓
CUDA / ROCm / Accelerator Runtime
   ↓
GPU

DP = 8
TP = 4
PP = 2

总 GPU = 8 × 4 × 2 = 64

L1 Hardware
GPU utilization
HBM usage
temperature
power
ECC / hardware errors

L2 Runtime
NCCL latency
OOM
CUDA errors
KV cache usage

L3 Model
tokens/s
TTFT
TPOT
batch size
queue length

L4 Service
QPS
P50/P95/P99
HTTP error
timeout
SLO

flowchart LR
    A[Git Commit] --> B[Unit Test]
    B --> C[Build Container]
    C --> D[Image Scan]
    D --> E[Push Registry]
    E --> F[Staging Deployment]
    F --> G[Offline Evaluation]
    G --> H[Security Evaluation]
    H --> I{Gate}
    I -->|Pass| J[Canary]
    I -->|Fail| K[Reject]
    J --> L[Production]
    L --> M[Monitoring]
    M --> N{SLO / Quality OK?}
    N -->|Yes| L
    N -->|No| O[Rollback]

git_commit
container_digest
model_id
model_hash
dataset_version
training_config
evaluation_report
deployment_version
operator
timestamp

Base Model
   ↓
Dataset
   ↓
Tokenization
   ↓
8-GPU Distributed Training
   ↓
Checkpoint
   ↓
Evaluation
   ↓
Model Registry

GPU: 8 × 40~80 GB
CPU: 64+ vCPU
RAM: 256+ GB
共享存储: ≥ 1 TB
本地 NVMe: 建议用于数据 Cache
网络: 单机 8 卡可先不要求 RDMA；跨机训练建议高速 RDMA 网络

{
  "bf16": {
    "enabled": true
  },
  "zero_optimization": {
    "stage": 3,
    "overlap_comm": true,
    "contiguous_gradients": true,
    "reduce_scatter": true,
    "stage3_gather_16bit_weights_on_model_save": true
  },
  "gradient_accumulation_steps": 8,
  "gradient_clipping": 1.0,
  "train_micro_batch_size_per_gpu": 1,
  "steps_per_print": 20,
  "wall_clock_breakdown": false
}

train/
├── train.py
├── ds_config.json
├── data/
│   ├── train.jsonl
│   └── valid.jsonl
└── output/

import os

from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    Trainer,
    TrainingArguments,
    DataCollatorForLanguageModeling,
)

MODEL_PATH = os.environ.get("MODEL_PATH", "/models/base-model")
DATA_PATH = os.environ.get("DATA_PATH", "./data/train.jsonl")
OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "./output")

tokenizer = AutoTokenizer.from_pretrained(
    MODEL_PATH,
    trust_remote_code=False,
)

if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    torch_dtype="auto",
    trust_remote_code=False,
)

# 降低训练阶段 Activation 显存压力。
model.gradient_checkpointing_enable()

dataset = load_dataset(
    "json",
    data_files={"train": DATA_PATH},
)["train"]

def tokenize(batch):
    return tokenizer(
        batch["text"],
        truncation=True,
        max_length=2048,
    )

dataset = dataset.map(
    tokenize,
    batched=True,
    remove_columns=dataset.column_names,
)

args = TrainingArguments(
    output_dir=OUTPUT_DIR,
    num_train_epochs=1,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=8,
    learning_rate=2e-5,
    logging_steps=10,
    save_steps=500,
    save_total_limit=2,
    bf16=True,
    deepspeed="./ds_config.json",
    report_to="none",
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=dataset,
    data_collator=DataCollatorForLanguageModeling(
        tokenizer=tokenizer,
        mlm=False,
    ),
)

trainer.train()
trainer.save_model(OUTPUT_DIR)
tokenizer.save_pretrained(OUTPUT_DIR)

export MODEL_PATH=/models/base-model
export DATA_PATH=/data/train.jsonl
export OUTPUT_DIR=/output/model-v1

deepspeed \
  --num_gpus=8 \
  train.py

model:
  base_model: "base-model"
  base_model_revision: "sha256:REPLACE_ME"

dataset:
  name: "internal-sft-dataset"
  version: "2026-10-01"
  license_verified: true
  pii_reviewed: true

training:
  precision: "bf16"
  sequence_length: 2048
  global_batch_size: 64
  optimizer: "adamw"
  learning_rate: 0.00002
  deepspeed_stage: 3

artifact:
  output: "model-v1"
  git_commit: "REPLACE_ME"
  container_digest: "sha256:REPLACE_ME"

Model V1
= BaseModel@Revision
+ Dataset@Version
+ Code@Commit
+ Container@Digest
+ TrainingConfig

GPU 数量                 = 8
训练时长                 = 12 h
假设有效 GPU 单价        = ¥20 / GPU·h
存储、日志等假设费用     = ¥180
失败重跑预算 Reserve     = 20%

¥ / training run

¥ / successful run
¥ / billion training tokens
tokens / GPU second
GPU utilization
failure rate
checkpoint overhead

任务 A：
成本 ¥2,000
成功率 50%

任务 B：
成本 ¥2,500
成功率 95%

Internet / Internal Client
          ↓
      API Gateway
          ↓
      Kubernetes Service
          ↓
        vLLM Pod
          ↓
        GPU
          ↓
      Model Storage

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-v1
  namespace: ai-serving
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llm-v1
  template:
    metadata:
      labels:
        app: llm-v1
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:<PINNED_TESTED_VERSION>

          command:
            - vllm
            - serve
            - /models/my-model

          args:
            - --host
            - "0.0.0.0"
            - --port
            - "8000"
            - --dtype
            - auto
            - --max-model-len
            - "8192"
            - --gpu-memory-utilization
            - "0.90"
            - --enable-prefix-caching

          ports:
            - containerPort: 8000

          resources:
            limits:
              nvidia.com/gpu: "1"
              cpu: "16"
              memory: "64Gi"
            requests:
              nvidia.com/gpu: "1"
              cpu: "8"
              memory: "32Gi"

          volumeMounts:
            - name: model
              mountPath: /models
              readOnly: true

      volumes:
        - name: model
          persistentVolumeClaim:
            claimName: llm-model-pvc

apiVersion: v1
kind: Service
metadata:
  name: llm-service
  namespace: ai-serving
spec:
  selector:
    app: llm-v1
  ports:
    - name: http
      port: 80
      targetPort: 8000
  type: ClusterIP

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

kubectl -n ai-serving get pods -w

kubectl -n ai-serving port-forward service/llm-service 8000:80

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "/models/my-model",
    "messages": [
      {
        "role": "user",
        "content": "请用一句话解释什么是 AI Infra。"
      }
    ],
    "temperature": 0.2,
    "max_tokens": 128
  }'

CLB / API Gateway
        ↓
TKE Service
        ↓
Inference Pods
        ↓
GPU Node Pool

平均生成速度        = 800 output token/s
平均每请求输出       = 200 token

Prefill
Queue
Batching
KV Cache
Network
Serialization
Prompt length variance
P99 latency requirement

固定模型
固定 GPU
固定 context distribution
固定 output distribution

逐渐增加 QPS
       ↓
观察 TTFT / TPOT / P99
       ↓
找到 SLO 拐点
       ↓
设置安全余量

Input tokens/s
Output tokens/s
Request/s
TTFT P50/P95/P99
TPOT P50/P95/P99
GPU HBM
KV cache utilization
Queue time
GPU utilization

GPU 单价              = ¥12 / GPU·h
单副本 GPU            = 1
运行时间              = 720 h/月
存储、LB、日志等       = ¥600/月

Baseline
 ↓
Continuous Batching
 ↓
KV Cache 调优
 ↓
Prefix Cache
 ↓
Quantization
 ↓
Tensor Parallel
 ↓
Speculative Decoding
 ↓
P/D Disaggregation
 ↓
Multi-node KV Cache

quality
throughput
TTFT
TPOT
P99
memory
cost
failure rate

> **生成式人工智能使用说明**
>
> 本文部分资料整理、结构梳理或语言润色过程使用了生成式人工智能工具辅助。
> 文中的技术结论、代码示例、引用来源及合规相关内容均由作者进行人工复核。
> 如文中包含人工智能生成或合成的图片、文本等内容，将按照适用法律法规及发布平台要求进行相应声明或标识。

是否向境内公众提供生成式 AI 服务？
              │
       ┌──────┴──────┐
       │             │
      否             是
       │             │
内部研发治理      是否具舆论属性
                 或社会动员能力？
                      │
                ┌─────┴─────┐
                │           │
               否           是
                │           │
           常规合规治理   进一步判断
                         安全评估 /
                         算法备案等

Request ID
 ↓
User / Tenant
 ↓
Model Version
 ↓
System Policy Version
 ↓
Prompt Template Version
 ↓
RAG Documents
 ↓
Generation Parameters
 ↓
Output
 ↓
Safety Decision
 ↓
Human Review

R = Responsible，执行者
A = Accountable，最终负责者
C = Consulted，需要咨询
I = Informed，需要知会

### 免责声明与合规说明

本文仅用于技术学习与工程实践交流，不构成法律意见、投资建议、
采购建议、产品承诺或任何形式的官方性能保证。

文中涉及腾讯云及其他厂商产品的功能、规格、地域可用性和计费方式，
均可能随产品迭代发生变化，请以各厂商最新官方文档、控制台及合同为准。

文中的成本数字如未明确标注为官方价格，均属于教学性质的假设性测算，
不代表腾讯云或任何其他厂商的实际报价。

本文涉及的模型、数据集、代码、软件包及第三方组件，
在实际使用前应自行确认其许可证、知识产权、数据来源、
个人信息保护及商业使用条件。

如将相关技术用于面向公众的生成式人工智能服务，
应根据实际业务形态遵守适用的网络安全、数据安全、
个人信息保护、生成式人工智能服务及人工智能生成合成内容标识等相关要求。

本文部分资料整理、结构梳理或文字润色过程可能使用生成式人工智能工具辅助，
相关技术结论、示例代码及引用资料均应由发布者进行人工复核；
涉及人工智能生成合成内容时，应按照适用法律法规及发布平台规则进行声明或标识。

本文不代表腾讯云官方立场。

□ 是否把厂商测试数字写成普遍事实？
□ 是否把示例成本误写成官方报价？
□ 是否引用了来源不明的数据集？
□ 是否展示真实 AccessKey / Token / IP？
□ 是否包含真实客户数据或个人信息？
□ 是否把未经验证的模型输出写成事实？
□ 是否明确 AI 辅助生成情况？
□ 外部图片是否拥有合理使用或转载条件？
□ 开源代码是否说明许可证边界？
□ 是否把产品路线图写成已经正式 GA 的能力？
□ 是否检查链接与产品名称仍然有效？

GPU
Kubernetes
Ray
DeepSpeed
vLLM
Prometheus
...

flowchart TD

    A[业务需求] --> B{训练还是推理?}

    B -->|训练| C[模型大小 / Token / 时限]
    B -->|推理| D[QPS / TTFT / TPOT / Context]

    C --> E{单卡能否容纳?}
    E -->|能| F[单卡/DP]
    E -->|不能| G[FSDP / ZeRO]

    G --> H{单节点能否完成?}
    H -->|能| I[Node-local NVLink]
    H -->|不能| J[RDMA + Multi-node]

    D --> K{单卡能否容纳模型 + KV?}
    K -->|能| L[vLLM / SGLang Single GPU]
    K -->|不能| M[TP / Quantization]

    M --> N{规模是否足够大?}
    N -->|否| O[Co-located Prefill/Decode]
    N -->|是| P[评估 P/D Disaggregation]

    F --> Q[Benchmark]
    I --> Q
    J --> Q
    L --> Q
    O --> Q
    P --> Q

    Q --> R[Cost + SLO + Reliability]

因为单卡显存不够
→ 引入 FSDP

因为单节点显存仍不够
→ 引入 TP/PP

因为网络通信成为瓶颈
→ 升级 RDMA / topology

因为 Decode 被长 Prompt Prefill 阻塞
→ 考虑 P/D 分离

“这个技术最近很热门”
→ 直接上生产

GPU Utilization = 95%

GPU Util = 95%
但：
TTFT = 15s
P99 = 60s
Queue = 10000 requests

GPU Util = 70%
TTFT = 300ms
TPOT = 20ms
SLO = 99.9% achieved

100 张 GPU
有效利用率 = 40%

减少 Idle
    ↓
减少 Failed Jobs
    ↓
提高 Batching
    ↓
提高 Cache Hit
    ↓
合理使用 Spot
    ↓
再谈购买更便宜的 GPU

Cluster Cost
│
├── Training
│   ├── GPU Hours
│   ├── Cost / Billion Tokens
│   ├── Failed Job Cost
│   └── Idle GPU Cost
│
├── Inference
│   ├── Cost / Million Tokens
│   ├── Cost / Request
│   ├── Cost / Tenant
│   └── Cache Saving
│
├── Storage
│   ├── Dataset
│   ├── Checkpoint
│   └── Logs
│
└── Network
    ├── Cross-zone
    ├── Internet
    └── Model Distribution