大模型技术栈

「Transformer 架构是过去十年 AI 领域最重要的突破，大模型则是它开出的最灿烂的花。」

阶段目标

这是当前 AI 行业最热门的方向。学完这个阶段，你将能够：

理解 Transformer 架构和自注意力机制
掌握大模型的训练全流程：预训练 → SFT → RLHF
了解主流大模型家族（GPT、LLaMA、Qwen、DeepSeek）
理解推理优化技术（KV Cache、量化）
掌握 Prompt Engineering 基础
理解 RAG 和 Agent 的概念与实现

💡 学习建议

大模型技术栈涉及面很广，建议先理解原理框架，再深入某个方向。不要试图同时掌握所有内容。

第一部分：大模型是什么？

在深入 Transformer 架构之前，先建立对大模型的基本认知：它是什么、涌现如何发生、有哪些类型、参数规模有多大、最基本的输入输出单位是什么。弄清这些，后面的原理学习会更有的放矢。

大模型定义与涌现效应

AI 大模型是使用深度学习技术构建的、规模庞大的神经网络模型，通常有超过十亿参数，能对大量数据训练，展现强大的理解、生成和推理能力。

典型特征：使用 Transformer + 自注意力；参数量 10 亿~万亿级；预训练 + 微调机制。
关键认知：大模型的价值在于与应用场景的适配性，而非仅参数规模。参数并非越大越好，适应性和效率才是关键——7B 模型只要能有效解决问题，也可视为大模型。
涌现效应：当参数达到某一量级后，模型准确率开始大幅提升；阈值随评测口径不同而异（约 6B~10B 参数量级）。典型大模型起步 7B（70 亿）以上，普遍超过 100B。

大模型的类型

类型	核心能力	典型应用
NLP 大模型	文本生成、内容理解	文案纪要、智能投研、辅助客服
CV 大模型	图像分类、分割、检测	工业质检、工地周界、仓库监控
多模态大模型	跨模态生成、看图说话	图文检索、辅助设计
AI4S 大模型（科学计算）	气象预测、生物医学、回归预测	气象预测、蛋白预测、方程求解
预测大模型	回归预测、异常检测	销售预测、财务异常、工艺预测

典型预训练大模型参数（B=10 亿）

厂商	模型	参数量
国内·DeepSeek	DeepSeek V3/R1	671B
国内·Qwen	Qwen3	235B/30B、32B/14B/8B
国内·Qwen	Qwen2.5	72B/32B/14B/7B
国内·智谱	GLM	130B/32B/9B
国内·腾讯混元	混元	389B
国内·盘古	Pangu 盘古	718B/72B、135B/38B/7B
海外·OpenAI	GPT-4	预估 1800B
海外·OpenAI	GPT-o1/o3	预估 200B
海外·Llama	Llama3.1	405B/70B/8B
海外·Gemini	Gemini 2.5 Pro	预估 1000-1800B
海外·Claude	Claude 3.5/4	预估 1500-2000B / 100-300B / 10-50B
海外·Mistral	Mistral Large 2	123B

Token 概念

Token 是自然语言处理的最细粒度，GPT 的输入和输出都是一个个 Token。

一个 Token 对应多少英文单词/汉字没有固定规则，取决于**分词器（tokenizer）**的设置。
有些分词器把单词视为一个 Token，有些把单词的一部分甚至标点视为一个 Token；汉字通常每个字视为一个独立 Token。
BPE（Byte Pair Encoding） 是常见分词方法；Unicode（统一码） 为每种语言每个字符设定统一且唯一的二进制编码（如「你」=\u4F60=0100 1111 0110 0000）。

第二部分：Transformer 架构

RNN/CNN/Transformer 对比

在深入 Transformer 之前，先看看它和另外两种经典神经网络的差异，理解为什么 Transformer 最终胜出。

模型	模型结构	特征表示能力	训练效率	模型复杂度	鲁棒性	应用场景
CNN	局部连接、权值共享卷积结构	局部特征强，适合图像/语音	高，可并行化	相对简单、参数较少（不适于序列）	一般	人脸识别、物体/交通标志识别、自动驾驶
RNN	具有循环连接（LSTM/GRU 等）	捕捉序列信息演化，适合序列	相对较低，难并行化	相对复杂、参数较多	一定	商品推荐、股票预测、天气预测、语音识别、文本生成
Transformer	基于自注意力机制的结构	建模能力强，适合序列、图像等多种数据	较高，可并行化	较为复杂、参数较多	较强	机器翻译、文本摘要、命名实体识别、视频处理、语音合成

为什么 Transformer 如此重要？

2017 年，Google 发表论文《Attention is All You Need》，提出了 Transformer 架构。这个架构彻底改变了 NLP（自然语言处理）领域，并最终催生了 ChatGPT 等大语言模型。

text

Transformer 之前：
  RNN/LSTM → 串行处理，速度慢，难以记住长距离依赖

Transformer 之后：
  并行处理 → 训练速度快
  自注意力 → 直接捕捉任意距离的依赖关系
  可扩展 → 模型可以做得非常大

自注意力机制（Self-Attention）

自注意力是 Transformer 的核心创新。

直觉理解

text

人类阅读时的注意力：
  "The cat sat on the mat because it was tired."
  
  读到 "it" 时，你的注意力会自动指向 "cat"（而不是 "mat"）
  这就是注意力机制——根据上下文决定关注哪些词

自注意力机制让模型自己学会：
  每个词应该"关注"句子中的哪些其他词

Q、K、V 机制

自注意力通过三个矩阵实现：Query（查询）、Key（键）、Value（值）。

text

类比：图书馆找书
  Query（Q）：你想找什么 → "我要找关于深度学习的书"
  Key（K）：每本书的标签 → "这本书是关于机器学习的"
  Value（V）：书的内容 → 书的实际内容

过程：
  1. 用 Q 和每个 K 比较（计算相似度）→ 得到注意力分数
  2. 用注意力分数对 V 加权求和 → 得到最终输出

数学表示：
  Attention(Q, K, V) = softmax(QK^T / √d_k) · V

python

import torch
import torch.nn.functional as F
import math

def self_attention(Q, K, V):
    """
    简化版自注意力
    Q, K, V: (batch, seq_len, d_k)
    """
    d_k = Q.size(-1)
    
    # 1. 计算注意力分数: QK^T / √d_k
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
    
    # 2. softmax 归一化
    attention_weights = F.softmax(scores, dim=-1)
    
    # 3. 加权求和
    output = torch.matmul(attention_weights, V)
    
    return output, attention_weights

# 示例
batch_size = 2
seq_len = 5
d_k = 64

Q = torch.randn(batch_size, seq_len, d_k)
K = torch.randn(batch_size, seq_len, d_k)
V = torch.randn(batch_size, seq_len, d_k)

output, weights = self_attention(Q, K, V)
print(f"输出形状: {output.shape}")           # (2, 5, 64)
print(f"注意力权重形状: {weights.shape}")     # (2, 5, 5)

💡 理解关键

自注意力让每个位置都能直接"看到"序列中的所有其他位置，不需要像 RNN 那样逐步传递。这是 Transformer 能处理长序列的根本原因。

位置编码（Positional Encoding）

Transformer 的注意力机制本身没有顺序概念——打乱输入顺序，结果可能一样。为了让模型知道词的位置，需要位置编码。

text

问题：
  "狗咬人" 和 "人咬狗" 在自注意力看来可能没区别

解决方案：位置编码
  给每个位置加上一个独特的"位置信号"
  
  方法1：正弦/余弦编码（原始论文）
  方法2：可学习位置编码（BERT）
  方法3：旋转位置编码 RoPE（LLaMA/Qwen 常用）

python

import torch
import math

def positional_encoding(seq_len, d_model):
    """正弦余弦位置编码"""
    pe = torch.zeros(seq_len, d_model)
    position = torch.arange(0, seq_len).unsqueeze(1).float()
    
    div_term = torch.exp(
        torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
    )
    
    pe[:, 0::2] = torch.sin(position * div_term)  # 偶数位用 sin
    pe[:, 1::2] = torch.cos(position * div_term)  # 奇数位用 cos
    
    return pe

pe = positional_encoding(seq_len=100, d_model=512)
print(f"位置编码形状: {pe.shape}")  # (100, 512)

多头注意力（Multi-Head Attention）

一个注意力头只能学习一种"关注模式"。多头注意力让模型同时从多个角度关注输入。

text

类比：多个人从不同角度分析同一段话
  头1：关注语法关系（主语-谓语）
  头2：关注语义关系（同义词、反义词）
  头3：关注指代关系（"it" 指代什么）
  ...
  
  最后把所有头的结果拼接起来

text

Multi-Head Attention:
  输入 → 分成 h 个头 → 每个头独立做 Self-Attention → 拼接 → 线性变换

  例如：d_model=512, h=8 → 每个头 d_k=64
  8个头各自计算注意力，最后拼回 512 维

Transformer 整体架构

text

┌──────────────────────────────────────────┐
│           Transformer 架构               │
├──────────────────────────────────────────┤
│                                          │
│  输入嵌入 + 位置编码                      │
│         │                                │
│         ▼                                │
│  ┌─────────────────────┐                │
│  │   多头自注意力       │                │
│  │   (Multi-Head Attn) │                │
│  └─────────┬───────────┘                │
│            │                             │
│  残差连接 + 层归一化                      │
│            │                             │
│  ┌─────────────────────┐                │
│  │   前馈神经网络       │                │
│  │   (Feed Forward)    │                │
│  └─────────┬───────────┘                │
│            │                             │
│  残差连接 + 层归一化                      │
│            │                             │
│     （重复 N 层）                         │ │
│            │                             │
│            ▼                             │
│        输出层                             │
│                                          │
└──────────────────────────────────────────┘

关键组件说明

组件	作用
多头自注意力	捕捉序列内部的依赖关系
前馈网络	对每个位置独立做非线性变换
残差连接	缓解深层网络的梯度问题
层归一化	稳定训练过程
位置编码	注入位置信息

Encoder vs Decoder

Transformer 有两种主要变体：

变体	结构	代表模型	适用场景
Encoder-Only	只有编码器	BERT	文本理解（分类、NER）
Decoder-Only	只有解码器	GPT 系列	文本生成
Encoder-Decoder	两者都有	T5、BART	序列到序列（翻译）

当前主流大模型（GPT、LLaMA、Qwen 等）几乎都是 Decoder-Only 架构，因为在生成任务上表现最好。

第三部分：预训练与微调

大模型的训练是一个多阶段的过程。在进入训练流程之前，先理解为什么大模型相比传统小模型是一个质的飞跃。

为什么大模型比传统小模型更好？

对比一（学习范式）：

	传统小模型	大模型
训练方式	针对特定场景训练	大规模无标注数据预训练
数据需求	大量标注数据	预训练几十亿条无标注；微调仅需百条以内精标数据
泛化性	差	强
应用	一个场景一个模型	一个模型 + 能力插件，覆盖多场景

对比二（通用性与泛化性）：传统小模型是"烟囱式"（不同场景各一个模型、各自调优、算力独立）；大模型一个覆盖多场景，实现 4 大价值飞跃——①覆盖多场景 ②精度更高 ③超强泛化 ④降低研发成本（自监督减少标注）。

对比三（使用层次）：大模型 + 小模型将长期共存——

任务级（小模型）：判别式任务，嵌入已有 AI 系统（搜索问答、检测监控、识别诊断）。
助手级（大模型）：创造性任务，结合向量数据库、搜索增强模块（文档理解、内容生成、客服助手）。
代理级（下一代智能体）：决策式任务，工具调用、复杂推理（规划调度、虚拟角色）。

训练全流程

text

┌─────────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
│   预训练     │ →  │   SFT   │ →  │  RLHF   │ →  │  部署    │
│ Pre-training│    │         │    │         │    │         │
└─────────────┘    └─────────┘    └─────────┘    └─────────┘
  海量文本          问答对数据      人类反馈        推理服务
  学语言规律        学会回答问题     优化回答质量     上线服务
  最贵最久          较快            较快

阶段一：预训练（Pre-training）

目标：从海量文本中学习语言的基本规律和世界知识。

text

方法：自回归语言建模（Decoder-Only 模型）
  给定前面的词，预测下一个词

  训练数据示例：
  "今天天气真" → 预测 "好"
  "今天天气真好" → 预测 "，"
  "今天天气真好，" → 预测 "适"
  ...

  用几万亿 token 的文本训练
  模型学会：语法、常识、推理、知识...

特点：

数据量：万亿级 token（整个互联网的文本）
算力成本：极高（GPT-4 估计超过 1 亿美元）
时间：几周到几个月
结果：一个"通晓语言"但不会直接回答问题的模型

💡 为什么预训练模型不会直接回答问题？

预训练只学会了"续写文本"。给它"法国的首都是"，它会续写"巴黎"。但给它"请告诉我法国的首都"，它可能续写"和主要城市"而不是回答"巴黎"。SFT 阶段就是教它"回答问题"而不是"续写文本"。

📏 算力-规模量化规律

算力规模 ≈ 参数量 × 数据量 / 训练时长（近似）。
算力需求与参数量、数据量、序列长度成正比：多模态数据训练需求约是文本数据的 320 倍；序列长度越长越吃显存与算力。
参数与算力大致对应：百亿百卡、千亿千卡、万亿万卡。
GPT-4 算力需求约是 GPT-3 的 10~20 倍。
需按精度匹配合适浮点运算（FP32/BF16/FP16）。

阶段二：监督微调（SFT, Supervised Fine-Tuning）

目标：教会模型按照"指令-回答"的格式工作。

text

训练数据：高质量的问答对
  {"instruction": "翻译成英文", "input": "你好世界", "output": "Hello World"}
  {"instruction": "写一首诗", "input": "关于春天", "output": "春风又绿江南岸..."}

数量：通常几万到几十万条
效果：模型从"续写文本"变成"回答问题"

特点：

数据量：万级到十万级（远小于预训练）
算力成本：中等
数据质量：极其重要（"Garbage in, garbage out"）

阶段三：人类反馈强化学习（RLHF）

目标：让模型的回答更符合人类偏好（有用、无害、诚实）。

text

RLHF 流程：
  1. 训练奖励模型（Reward Model）
     收集人类对模型回答的偏好排序
     训练一个能给回答打分的模型
  
  2. 用强化学习优化大模型
     模型生成回答 → 奖励模型打分 → 根据分数优化
     常用算法：PPO（Proximal Policy Optimization）

效果：

text

SFT 后的模型：
  问："1+1等于几？"
  答："1+1=2。这是基本的加法运算。"

RLHF 后的模型：
  问："1+1等于几？"
  答："1+1=2。"
  （更简洁，不啰嗦——因为人类偏好简洁的回答）

替代方案：DPO

DPO（Direct Preference Optimization）是 RLHF 的简化替代方案，不需要训练奖励模型，直接用偏好数据优化模型。目前在很多开源模型中广泛使用。

text

RLHF: 偏好数据 → 训练奖励模型 → PPO优化（复杂）
DPO:  偏好数据 → 直接优化模型（简单高效）

训练阶段对比

阶段	数据量	算力	时间	目标
预训练	万亿级 token	极高	月级	学语言规律
SFT	万-十万级	中等	天级	学会回答问题
RLHF/DPO	万级偏好	中等	天级	对齐人类偏好

第四部分：主流大模型

大模型家族概览

模型家族	开发者	开源情况	特点
GPT 系列	OpenAI	闭源	最知名，能力最强
LLaMA 系列	Meta	开源	开源标杆，生态最丰富
Qwen 系列	阿里	开源	中文能力强，多尺寸
DeepSeek 系列	深度求索	开源	推理能力强，性价比高
Claude 系列	Anthropic	闭源	安全性好，长文本强
Gemini 系列	Google	部分开源	多模态能力

GPT 系列

text

GPT-1 (2018) → GPT-2 (2019) → GPT-3 (2020) → GPT-3.5 (2022) → GPT-4 (2023) → GPT-4o (2024)

特点：
  - 闭源，只能通过 API 调用
  - 能力强，但成本高
  - 生态完善，工具链丰富

LLaMA 系列

text

LLaMA (2023) → LLaMA 2 (2023) → LLaMA 3 (2024) → LLaMA 3.1 (2024)

特点：
  - 开源，可商用
  - 社区生态最丰富（微调工具、推理框架等）
  - 英文能力强，中文需要微调
  - 昇腾生态支持好

Qwen 系列

text

Qwen (2023) → Qwen2 (2024) → Qwen2.5 (2024) → Qwen3 (2025)

特点：
  - 阿里开源，中文能力极强
  - 多尺寸选择（0.5B ~ 72B+，含 Qwen3 系列）
  - 支持 Tool Use、长文本
  - 昇腾生态支持好

DeepSeek 系列

text

DeepSeek (2023) → DeepSeek-V2 (2024) → DeepSeek-V3 / R1 (2024-2025)

特点：
  - 深度求索开源
  - MoE（混合专家）架构，推理高效
  - 推理能力突出（R1 强化推理）
  - 性价比极高

如何选择大模型？

text

选择决策树：

需要最强能力？
  ├─ 是 → 用 API 调用 GPT-4 / Claude
  └─ 否 → 继续

需要本地部署？
  ├─ 是 → 继续
  └─ 否 → 用 API 调用开源模型服务

中文场景为主？
  ├─ 是 → Qwen / DeepSeek
  └─ 否 → LLaMA

算力有限？
  ├─ 是 → 小尺寸模型（7B/8B）
  └─ 否 → 大尺寸模型（70B+）或 MoE

在昇腾上？
  ├─ 是 → 优先 Qwen / DeepSeek / LLaMA（适配好）
  └─ 否 → 按需选择

第五部分：大模型推理优化

推理的核心挑战

text

大模型推理的问题：
  1. 慢：逐 token 生成，速度受限
  2. 贵：显存占用大，硬件成本高
  3. 并发难：多个请求同时处理困难

优化方向：
  1. KV Cache：避免重复计算
  2. 量化：减少显存占用
  3. 推理框架：高效调度和批处理

KV Cache

问题：生成每个新 token 时，需要重新计算之前所有 token 的 Key 和 Value，浪费大量计算。

解决方案：把已经计算过的 Key 和 Value 缓存起来，下次直接用。

text

没有 KV Cache：
  生成第100个token → 重新计算前99个token的K和V → 很慢

有 KV Cache：
  生成第100个token → 直接用缓存的前99个K和V → 快很多
  
  只需要计算第100个token的Q，和缓存的K/V做注意力

text

代价：以空间换时间
  KV Cache 占用显存 = 2 × 层数 × 序列长度 × 隐藏维度 × 数据类型大小
  
  例：LLaMA-7B, 序列长度2048, fp16
  ≈ 2 × 32 × 2048 × 4096 × 2 bytes ≈ 1GB

量化（Quantization）

目标：用更少的数据精度存储模型，减少显存和加速推理。

text

精度类型：
  FP32  → 32位浮点 → 1个参数4字节
  FP16  → 16位浮点 → 1个参数2字节
  INT8  → 8位整数  → 1个参数1字节
  INT4  → 4位整数  → 1个参数0.5字节

量化效果：
  LLaMA-7B FP16 → 14GB 显存
  LLaMA-7B INT8 → 7GB 显存
  LLaMA-7B INT4 → 3.5GB 显存

量化方法	说明	精度损失
PTQ（训练后量化）	直接量化训练好的模型	较小
AWQ	激活感知量化，保护重要权重	小
GPTQ	逐层量化+误差补偿	小
INT4 量化	4位量化，显存占用最少	中等

💡 实用建议

追求质量：FP16 或 AWQ INT8
显存有限：INT4 量化（AWQ/GPTQ）
昇腾环境：MindIE 支持多种量化方案

推理框架

框架	说明	适用场景
vLLM	高吞吐量推理引擎，PagedAttention	GPU 高并发服务
MindIE	昇腾推理引擎	昇腾 NPU 推理
TGI	HuggingFace 推理服务	快速部署
TensorRT-LLM	NVIDIA 推理优化	NVIDIA GPU
llama.cpp	CPU/边缘设备推理	资源受限环境

💡 昇腾环境

在昇腾 NPU 上，推荐使用 MindIE 进行大模型推理。它针对昇腾硬件做了深度优化，支持量化、KV Cache 等技术。详见昇腾生态实战。

第六部分：Prompt Engineering

什么是 Prompt Engineering？

Prompt Engineering（提示词工程）是通过设计输入提示词来引导大模型产生更好输出的技术。

text

好的 Prompt → 好的输出
坏的 Prompt → 坏的输出

大模型的能力是固定的，但不同的 Prompt 能激发出完全不同的表现。

基础技巧

1. 明确角色

text

❌ 差的 Prompt：
  "写一篇关于AI的文章"

✅ 好的 Prompt：
  "你是一位资深的AI技术科普作家，擅长用通俗易懂的语言解释复杂技术。
   请写一篇 800 字的文章，介绍大语言模型的工作原理，目标读者是高中生。"

2. 提供上下文

text

❌ 差的 Prompt：
  "翻译这段话"

✅ 好的 Prompt：
  "请将以下中文翻译成英文。这是给学术论文用的，请使用正式学术语言：
   
   大语言模型通过预训练和微调两个阶段获得语言理解和生成能力。"

3. 给出示例（Few-shot）

text

Prompt：
  "将以下句子分类为'积极'或'消极'：
   
   示例1：'这家餐厅的服务很好' → 积极
   示例2：'产品质量太差了' → 消极
   示例3：'物流速度很慢' → 消极
   
   请分类：'包装很精美，但味道一般'"
   
输出：→ "消极"（模型从示例中学会了分类方式）

4. 分步思考（Chain of Thought）

text

❌ 直接问：
  "一个商店有23个苹果，卖了17个，又进了8个，现在有多少个？"

✅ 引导分步思考：
  "请一步步思考以下问题：
   一个商店有23个苹果，卖了17个，又进了8个，现在有多少个？
   
   请先计算卖出后剩多少，再计算进货后有多少。"

5. 指定输出格式

text

Prompt：
  "请分析以下产品的优缺点，以JSON格式输出：
   
   产品：某品牌无线耳机
   
   输出格式：
   {
     \"product\": \"产品名\",
     \"pros\": [\"优点1\", \"优点2\"],
     \"cons\": [\"缺点1\", \"缺点2\"],
     \"recommendation\": \"推荐/不推荐\"
   }"

Prompt 框架模板

text

一个完整的 Prompt 通常包含：

1. 【角色】你是一个...
2. 【任务】请完成...
3. 【上下文】背景信息...
4. 【约束】要求/限制...
5. 【格式】输出格式...
6. 【示例】参考示例...

第七部分：RAG 与 Agent

RAG（检索增强生成）

问题背景

text

大模型的局限：
  1. 知识有截止日期 → 不知道最新信息
  2. 不了解私有数据 → 不懂公司内部文档
  3. 会"幻觉" → 编造不存在的信息

RAG 的解决方案：
  先检索相关信息 → 再让模型基于检索结果回答

RAG 流程

text

┌──────────────────────────────────────────────┐
│                  RAG 流程                     │
├──────────────────────────────────────────────┤
│                                              │
│  用户提问                                     │
│     │                                        │
│     ▼                                        │
│  ┌──────────┐                                │
│  │ 向量化    │ 把问题转成向量                  │
│  └────┬─────┘                                │
│       │                                      │
│       ▼                                      │
│  ┌──────────┐     ┌──────────┐              │
│  │ 检索      │ ←── │ 知识库    │              │
│  │ (向量搜索)│     │ (文档库)  │              │
│  └────┬─────┘     └──────────┘              │
│       │                                      │
│       ▼                                      │
│  ┌──────────┐                                │
│  │ 拼接上下文│ 问题 + 检索到的相关文档          │
│  └────┬─────┘                                │
│       │                                      │
│       ▼                                      │
│  ┌──────────┐                                │
│  │ 大模型    │ 基于上下文生成回答              │
│  │ 生成回答  │                                │
│  └──────────┘                                │
│                                              │
└──────────────────────────────────────────────┘

RAG 的核心组件

组件	说明	常用工具
文档处理	文本分块（Chunking）	LangChain、LlamaIndex
向量化	文本转向量（Embedding）	BGE、text-embedding-ada
向量数据库	存储和检索向量	Chroma、Faiss、Milvus
检索	找到最相关的文档块	向量相似度搜索
生成	大模型基于上下文回答	GPT、Qwen、LLaMA

简单 RAG 示例（伪代码）

python

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 1. 文档处理：将长文档分成小块
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_text(long_document)

# 2. 向量化并存储到向量数据库
embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-base-zh")
vector_store = Chroma.from_texts(chunks, embeddings)

# 3. 检索相关文档
question = "公司年假政策是怎样的？"
relevant_docs = vector_store.similarity_search(question, k=3)

# 4. 构建 Prompt 并调用大模型
context = "\n".join([doc.page_content for doc in relevant_docs])
prompt = f"基于以下信息回答问题：\n\n{context}\n\n问题：{question}"
answer = llm.generate(prompt)

Agent（智能体）

什么是 Agent？

text

传统大模型：
  问 → 答（被动的，只能生成文本）

Agent：
  问 → 思考 → 使用工具 → 观察 → 再思考 → 行动 → 答
  （主动的，能调用工具、执行动作）

Agent 的核心组件

text

┌──────────────────────────────────────┐
│            Agent 架构                │
├──────────────────────────────────────┤
│                                      │
│  用户指令                             │
│     │                                │
│     ▼                                │
│  ┌──────────┐                        │
│  │  大模型   │ ← 核心"大脑"            │
│  │ (LLM)   │                        │
│  └────┬─────┘                        │
│       │                              │
│       ▼                              │
│  ┌──────────┐    ┌──────────────┐   │
│  │  规划     │ →  │  记忆         │   │
│  │ (Planning)│    │ (Memory)     │   │
│  └────┬─────┘    └──────────────┘   │
│       │                              │
│       ▼                              │
│  ┌──────────────────────────┐       │
│  │       工具调用             │       │
│  │  ┌─────┐ ┌─────┐ ┌─────┐│       │
│  │  │搜索  │ │计算器│ │代码  ││       │
│  │  └─────┘ └─────┘ └─────┘│       │
│  └──────────────────────────┘       │
│                                      │
└──────────────────────────────────────┘

组件	说明	例子
大脑（LLM）	理解指令、推理决策	GPT、Qwen
规划（Planning）	将复杂任务分解为步骤	先搜索→再分析→最后总结
记忆（Memory）	记住之前的交互和结果	短期记忆、长期记忆
工具（Tools）	调用外部能力	搜索引擎、计算器、API

Agent 示例场景

text

用户："帮我查一下今天北京的天气，如果下雨就提醒我带伞"

Agent 执行过程：
  1. 理解任务：需要查天气 + 条件判断
  2. 规划：先调用天气API → 判断是否下雨 → 给出建议
  3. 调用工具：天气API → "北京，小雨，15°C"
  4. 判断：有小雨 → 需要提醒
  5. 输出："今天北京有小雨，气温15°C，请记得带伞！"

ReAct 模式

ReAct（Reasoning + Acting）是 Agent 最常用的模式：

text

循环执行：
  Thought（思考）：我需要做什么
  Action（行动）：调用某个工具
  Observation（观察）：工具返回的结果
  Thought（再思考）：根据结果下一步做什么
  ...
  Final Answer（最终答案）

Agent 相关框架

框架	说明
LangChain	最流行的 LLM 应用框架
LangGraph	LangChain 的 Agent 工作流框架
AutoGen	微软的多 Agent 框架
MetaGPT	多 Agent 协作框架
Dify	可视化 LLM 应用搭建平台

论文	说明
Attention is All You Need (2017)	Transformer 原始论文
BERT (2018)	预训练语言模型里程碑
GPT-3 (2020)	大规模语言模型
InstructGPT (2022)	RLHF 方法
LLaMA (2023)	开源大模型

书名	说明	推荐指数
《大语言模型》赵鑫	系统介绍 LLM	★★★★★
《动手做大语言模型》	实践导向	★★★★☆
《自然语言处理实战》	NLP 工程实践	★★★★☆

资源	说明
Hugging Face NLP Course	免费官方课程
LangChain 官方文档	RAG/Agent 最佳参考
吴恩达 Prompt Engineering	免费短课程
李宏毅生成式AI	中文，讲解大模型

平台	说明
Hugging Face	模型/数据集/Spaces
ModelScope（魔搭）	阿里的模型平台，中文友好
OpenXLab	昇腾相关模型体验

阶段总结

知识点清单

完成本阶段后，确认你掌握了：

理论：

[ ] 自注意力机制（Q、K、V）的原理
[ ] 位置编码的作用
[ ] 多头注意力的意义
[ ] 预训练 → SFT → RLHF 三阶段训练
[ ] KV Cache 的原理和代价
[ ] 量化的概念和常见方法
[ ] 什么是 Token？大模型的基本输入输出单位
[ ] 大模型与传统小模型的核心区别

实践：

[ ] 能编写高质量的 Prompt
[ ] 理解 RAG 的完整流程
[ ] 理解 Agent 的概念和 ReAct 模式
[ ] 能使用推理框架部署大模型
[ ] 了解主流大模型的选择策略

下一步

🚀 下一阶段

👉 阶段五：昇腾生态实战 —— 在昇腾 NPU 上动手实践

「你已经理解了大模型的技术原理。接下来，我们要把这些知识落到昇腾硬件上，从理论走向实战。这是你区别于'纸上谈兵'的关键一步。」

大模型技术栈 ​

阶段目标 ​

第一部分：大模型是什么？ ​

大模型定义与涌现效应 ​

大模型的类型 ​

典型预训练大模型参数（B=10 亿） ​

Token 概念 ​

第二部分：Transformer 架构 ​

RNN/CNN/Transformer 对比 ​

为什么 Transformer 如此重要？ ​

自注意力机制（Self-Attention） ​

直觉理解 ​

Q、K、V 机制 ​

位置编码（Positional Encoding） ​

多头注意力（Multi-Head Attention） ​

Transformer 整体架构 ​

关键组件说明 ​

Encoder vs Decoder ​

第三部分：预训练与微调 ​

为什么大模型比传统小模型更好？ ​

训练全流程 ​

阶段一：预训练（Pre-training） ​

阶段二：监督微调（SFT, Supervised Fine-Tuning） ​

阶段三：人类反馈强化学习（RLHF） ​

替代方案：DPO ​

训练阶段对比 ​

第四部分：主流大模型 ​

大模型家族概览 ​

GPT 系列 ​

LLaMA 系列 ​

Qwen 系列 ​

DeepSeek 系列 ​

如何选择大模型？ ​

第五部分：大模型推理优化 ​

推理的核心挑战 ​

KV Cache ​

量化（Quantization） ​

推理框架 ​

第六部分：Prompt Engineering ​

什么是 Prompt Engineering？ ​

基础技巧 ​

1. 明确角色 ​

2. 提供上下文 ​

3. 给出示例（Few-shot） ​

4. 分步思考（Chain of Thought） ​

5. 指定输出格式 ​

Prompt 框架模板 ​

第七部分：RAG 与 Agent ​

RAG（检索增强生成） ​

问题背景 ​

RAG 流程 ​

RAG 的核心组件 ​

简单 RAG 示例（伪代码） ​

Agent（智能体） ​

什么是 Agent？ ​

Agent 的核心组件 ​

Agent 示例场景 ​

ReAct 模式 ​

Agent 相关框架 ​

推荐学习资源 ​

论文 ​

书籍 ​

课程与教程 ​

实践平台 ​

阶段总结 ​

知识点清单 ​

下一步 ​

大模型技术栈

阶段目标

第一部分：大模型是什么？

大模型定义与涌现效应

大模型的类型

典型预训练大模型参数（B=10 亿）

Token 概念

第二部分：Transformer 架构

RNN/CNN/Transformer 对比

为什么 Transformer 如此重要？

自注意力机制（Self-Attention）

直觉理解

Q、K、V 机制

位置编码（Positional Encoding）

多头注意力（Multi-Head Attention）

Transformer 整体架构

关键组件说明

Encoder vs Decoder

第三部分：预训练与微调

为什么大模型比传统小模型更好？

训练全流程

阶段一：预训练（Pre-training）

阶段二：监督微调（SFT, Supervised Fine-Tuning）

阶段三：人类反馈强化学习（RLHF）

替代方案：DPO

训练阶段对比

第四部分：主流大模型

大模型家族概览

GPT 系列

LLaMA 系列

Qwen 系列

DeepSeek 系列

如何选择大模型？

第五部分：大模型推理优化

推理的核心挑战

KV Cache

量化（Quantization）

推理框架

第六部分：Prompt Engineering

什么是 Prompt Engineering？

基础技巧

1. 明确角色

2. 提供上下文

3. 给出示例（Few-shot）

4. 分步思考（Chain of Thought）

5. 指定输出格式

Prompt 框架模板

第七部分：RAG 与 Agent

RAG（检索增强生成）

问题背景

RAG 流程

RAG 的核心组件

简单 RAG 示例（伪代码）

Agent（智能体）

什么是 Agent？

Agent 的核心组件

Agent 示例场景

ReAct 模式

Agent 相关框架

推荐学习资源

论文

书籍

课程与教程

实践平台

阶段总结

知识点清单

下一步