Agent Frameworks | Home

AI开发中常用的Python库

Wed, 05 Aug 2026 00:00:00 +0000

AI开发中常用的Python库

Python之所以成为AI开发的主流语言，并不是因为它本身运行速度快，而是因为它构建了一套极其完整的AI计算、机器学习、深度学习、数据处理、模型推理、RAG、Agent和MLOps生态。

真正进入AI工程开发之后，开发者面对的并不是“会不会Python语法”，而是一个更加复杂的问题：

什么时候使用 NumPy？什么时候使用 PyTorch？什么时候使用 Transformers？RAG应该选择什么框架？Agent又应该如何组织？

本文从AI应用架构的角度，对目前AI开发中最常用的Python库进行系统梳理。

一、AI开发为什么离不开Python？

传统后端开发经常以Java、Go、C++为核心，而AI开发则大量采用Python。

核心原因并不是Python语言本身，而是：

Python
 │
 ├── 数值计算
 │ └── NumPy
 │
 ├── 数据分析
 │ ├── Pandas
 │ └── Polars
 │
 ├── 机器学习
 │ ├── Scikit-learn
 │ ├── XGBoost
 │ └── LightGBM
 │
 ├── 深度学习
 │ ├── PyTorch
 │ └── TensorFlow
 │
 ├── LLM
 │ ├── Transformers
 │ ├── Accelerate
 │ ├── PEFT
 │ └── TRL
 │
 ├── Embedding / RAG
 │ ├── Sentence Transformers
 │ ├── FAISS
 │ ├── Chroma
 │ ├── Milvus
 │ └── Qdrant
 │
 ├── Agent
 │ ├── LangChain
 │ ├── LangGraph
 │ ├── LlamaIndex
 │ └── AutoGen
 │
 └── AI服务化
 ├── FastAPI
 ├── Pydantic
 ├── Uvicorn
 └── Celery

因此可以把AI Python生态理解成：

Python不是一个AI库，而是一整个AI软件工程平台。

二、NumPy：AI计算的基础设施

2.1 NumPy是什么？

NumPy，全称 Numerical Python，是Python科学计算生态最基础的库之一。

核心对象是：

numpy.ndarray

它提供了高效的多维数组以及大量数学运算。

例如：

import numpy as np

x = np.array([1, 2, 3, 4])

print(x * 2)

输出：

[2 4 6 8]

但是NumPy真正重要的地方不是简单的数组运算，而是：

Tensor和Vector思想的基础。

三、NumPy为什么对AI如此重要？

假设一个Embedding：

[0.123, -0.532, 0.832, ...]

本质上就是一个向量。

一个Batch：

[
 [0.1, 0.2, 0.3],
 [0.4, 0.5, 0.6],
 [0.7, 0.8, 0.9]
]

就是一个二维矩阵。

深度学习模型进一步扩展：

Scalar
 ↓
Vector
 ↓
Matrix
 ↓
Tensor

因此NumPy是理解：

Embedding
Matrix
Tensor
Cosine Similarity
Dot Product
Attention

的重要基础。

四、Pandas：AI数据处理的瑞士军刀

Pandas主要解决：

结构化数据处理问题。

例如：

import pandas as pd

df = pd.read_csv("users.csv")

print(df.head())
print(df.describe())

典型能力包括：

CSV读取
Excel处理
数据清洗
缺失值处理
数据过滤
GroupBy
Join
聚合
数据转换

例如：

df[df["age"] > 30]

五、Pandas在LLM时代仍然重要

很多人认为：

“现在都是LLM了，Pandas是不是没用了？”

实际上恰恰相反。

AI应用中经常需要处理：

数据库
 ↓
CSV / JSON
 ↓
数据清洗
 ↓
Chunk
 ↓
Embedding
 ↓
Vector Database

因此Pandas依然大量出现在：

数据预处理
AI训练数据处理
Evaluation Dataset
RAG数据清洗
Fine-tuning Dataset
日志分析

中。

六、Polars：Pandas的高性能替代方案

Polars是近年来越来越受到关注的数据处理库。

相比传统Pandas，它强调：

Rust实现
并行计算
Lazy Execution
更高性能
更低内存开销

例如：

import polars as pl

df = pl.read_csv("data.csv")

result = (
 df
 .filter(pl.col("age") > 30)
 .group_by("department")
 .agg(pl.col("salary").mean())
)

对于大规模AI数据处理，Polars非常值得掌握。

可以简单理解：

Pandas
 ↓
通用数据分析

Polars
 ↓
高性能数据工程

七、Scikit-learn：传统机器学习核心框架

Scikit-learn是Python机器学习领域最经典的库之一。

它主要覆盖：

分类
回归
聚类
降维
特征工程
模型评估
数据预处理

例如：

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

model.fit(X_train, y_train)

prediction = model.predict(X_test)

八、Scikit-learn与LLM是什么关系？

Scikit-learn并没有因为LLM出现而失去价值。

在真实AI系统中，经常出现：

LLM
 +
传统机器学习
 +
规则引擎

例如：

一个金融风控系统可能：

用户请求
 ↓
LLM提取用户意图
 ↓
Feature Engineering
 ↓
XGBoost
 ↓
Risk Score
 ↓
LLM生成解释

所以：

AI Engineering并不等于LLM Engineering。

九、XGBoost：工业界非常重要的机器学习库

XGBoost是一种Gradient Boosting算法实现。

特别适合：

风控
推荐
CTR预测
用户画像
表格数据
分类
回归

例如：

from xgboost import XGBClassifier

model = XGBClassifier()

model.fit(X_train, y_train)

对于结构化数据：

年龄
收入
地区
历史行为
交易次数
信用记录

XGBoost往往仍然是非常强的解决方案。

十、LightGBM：大规模结构化数据机器学习

LightGBM也是Gradient Boosting家族的重要成员。

特点：

高性能
低内存
支持大规模数据
训练速度快

典型应用：

推荐系统
广告系统
风控
搜索排序
用户预测

十一、PyTorch：现代AI开发的核心

如果说NumPy是科学计算基础设施，那么：

PyTorch就是现代深度学习开发的核心框架之一。

PyTorch核心对象：

torch.Tensor

例如：

import torch

x = torch.tensor([1, 2, 3])

print(x * 2)

十二、PyTorch为什么如此重要？

PyTorch提供：

Tensor
+
GPU
+
Autograd
+
Neural Network
+
Distributed Training

例如：

import torch

x = torch.tensor([2.0], requires_grad=True)

y = x ** 2

y.backward()

print(x.grad)

PyTorch会自动计算：

dy/dx = 2x

这就是：

Automatic Differentiation

即自动微分。

十三、PyTorch是理解LLM的基础

现代Transformer模型最终仍然建立在：

Tensor
 ↓
Matrix Multiplication
 ↓
Attention
 ↓
Neural Network
 ↓
Gradient

之上。

例如Transformer中的核心计算：

Attention(Q,K,V)
=
softmax(QKᵀ / √d)V

本质上就是大量Tensor运算。

因此：

想真正理解LLM底层原理，PyTorch是非常值得掌握的。

十四、TensorFlow：另一套深度学习生态

TensorFlow曾经长期占据深度学习主流位置。

典型组件：

TensorFlow
 ├── Keras
 ├── TensorBoard
 └── TensorFlow Serving

Keras可以快速构建模型：

from tensorflow import keras

model = keras.Sequential([
 keras.layers.Dense(128, activation="relu"),
 keras.layers.Dense(10)
])

不过对于今天的新一代LLM研究和开源模型生态而言，PyTorch的存在感通常更强。

十五、Hugging Face Transformers：LLM开发核心库

进入大模型开发以后，最重要的Python库之一就是：

transformers

它提供大量预训练模型和统一接口。

例如：

from transformers import pipeline

generator = pipeline(
 "text-generation",
 model="..."
)

result = generator("AI is")

十六、Transformers解决了什么问题？

如果没有Transformers，开发者需要自己处理：

模型结构
Tokenizer
权重加载
Attention
Position Embedding
Model Configuration
GPU
Inference

Transformers将这些统一起来。

常见模型类型包括：

BERT
GPT
T5
Llama
Qwen
Mistral
Gemma
Whisper
CLIP

因此可以把Transformers理解为：

开源LLM模型的软件接口层。

十七、Tokenizer：LLM的输入层

LLM并不是直接理解字符串。

例如：

Hello AI

会经过：

Text
 ↓
Tokenizer
 ↓
Token IDs
 ↓
Embedding
 ↓
Transformer

Transformers提供统一Tokenizer接口：

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("...")

tokens = tokenizer("Hello AI")

print(tokens)

十八、Accelerate：让模型运行在不同硬件上

Hugging Face Accelerate解决：

CPU
GPU
Multi-GPU
Distributed Training
Mixed Precision

等问题。

例如：

from accelerate import Accelerator

accelerator = Accelerator()

它可以减少大量设备管理代码。

在模型训练和推理工程中非常有价值。

十九、PEFT：参数高效微调

PEFT：

Parameter-Efficient Fine-Tuning

核心思想：

不修改整个模型，而只训练少量参数。

典型技术：

LoRA
QLoRA
Adapter
Prefix Tuning
Prompt Tuning

例如LoRA：

原始LLM
 │
 ├── Frozen Parameters
 │
 └── LoRA Parameters
 ↓
 Fine-tuning

优势：

训练参数 ↓
显存 ↓
训练成本 ↓
部署成本 ↓

二十、TRL：LLM训练与对齐

TRL：

Transformer Reinforcement Learning

主要用于：

SFT
Reward Modeling
RLHF
Preference Optimization

可以理解为：

Transformers
 +
训练算法
 ↓
LLM Alignment

二十一、Sentence Transformers：Embedding核心工具

RAG系统最重要的组件之一就是Embedding。

Sentence Transformers专门用于：

将文本转换成向量。

例如：

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("...")

embedding = model.encode(
 "What is artificial intelligence?"
)

得到：

[0.123,
 -0.234,
 0.456,
 ...
]

二十二、Embedding为什么是RAG的核心？

假设知识库：

文档A：Java是一种面向对象编程语言

文档B：Redis是一种内存数据库

文档C：Kafka是一种分布式消息系统

用户问：

Java是什么？

系统不是简单搜索关键词，而是：

Query
 ↓
Embedding
 ↓
Vector Search
 ↓
找到相似文档
 ↓
LLM
 ↓
Answer

这就是：

Semantic Search

二十三、FAISS：向量检索基础设施

FAISS：

Facebook AI Similarity Search

主要解决：

高维向量的相似度搜索。

例如：

import faiss

index = faiss.IndexFlatL2(768)

index.add(vectors)

D, I = index.search(query, 5)

可以理解：

Embedding
 ↓
FAISS
 ↓
Top-K Similar Vectors

FAISS非常适合：

本地RAG
实验
原型系统
大规模向量检索研究

二十四、Chroma：轻量级Vector Database

Chroma主要面向AI应用开发者。

它提供：

Embedding存储
Vector Search
Metadata
Collection

非常适合：

RAG Demo
 ↓
Prototype
 ↓
POC

例如：

import chromadb

client = chromadb.Client()

collection = client.create_collection(
 name="documents"
)

二十五、Milvus：企业级向量数据库

如果RAG系统规模扩大：

百万级
千万级
亿级Vector

就需要更加专业的Vector Database。

Milvus支持：

Vector Search
Hybrid Search
Metadata Filter
Distributed Architecture
Large-scale Retrieval

典型架构：

LLM Application
 ↓
Embedding
 ↓
Milvus
 ↓
Vector Search
 ↓
Top-K Documents

二十六、Qdrant：现代Vector Database

Qdrant也是目前非常流行的向量数据库。

特点包括：

Vector Search
Metadata Filtering
Payload
REST API
高性能检索

适合构建：

RAG
Semantic Search
Recommendation
Agent Memory

二十七、LangChain：LLM应用编排框架

LangChain是AI应用开发中非常知名的框架。

它试图解决：

LLM
+
Prompt
+
Tool
+
Memory
+
Retriever
+
Agent

之间的组合问题。

例如：

User
 ↓
Prompt
 ↓
LLM
 ↓
Tool
 ↓
Database
 ↓
LLM
 ↓
Answer

二十八、LangChain最重要的概念

理解LangChain，建议掌握：

Model
Prompt
Output Parser
Retriever
Tool
Agent
Memory
Chain
Runnable

例如：

chain = prompt | model | parser

这种Pipeline思想非常重要。

二十九、LangGraph：Agent开发的重要框架

如果说LangChain偏向：

LLM Application Framework

那么LangGraph更加关注：

Agent Workflow / Stateful Agent

Agent并不是简单：

Prompt → LLM → Answer

而是：

 ┌──────────────┐
 │ Agent │
 └──────┬───────┘
 ↓
 Analyze Task
 ↓
 ┌──────┴──────┐
 ↓ ↓
 Tool A Tool B
 ↓ ↓
 └──────┬──────┘
 ↓
 Observation
 ↓
 Re-plan
 ↓
 ...

这就是Graph思想。

三十、LlamaIndex：RAG领域的重要框架

LlamaIndex主要关注：

LLM + External Data

特别适合：

Document ingestion
Index
Retrieval
RAG
Data Connector

典型流程：

PDF
 ↓
Document
 ↓
Node
 ↓
Embedding
 ↓
Index
 ↓
Retriever
 ↓
LLM

三十一、AutoGen：多Agent协作

AutoGen主要关注：

Multi-Agent Collaboration

例如：

 User
 ↓
 Orchestrator
 / | \
 / | \
 Research Coder Reviewer
 \ | /
 \ | /
 Final Agent

多个Agent分别承担：

Research Agent
Coding Agent
Testing Agent
Review Agent
Planning Agent

然后通过Agent Communication完成协作。

这和传统：

Microservice

在架构思想上有一定相似性。

三十二、OpenAI SDK：调用LLM的基础客户端

如果应用直接调用模型API，那么通常需要官方SDK。

基本形式：

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
 model="...",
 input="Explain AI"
)

它主要解决：

API Authentication
Request
Response
Streaming
Tool Calling
Structured Output

三十三、Pydantic：AI工程里被严重低估的库

Pydantic不是AI专用库，但是现代AI开发非常重要。

核心能力：

数据验证 + 类型定义 + Schema生成

例如：

from pydantic import BaseModel

class User(BaseModel):
 name: str
 age: int

三十四、为什么LLM特别需要Pydantic？

LLM输出：

{
 "name": "Vincent",
 "age": 30
}

我们希望它符合：

class User(BaseModel):
 name: str
 age: int

于是可以实现：

LLM
 ↓
Structured Output
 ↓
Pydantic
 ↓
Validation
 ↓
Business Logic

这对于：

Agent
Tool Calling
Structured Output
API
Workflow

都非常重要。

三十五、FastAPI：AI服务化的核心框架

AI模型最终通常需要变成API。

例如：

Frontend
 ↓
HTTP
 ↓
FastAPI
 ↓
LLM
 ↓
Response

代码：

from fastapi import FastAPI

app = FastAPI()

@app.post("/chat")
def chat(message: str):
 return {
 "answer": "Hello AI"
 }

FastAPI非常适合：

LLM API
RAG API
Agent API
Model Service
AI Gateway

三十六、Uvicorn：运行FastAPI

FastAPI本身不是完整Web Server。

通常使用：

FastAPI
 ↓
Uvicorn
 ↓
ASGI

启动：

uvicorn main:app --host 0.0.0.0 --port 8000

生产环境还可以配合：

Nginx
Docker
Kubernetes

三十七、HTTPX：AI服务中的HTTP客户端

AI系统往往需要调用很多外部服务：

LLM API
Embedding API
Vector DB
Internal Service
External API

HTTPX提供现代Python HTTP客户端：

import httpx

response = httpx.get(
 "https://example.com"
)

还支持：

Async
Connection Pool
HTTP/2

对于异步AI应用非常重要。

三十八、AsyncIO：AI应用必须理解的异步模型

LLM应用大量时间实际上花在：

等待网络
等待模型
等待数据库
等待Vector Search

例如：

Request
 ↓
LLM API
 ↓
等待
 ↓
Vector DB
 ↓
等待
 ↓
Tool API
 ↓
等待

因此Python AsyncIO非常重要。

例如：

import asyncio

async def call_model():
 await asyncio.sleep(1)
 return "result"

三十九、PyMuPDF：RAG文档解析

企业RAG经常需要处理：

PDF
DOCX
PPTX
TXT
HTML

PyMuPDF非常适合PDF文本提取。

例如：

import fitz

doc = fitz.open("document.pdf")

for page in doc:
 text = page.get_text()

典型流程：

PDF
 ↓
PyMuPDF
 ↓
Text
 ↓
Chunk
 ↓
Embedding
 ↓
Vector DB

四十、BeautifulSoup：网页数据提取

如果AI系统需要读取网页：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, "html.parser")

text = soup.get_text()

适合：

HTML解析
网页内容提取
数据采集
RAG数据源

四十一、Playwright：浏览器自动化

BeautifulSoup只能处理HTML。

如果网页需要：

JavaScript
Login
Dynamic Rendering
Click
Scroll
Form

可以使用Playwright。

例如：

from playwright.async_api import async_playwright

这对于Browser Agent非常重要。

架构可以是：

Agent
 ↓
Browser Tool
 ↓
Playwright
 ↓
Browser
 ↓
Website

四十二、OCR库：让AI理解图片和扫描文档

企业AI应用经常遇到：

扫描PDF
发票
身份证
合同
截图
表格

常见OCR技术栈包括：

PaddleOCR
Tesseract
EasyOCR

其中PaddleOCR在中文场景非常常见。

典型流程：

Image
 ↓
OCR
 ↓
Text
 ↓
LLM

四十三、OpenCV：计算机视觉基础设施

OpenCV主要解决：

图像处理
视频处理
OCR前处理
图像识别
Computer Vision

例如：

import cv2

image = cv2.imread("image.jpg")

gray = cv2.cvtColor(
 image,
 cv2.COLOR_BGR2GRAY
)

如果开发：

Vision AI
OCR
Video AI
Image Processing

OpenCV依然重要。

四十四、Pillow：Python图像处理基础库

Pillow适合：

图片读取
Resize
Crop
Format转换
压缩
基础图像处理

例如：

from PIL import Image

image = Image.open("image.jpg")

image = image.resize((512, 512))

四十五、ONNX Runtime：模型推理

训练模型和运行模型是两件不同的事情。

训练：

PyTorch

生产推理：

ONNX Runtime

可以将模型：

PyTorch
 ↓
ONNX
 ↓
ONNX Runtime

从而在不同环境中进行高性能推理。

四十六、vLLM：LLM推理服务器

如果自己部署大模型，vLLM非常值得掌握。

它主要解决：

如何高效运行LLM。

核心技术包括：

PagedAttention
Continuous Batching
KV Cache
GPU Optimization

典型架构：

Client
 ↓
FastAPI / Gateway
 ↓
vLLM
 ↓
GPU
 ↓
LLM

如果目标是：

LLM Infrastructure Engineer

那么vLLM属于重点技术。

四十七、TGI：Text Generation Inference

TGI也是用于部署Transformer/LLM的推理服务器。

主要关注：

Model Serving
Batching
Streaming
GPU Inference

它与vLLM属于类似领域。

四十八、Ray：AI分布式计算平台

Ray解决的是：

如何把Python计算任务扩展到多机器。

可以用于：

Distributed Training
Distributed Inference
Hyperparameter Tuning
RL
Data Processing
Agent

架构：

 Ray Cluster
 ┌────────┼────────┐
 ↓ ↓ ↓
 Node1 Node2 Node3
 ↓ ↓ ↓
 GPU GPU GPU

四十九、Dask：Python分布式数据计算

Dask主要用于：

Large Dataset
Parallel Computing
Distributed Data Processing

如果Pandas处理不了数据规模，可以考虑：

Pandas
 ↓
Dask / Polars

五十、MLflow：机器学习生命周期管理

AI项目不仅仅是训练模型。

还需要：

Experiment
 ↓
Training
 ↓
Model
 ↓
Version
 ↓
Deployment
 ↓
Monitoring

MLflow可以管理：

Experiment
Metrics
Parameters
Model Registry
Model Version

例如：

Experiment #123

learning_rate = 0.001
batch_size = 32
accuracy = 0.94

五十一、Weights & Biases：AI实验管理

W&B主要用于：

Experiment Tracking
Model Training
Metrics Visualization
Dataset
Model Version

特别适合深度学习训练。

例如：

Epoch 1
Loss = 2.31

Epoch 10
Loss = 0.42

Epoch 50
Loss = 0.08

可以实时可视化。

五十二、Prometheus：AI系统监控

AI应用上线后，需要监控：

Request Count
Latency
Error Rate
Token Usage
GPU Utilization
Model Latency
RAG Latency

Prometheus非常适合指标监控。

典型AI监控：

 AI System
 │
 ┌─────────────┼─────────────┐
 ↓ ↓ ↓
 API Metrics Model Metrics GPU Metrics
 │ │ │
 └─────────────┼─────────────┘
 ↓
 Prometheus
 ↓
 Grafana

五十三、Loguru：更方便的Python日志库

Python标准库：

logging

已经足够强大。

但Loguru提供更加简单的日志体验：

from loguru import logger

logger.info("AI request started")
logger.error("Model failed")

适合AI应用开发阶段快速构建日志体系。

五十四、Tenacity：AI系统中的重试机制

LLM应用非常容易遇到：

Timeout
Rate Limit
503
Network Error
Temporary Failure

Tenacity可以实现：

Retry
Backoff
Stop Condition

例如：

from tenacity import retry

@retry
def call_llm():
 ...

生产AI系统中：

Retry不是锦上添花，而是可靠性设计的一部分。

五十五、Redis：AI应用中的基础设施

Redis虽然不是Python AI库，但AI应用经常通过Python客户端使用Redis。

典型用途：

Session
Cache
Rate Limit
Agent State
Task Queue
Semantic Cache

例如：

User
 ↓
API
 ↓
Redis
 ↓
Conversation State
 ↓
LLM

五十六、Celery：AI异步任务

有些AI任务非常耗时：

PDF解析
OCR
Embedding
Batch Inference
Document Index
Fine-tuning

不应该阻塞HTTP请求。

可以设计：

FastAPI
 ↓
Celery
 ↓
Redis / RabbitMQ
 ↓
Worker
 ↓
AI Task

这和传统企业级Java异步任务架构非常类似。

五十七、一个完整AI项目到底需要哪些Python库？

可以把AI开发技术栈分成七层。

Layer 1：基础计算

NumPy
Pandas
Polars

Layer 2：Machine Learning

Scikit-learn
XGBoost
LightGBM

Layer 3：Deep Learning

PyTorch
TensorFlow

Layer 4：LLM

Transformers
Accelerate
PEFT
TRL
OpenAI SDK

Layer 5：RAG

Sentence Transformers
FAISS
Chroma
Milvus
Qdrant
LlamaIndex

Layer 6：Agent

LangChain
LangGraph
AutoGen

Layer 7：Production

FastAPI
Pydantic
Uvicorn
HTTPX
Redis
Celery
MLflow
Prometheus

五十八、如果开发一个企业级RAG系统

假设我们要构建：

企业内部知识库问答系统

可以设计：

 User
 │
 ↓
 FastAPI
 │
 ↓
 Query Rewrite
 │
 ↓
 Embedding
 │
 ↓
 ┌────────────────┐
 │ Vector Database│
 │ Milvus/Qdrant │
 └───────┬────────┘
 ↓
 Top-K Docs
 │
 ↓
 Reranker
 │
 ↓
 Prompt
 │
 ↓
 LLM
 │
 ↓
 Pydantic
 │
 ↓
 Response

对应Python技术栈：

FastAPI
Pydantic
Sentence Transformers
Milvus/Qdrant
LangChain/LlamaIndex
OpenAI SDK / Transformers
Redis
Prometheus

五十九、如果开发一个Agent系统

例如：

AI软件开发Agent

可以设计：

 User
 ↓
 Planner
 ↓
 ┌──────┼──────┐
 ↓ ↓ ↓
 Coder Search Tester
 │ │ │
 └──────┼──────┘
 ↓
 Reviewer
 ↓
 Planner
 ↓
 Final

Python技术栈可能是：

LangGraph
Pydantic
LLM SDK
FastAPI
Redis
PostgreSQL
Playwright
GitPython
Docker SDK

这里真正重要的已经不是：

“会不会调用LLM”

而是：

如何设计Agent状态、工具、任务分解、错误恢复和多Agent通信。

六十、如果开发LLM推理平台

如果目标是AI基础设施：

 Client
 ↓
 Gateway
 ↓
 FastAPI
 ↓
 Load Balancer
 ↓
 ┌───────────┼───────────┐
 ↓ ↓ ↓
 vLLM vLLM vLLM
 ↓ ↓ ↓
 GPU GPU GPU

主要技术：

PyTorch
Transformers
vLLM
FastAPI
Ray
CUDA
Prometheus
Grafana
Docker
Kubernetes

这个方向与传统：

Java
Spring Boot
Kubernetes
Microservices
Observability

有很强的技术迁移关系。

六十一、AI开发真正需要掌握的Python能力

不要把AI开发理解成：

Python语法
+
调用OpenAI API

真正的AI Engineer至少需要理解：

Python
 │
 ├── OOP
 ├── Type Hint
 ├── AsyncIO
 ├── Generator
 ├── Decorator
 ├── Context Manager
 ├── Multiprocessing
 ├── Packaging
 │
 ↓
Data
 │
 ├── NumPy
 ├── Pandas
 └── Polars
 │
 ↓
ML
 │
 ├── Scikit-learn
 ├── XGBoost
 └── LightGBM
 │
 ↓
Deep Learning
 │
 └── PyTorch
 │
 ↓
LLM
 │
 ├── Transformers
 ├── PEFT
 └── TRL
 │
 ↓
RAG
 │
 ├── Embedding
 ├── Vector DB
 └── Retrieval
 │
 ↓
Agent
 │
 ├── LangGraph
 ├── Tool
 └── Workflow
 │
 ↓
Production
 │
 ├── FastAPI
 ├── Redis
 ├── Kubernetes
 └── Observability

六十二、AI开发中最值得优先掌握的库

如果从工程师角度排序，我更推荐：

优先级	库	核心作用
⭐⭐⭐⭐⭐	NumPy	数值计算
⭐⭐⭐⭐⭐	PyTorch	深度学习
⭐⭐⭐⭐⭐	Transformers	LLM
⭐⭐⭐⭐⭐	FastAPI	AI服务
⭐⭐⭐⭐⭐	Pydantic	数据与Schema
⭐⭐⭐⭐⭐	Sentence Transformers	Embedding
⭐⭐⭐⭐⭐	LangGraph	Agent
⭐⭐⭐⭐⭐	FAISS / Qdrant / Milvus	Vector Search
⭐⭐⭐⭐	Pandas	数据处理
⭐⭐⭐⭐	Scikit-learn	传统ML
⭐⭐⭐⭐	OpenAI SDK	LLM API
⭐⭐⭐⭐	vLLM	LLM推理
⭐⭐⭐⭐	Redis	Cache/State
⭐⭐⭐	LlamaIndex	RAG
⭐⭐⭐	LangChain	LLM编排
⭐⭐⭐	Playwright	Browser Agent
⭐⭐⭐	PyMuPDF	PDF处理
⭐⭐⭐	OpenCV	Computer Vision
⭐⭐⭐	MLflow	ML生命周期
⭐⭐⭐	Ray	分布式AI

六十三、一个AI Engineer真正应该形成的技术地图

最终可以形成下面这张地图：

 AI Engineer
 │
 ┌───────────────┼────────────────┐
 │ │ │
 AI Model AI Application AI Platform
 │ │ │
 ↓ ↓ ↓
 PyTorch RAG/Agent vLLM
 Transformers LangGraph Ray
 PEFT FastAPI CUDA
 TRL Pydantic K8s
 │ │ │
 └───────────────┼────────────────┘
 ↓
 Data Layer
 │
 ┌───────────┼───────────┐
 ↓ ↓ ↓
 Pandas Redis Vector DB
 Polars SQL Milvus
 Qdrant
 │
 ↓
 Observability
 │
 Prometheus/Grafana

六十四、最重要的认知：不要“背Python库”

AI工程师最容易陷入一个误区：

“我要把这些库全部学一遍。”

实际上没有必要。

真正应该掌握的是：

问题
 ↓
选择技术
 ↓
组合组件
 ↓
解决工程问题

例如：

问题1：我要处理PDF

选择：

PyMuPDF

问题2：我要做Embedding

选择：

Sentence Transformers

问题3：我要做Vector Search

选择：

FAISS / Qdrant / Milvus

问题4：我要做Agent

选择：

LangGraph

问题5：我要部署LLM

选择：

vLLM

问题6：我要做AI API

选择：

FastAPI + Pydantic

问题7：我要做生产监控

选择：

Prometheus + Grafana

这才是AI Engineering的正确思维。

六十五、从传统Java后端到AI Engineer

对于已经有Java/Spring Boot/微服务经验的工程师，实际上并不需要从零开始。

很多能力可以直接迁移。

Java后端	AI/Python
Spring Boot	FastAPI
Jackson	Pydantic
Maven	Poetry / uv / pip
CompletableFuture	asyncio
Redis	Redis
Kafka	Kafka
MyBatis/JPA	SQLAlchemy
Microservice	AI Service
Gateway	AI Gateway
OpenTelemetry	OpenTelemetry
Prometheus	Prometheus
Kubernetes	Kubernetes
Docker	Docker
Service Discovery	AI Service Discovery
Workflow	LangGraph
RPC/Tool	Agent Tool
Database	Vector DB
Cache	Semantic Cache
Service	Agent
Scheduler	Agent Workflow

因此对于有多年Java后端经验的工程师：

最大的变化不是从Java切换到Python，而是从传统Business Logic转向AI-Native Architecture。

六十六、最终总结

现代AI开发的Python生态已经形成了非常完整的技术体系：

 Python AI Ecosystem
 │
 ┌────────────────┼─────────────────┐
 ↓ ↓ ↓
 Data ML AI
 │ │ │
 NumPy/Pandas sklearn/XGBoost PyTorch
 Polars LightGBM Transformers
 │ │ │
 └────────────────┼─────────────────┘
 ↓
 LLM
 │
 ┌──────────┼──────────┐
 ↓ ↓ ↓
 RAG Agent Inference
 ↓ ↓ ↓
 Vector DB LangGraph vLLM
 Embedding Tools Ray
 │ │ │
 └──────────┼──────────┘
 ↓
 AI Application
 │
 FastAPI/Pydantic
 │
 Redis/PostgreSQL
 │
 Prometheus/Grafana
 │
 Kubernetes

如果从AI开发专家的角度看，我认为最重要的不是掌握几十个Python库，而是建立下面这条完整认知链：

Python
 ↓
Data
 ↓
Machine Learning
 ↓
Deep Learning
 ↓
Transformer
 ↓
LLM
 ↓
Embedding
 ↓
RAG
 ↓
Agent
 ↓
Multi-Agent
 ↓
AI Application
 ↓
AI Infrastructure
 ↓
Production AI

CNN 深度技术详解：从卷积数学原理到现代计算机视觉工程实践

Wed, 05 Aug 2026 00:00:00 +0000

CNN（Convolutional Neural Network，卷积神经网络）是深度学习历史上最重要的模型架构之一。

从图像分类、目标检测、图像分割，到OCR、人脸识别、医学影像和视频分析，CNN曾经长期占据计算机视觉的核心位置。

即使今天 Vision Transformer（ViT）和多模态大模型快速发展，CNN依然没有消失。相反，理解CNN仍然是理解现代Computer Vision、理解视觉模型和理解神经网络底层计算机制的重要基础。

本文不把CNN简单理解为“卷积 + 池化 + 全连接”，而是从数学、计算图和工程实现三个层面重新理解CNN。

一、CNN到底解决了什么问题？

假设有一张RGB图片：

224 × 224 × 3

如果使用传统全连接神经网络：

224 × 224 × 3
 ↓
 150528
 ↓
 Dense
 ↓
 Dense
 ↓
 Prediction

第一个全连接层假设有1000个神经元，那么参数数量：

150528 × 1000
≈ 150 million

这会产生两个严重问题：

参数量巨大
完全忽略图像的空间结构

图片中相邻像素通常具有强相关性：

Pixel
 ↓
Neighbor Pixel
 ↓
Local Pattern
 ↓
Object

例如：

边缘
 ↓
纹理
 ↓
局部形状
 ↓
物体部件
 ↓
完整物体

CNN的核心思想就是：

利用局部连接和参数共享，在保持空间结构的同时提取视觉特征。

二、CNN最核心的三个思想

CNN真正重要的不是“卷积”两个字，而是三个设计思想：

1. Local Connectivity
2. Parameter Sharing
3. Hierarchical Feature Learning

2.1 Local Connectivity：局部连接

假设：

5 × 5 Image

我们不让一个神经元连接所有25个像素，而只观察：

3 × 3

区域：

┌───────────────┐
│ │
│ ┌───────┐ │
│ │ 3 × 3 │ │
│ │ Kernel│ │
│ └───────┘ │
│ │
└───────────────┘

这样神经元只关注局部区域。

这与视觉系统中的局部感受野具有一定的对应关系。

三、Parameter Sharing：参数共享

这是CNN最重要的设计之一。

假设一个3×3卷积核：

1 0 -1
1 0 -1
1 0 -1

它可能用于检测：

垂直边缘。

这个Kernel不是只使用一次，而是在整张图片上滑动：

Image
 ↓
Kernel
 ↓
左上区域
 ↓
右移
 ↓
继续计算
 ↓
整个Image

也就是说：

同一组参数被重复用于不同空间位置。

这就是参数共享。

四、卷积到底在计算什么？

假设输入：

3 × 3

为：

1 2 3
4 5 6
7 8 9

Kernel：

1 0
0 1

进行一次卷积：

1×1 + 2×0
+ 4×0 + 5×1

得到：

Kernel向右移动：

2 3
5 6

得到：

2×1 + 3×0
+ 5×0 + 6×1
= 8

继续移动：

3 4
6 7

得到：

于是形成：

6 8
12 14

这就是Feature Map。

五、严格来说，CNN使用的是Cross-Correlation

很多教材直接把这个操作叫Convolution。

但从数学定义来说，深度学习框架中的：

torch.nn.Conv2d

通常执行的是cross-correlation，而不是严格意义上的数学卷积。

严格卷积需要：

Kernel Flip

即：

a b
c d

变成：

d c
b a

而深度学习中通常直接使用原始Kernel进行滑动计算。

由于Kernel参数本身是通过训练学习得到的，因此这种差异通常不影响神经网络的表达能力。

六、CNN输入数据到底是什么？

对于普通RGB图片：

Height × Width × Channels

例如：

224 × 224 × 3

但是PyTorch默认格式是：

Batch × Channels × Height × Width

即：

N × C × H × W

例如：

32 × 3 × 224 × 224

表示：

Batch = 32
Channels = 3
Height = 224
Width = 224

这是PyTorch CNN开发必须熟悉的数据格式。

七、一个卷积层包含什么？

例如：

nn.Conv2d(
 in_channels=3,
 out_channels=64,
 kernel_size=3
)

含义：

输入Channel
 ↓
 3
 ↓
3 × 3 Kernel
 ↓
64个Filter
 ↓
64个Feature Maps

所以：

Output Channels = Number of Filters

八、卷积核和Filter有什么区别？

实际工程中经常混用。

对于：

Input Channels = 3

一个完整Filter实际上不是：

3 × 3

而是：

3 × 3 × 3

因为它需要覆盖RGB三个Channel。

如果：

Input Channels = 64
Output Channels = 128
Kernel = 3 × 3

参数量：

128 × 64 × 3 × 3

再加上Bias：

总参数：

128 × 64 × 3 × 3 + 128
= 73856

九、卷积输出尺寸怎么算？

这是CNN面试和实际开发中非常重要的公式。

对于二维卷积：

H_out =
floor(
(H + 2P - D(K-1) - 1) / S
+ 1
)

W方向同理。

其中：

H = Input Height
W = Input Width
K = Kernel Size
P = Padding
S = Stride
D = Dilation

如果：

H = 32
K = 3
P = 1
S = 1
D = 1

那么：

H_out
=
(32 + 2 - 3) / 1 + 1
=
32

所以：

32 × 32

经过：

3 × 3
Padding=1
Stride=1

尺寸保持不变。

十、Stride：卷积移动的步长

Stride决定Kernel每次移动多少像素。

例如：

Stride = 1

表示：

→
每次移动1个Pixel

而：

Stride = 2

表示：

→→
每次移动2个Pixel

因此Stride越大：

Feature Map尺寸越小

例如：

224 × 224
 ↓
Stride = 2
 ↓
112 × 112

Stride本身就可以承担Downsampling作用。

十一、Padding：为什么需要补零？

如果没有Padding：

Input
 ↓
3 × 3 Kernel
 ↓
Output尺寸减少

例如：

连续使用很多卷积后：

32
 ↓
30
 ↓
28
 ↓
26
 ↓
...

空间尺寸会快速缩小。

Padding可以保持尺寸。

例如：

Input:
32 × 32

Padding:
1

Kernel:
3 × 3

Output:
32 × 32

十二、“Same"和"Valid”

常见概念：

Same
Valid

Valid

不Padding：

Input
 ↓
Kernel
 ↓
Output尺寸缩小

Same

通过Padding使：

Output ≈ Input

在Stride=1、奇数Kernel时尤其常见。

十三、多个Filter意味着什么？

假设：

Input:
224 × 224 × 3

第一层：

Conv2D
64 Filters

输出：

224 × 224 × 64

这64个Channel并不是64张原始图片。

而是：

64种不同的特征响应。

例如某些Filter可能学习：

Filter 1 → Vertical Edge

Filter 2 → Horizontal Edge

Filter 3 → Corner

Filter 4 → Texture

Filter 5 → Color Pattern

这些特征不是人工定义的，而是训练过程中自动学习出来的。

十四、CNN的层级特征学习

这是理解CNN最重要的概念之一。

CNN浅层：

Pixel
 ↓
Edge

中层：

Edge
 ↓
Texture
 ↓
Shape

深层：

Shape
 ↓
Part
 ↓
Object

例如识别猫：

Layer 1
 ↓
边缘

Layer 2
 ↓
纹理

Layer 3
 ↓
耳朵、眼睛

Layer 4
 ↓
猫脸

Layer 5
 ↓
Cat

这就是：

Hierarchical Representation Learning

十五、ReLU为什么需要存在？

卷积之后通常需要激活函数。

最经典的是：

ReLU(x) = max(0, x)

例如：

-3 → 0
-1 → 0
 0 → 0
 2 → 2
 5 → 5

代码：

nn.ReLU()

为什么需要它？

因为如果所有层都只是：

Linear
+
Linear
+
Linear

最终仍然可以表示成一个线性变换。

ReLU引入非线性：

Conv
 ↓
ReLU
 ↓
Conv
 ↓
ReLU

于是网络拥有更强的表达能力。

十六、为什么CNN通常是Conv + ReLU？

经典结构：

Input
 ↓
Conv
 ↓
ReLU
 ↓
Conv
 ↓
ReLU
 ↓
Pooling

现代网络可能进一步加入：

BatchNorm
Dropout
Residual Connection
Attention

形成：

Conv
 ↓
BatchNorm
 ↓
ReLU
 ↓
Conv
 ↓
Residual

十七、Pooling是什么？

Pooling用于：

降低Feature Map空间尺寸。

最经典的是Max Pooling：

2 × 2

例如：

1 3
2 4

Max Pooling：

对于：

4 × 4

可以变成：

2 × 2

十八、Max Pooling到底保留了什么？

例如：

2×2 Max Pool：

8 2
3 5

它保留：

局部区域中的最强激活。

所以可以理解成：

Feature Detector
 ↓
强响应
 ↓
Max Pooling
 ↓
保留最明显特征

十九、Average Pooling

另一种是：

Average Pooling

例如：

1 2
3 4

平均值：

(1+2+3+4)/4
=2.5

相比Max Pooling：

Max Pooling
→ 强调最强特征

Average Pooling
→ 强调整体统计

现代CNN中，Global Average Pooling非常常见。

二十、Global Average Pooling

假设：

7 × 7 × 512

经过：

Global Average Pooling

变成：

1 × 1 × 512

于是得到：

512-dimensional vector

然后可以直接：

Linear
 ↓
Classes

这可以减少大量参数。

二十一、经典CNN结构：LeNet

LeNet是CNN历史上的经典架构。

大致：

Input
 ↓
Conv
 ↓
Pooling
 ↓
Conv
 ↓
Pooling
 ↓
FC
 ↓
Output

它主要用于：

手写数字识别。

LeNet的重要意义是证明：

卷积 + 局部连接 + 参数共享可以有效解决视觉识别问题。

二十二、AlexNet：深度学习视觉革命

2012年的AlexNet是CNN发展史上的重要节点。

核心特点：

更深的网络
ReLU
GPU训练
Dropout
Data Augmentation
Max Pooling

结构可以简化理解为：

Image
 ↓
Conv
 ↓
ReLU
 ↓
Pool
 ↓
Conv
 ↓
ReLU
 ↓
Pool
 ↓
...
 ↓
FC
 ↓
Classification

AlexNet推动了深度学习重新成为Computer Vision主流。

二十三、VGG：用小卷积堆叠深度

VGG的重要思想：

使用多个3×3卷积代替较大的卷积核。

例如：

7 × 7

可以用：

3 × 3
3 × 3
3 × 3

进行堆叠。

优势：

更多非线性
更深的网络
更小的Kernel

经典：

VGG16
VGG19

二十四、为什么多个3×3比一个7×7更有吸引力？

假设单个：

7 × 7

参数：

49C²

三个：

3 × 3

参数：

27C²

同时还增加了多次非线性激活。

所以：

3×3
 ↓
ReLU
 ↓
3×3
 ↓
ReLU
 ↓
3×3

具有更强的表达能力。

二十五、ResNet：解决深层网络训练问题

随着网络越来越深：

20层
 ↓
50层
 ↓
100层
 ↓
1000层

出现：

Degradation Problem

不是简单的过拟合，而是网络越深，优化反而变困难。

ResNet提出：

Residual Connection

二十六、Residual Connection

传统：

x
 ↓
F(x)
 ↓
y

ResNet：

 ┌──────────────┐
 │ │
x ─────┼→ F(x) ───────┤
 │ ↓
 └────────────→ +
 ↓
 y

数学：

y = F(x) + x

也就是说网络不直接学习：

H(x)

而是学习：

F(x) = H(x) - x

这让深层网络更容易优化。

二十七、ResNet为什么如此重要？

因为Residual Connection后来不仅影响CNN，也影响了Transformer。

现代Transformer中：

x
 ↓
Attention
 ↓
Add(x)
 ↓
LayerNorm

也存在类似：

Residual Connection

因此：

ResNet不仅是CNN架构，它影响了现代深度学习架构设计。

二十八、Batch Normalization

BatchNorm用于稳定网络训练。

基本思想：

原始激活
 ↓
Normalize
 ↓
Scale
 ↓
Shift

即：

x
 ↓
(x - μ) / √(σ² + ε)
 ↓
γx + β

它可以：

稳定训练
改善梯度传播
加快收敛

经典CNN结构：

Conv
 ↓
BatchNorm
 ↓
ReLU

二十九、Dropout

Dropout是一种正则化方法。

训练过程中：

Neuron
Neuron
Neuron
Neuron

随机关闭部分神经元。

例如：

○ ○ × ○ × ○

目的是减少：

Overfitting

不过现代CNN中，随着BatchNorm、Data Augmentation、Weight Decay等方法普及，Dropout的使用方式已经发生变化。

三十、CNN完整结构

一个经典CNN可以表示：

Input Image
 │
 ↓
 Conv2D
 │
 ↓
 BatchNorm
 │
 ↓
 ReLU
 │
 ↓
 Conv2D
 │
 ↓
 ReLU
 │
 ↓
 MaxPooling
 │
 ↓
 Conv Block
 │
 ↓
 Conv Block
 │
 ↓
 Global Average Pool
 │
 ↓
 Linear
 │
 ↓
 Softmax
 │
 ↓
 Classification

三十一、Softmax是什么？

假设模型输出：

[2.1, 0.8, -1.2]

Softmax将它转成概率：

[0.75, 0.20, 0.05]

公式：

P_i = e^z_i / Σ e^z_j

最终：

Cat: 0.75
Dog: 0.20
Car: 0.05

预测：

Cat

三十二、CNN是如何训练出来的？

整个训练过程：

Image
 ↓
CNN Forward
 ↓
Prediction
 ↓
Loss
 ↓
Backpropagation
 ↓
Gradient
 ↓
Optimizer
 ↓
Update Weights
 ↓
Repeat

例如：

loss.backward()
optimizer.step()

三十三、Loss Function

分类任务常用：

Cross Entropy Loss

例如：

criterion = nn.CrossEntropyLoss()

如果真实标签：

Cat

模型预测：

Cat = 0.9
Dog = 0.1

Loss较低。

如果：

Cat = 0.01
Dog = 0.99

Loss很高。

模型通过Loss知道：

当前预测距离正确答案有多远。

三十四、CNN反向传播到底发生了什么？

Forward：

Input
 ↓
Conv
 ↓
ReLU
 ↓
Conv
 ↓
Loss

Backward：

Loss
 ↓
∂Loss/∂Conv2
 ↓
∂Loss/∂ReLU
 ↓
∂Loss/∂Conv1
 ↓
∂Loss/∂Kernel

最终更新：

Kernel

所以CNN中的：

Edge Detector
Texture Detector
Shape Detector

并不是人工写出来的。

而是：

通过反向传播自动学习出来的。

三十五、CNN如何学习一个Edge Detector？

假设模型发现：

Kernel A

能够让某种边缘产生较高激活。

那么训练过程会：

Prediction错误
 ↓
Loss
 ↓
Gradient
 ↓
调整Kernel
 ↓
Edge响应增强

经过数百万次训练样本后：

随机Kernel
 ↓
有意义的Feature Detector

逐渐形成。

这就是Representation Learning。

三十六、感受野 Receptive Field

CNN另一个非常重要的概念：

Receptive Field

一个神经元最终能够“看到”原始图片中的多大区域？

例如：

Layer 1
3×3

感受野：

3×3

再经过一个：

3×3

理论感受野变成：

5×5

再加一层：

7×7

因此：

Network越深
 ↓
Receptive Field越大

浅层：

Local Features

深层：

Global / Semantic Features

三十七、Dilation Convolution

普通卷积：

● ● ●
● ● ●
● ● ●

Dilation可以扩大Kernel的间隔：

● ● ●

● ● ●

● ● ●

这样可以：

增大感受野，同时不显著增加参数量。

常用于：

Semantic Segmentation
Image Processing
Dense Prediction

三十八、Depthwise Separable Convolution

普通卷积：

Input
 ↓
Standard Conv
 ↓
Output

Depthwise Separable Convolution：

Input
 ↓
Depthwise Conv
 ↓
Pointwise Conv
 ↓
Output

Pointwise就是：

1 × 1 Conv

这种设计可以显著降低计算量。

典型代表：

MobileNet

三十九、1×1 Convolution有什么用？

很多人第一次看到：

Conv2d(kernel_size=1)

会觉得：

1×1卷积不是没有空间感受野吗？

它的重要作用之一是：

改变Channel维度。

例如：

56 × 56 × 256

经过：

1 × 1 Conv
64 filters

得到：

56 × 56 × 64

空间尺寸不变，但Channel从：

256 → 64

因此1×1 Conv可以理解成：

对每一个像素位置上的Channel向量进行一次Linear Projection。

四十、CNN计算量如何估算？

卷积层FLOPs通常与：

H × W × Cin × Cout × K²

有关。

例如：

H = 56
W = 56
Cin = 64
Cout = 128
K = 3

计算规模大约：

56 × 56 × 64 × 128 × 9

因此CNN优化时需要重点关注：

Feature Map Size
Channels
Kernel Size
Batch Size

四十一、CNN为什么适合GPU？

CNN本质上包含大量：

Matrix Operation
Tensor Operation
Parallel Computation

例如：

Image
 ↓
Millions of Multiply-Add
 ↓
GPU

GPU拥有大量计算核心，非常适合执行这类高度并行的运算。

PyTorch：

model.cuda()

就可以把模型放到GPU上。

四十二、PyTorch实现一个CNN

一个简单的CNN：

import torch
import torch.nn as nn


class CNN(nn.Module):

 def __init__(self, num_classes=10):
 super().__init__()

 self.features = nn.Sequential(
 nn.Conv2d(3, 32, 3, padding=1),
 nn.BatchNorm2d(32),
 nn.ReLU(),

 nn.Conv2d(32, 64, 3, padding=1),
 nn.BatchNorm2d(64),
 nn.ReLU(),

 nn.MaxPool2d(2),

 nn.Conv2d(64, 128, 3, padding=1),
 nn.BatchNorm2d(128),
 nn.ReLU(),

 nn.AdaptiveAvgPool2d(1)
 )

 self.classifier = nn.Linear(
 128,
 num_classes
 )

 def forward(self, x):

 x = self.features(x)

 x = torch.flatten(x, 1)

 return self.classifier(x)

这里：

Input
3 × H × W
 ↓
Conv 32
 ↓
Conv 64
 ↓
MaxPool
 ↓
Conv 128
 ↓
Global Average Pool
 ↓
128
 ↓
Linear
 ↓
Classes

四十三、为什么使用AdaptiveAvgPool2d？

传统CNN经常：

Flatten
 ↓
Fully Connected

例如：

7 × 7 × 512

Flatten：

然后：

25088 → 4096

参数量巨大。

使用：

nn.AdaptiveAvgPool2d(1)

直接得到：

1 × 1 × 512

因此：

512 → Classes

参数大幅下降。

四十四、CNN中的Data Augmentation

训练图像模型时，数据增强非常重要。

常见：

Random Crop
Random Flip
Rotation
Color Jitter
Resize
Normalization

例如：

from torchvision import transforms

transform = transforms.Compose([
 transforms.RandomResizedCrop(224),
 transforms.RandomHorizontalFlip(),
 transforms.ToTensor(),
])

为什么有效？

因为我们希望模型学习：

Object

而不是：

Specific Pixel Arrangement

例如猫向左：

Cat →

和猫向右：

← Cat

应该属于同一类别。

四十五、CNN在目标检测中的应用

CNN不只是分类。

目标检测任务：

Image
 ↓
CNN Backbone
 ↓
Feature Maps
 ↓
Detection Head
 ↓
Bounding Boxes

例如：

┌──────────────────────┐
│ │
│ ┌───────┐ │
│ │ Cat │ │
│ └───────┘ │
│ ┌───┐ │
│ │Dog│ │
│ └───┘ │
└──────────────────────┘

经典模型：

R-CNN
Fast R-CNN
Faster R-CNN
YOLO
SSD
RetinaNet

很多经典检测模型都以CNN作为Backbone。

四十六、CNN在图像分割中的应用

语义分割：

Image
 ↓
CNN Encoder
 ↓
Feature
 ↓
Decoder
 ↓
Pixel-level Prediction

经典架构：

U-Net
FCN
DeepLab

最终输出：

每一个Pixel
 ↓
Class

例如：

Pixel 1 → Road
Pixel 2 → Road
Pixel 3 → Car
Pixel 4 → Person

四十七、CNN与Transformer的关系

近年来：

CNN
 ↓
ViT
 ↓
Swin Transformer
 ↓
Vision-Language Model
 ↓
Multimodal LLM

Transformer在视觉领域快速发展。

但是不能简单认为：

CNN已经被Transformer淘汰。

二者解决问题的思路不同。

四十八、CNN vs Vision Transformer

CNN：

Local
 ↓
Hierarchical
 ↓
Global

Transformer：

Patch
 ↓
Attention
 ↓
Global Interaction

CNN天然具有：

Locality
Translation Equivariance
Parameter Sharing

Transformer更加擅长：

Long-range Dependency
Global Context
Flexible Attention

四十九、为什么Transformer需要大量数据？

CNN拥有比较强的Inductive Bias：

Locality
Spatial Structure
Translation Equivariance

也就是说CNN：

对图像结构已经有先验假设。

Transformer的先验更弱。

因此通常需要更多数据来学习：

什么是局部关系？
什么是空间关系？
什么是物体结构？

这也是CNN在数据规模有限的视觉任务中仍然具有价值的原因之一。

五十、现代CNN已经发生了什么变化？

现代CNN已经不再是简单：

Conv
 ↓
Pool
 ↓
Conv
 ↓
Pool

而是逐渐演化为：

Residual
Depthwise Conv
Attention
Normalization
Large Kernel
Multi-scale
Feature Pyramid

代表架构包括：

ResNet
DenseNet
MobileNet
EfficientNet
ConvNeXt

其中ConvNeXt尤其值得关注。

五十一、ConvNeXt：现代CNN重新思考

ConvNeXt的思想之一是：

把Transformer时代的一些设计经验重新应用到CNN。

例如：

Large Kernel
LayerNorm
Depthwise Conv
Modern Training Recipe

这说明一个非常重要的事实：

CNN和Transformer并不是完全割裂的两套体系。

现代视觉模型正在不断融合两者的思想。

五十二、CNN真正的核心知识体系

如果把CNN压缩成一张知识地图：

CNN
│
├── Tensor
│
├── Convolution
│ ├── Kernel
│ ├── Filter
│ ├── Stride
│ ├── Padding
│ └── Dilation
│
├── Feature
│ ├── Edge
│ ├── Texture
│ ├── Shape
│ └── Semantic
│
├── Downsampling
│ ├── MaxPool
│ ├── AvgPool
│ └── Stride Conv
│
├── Nonlinearity
│ └── ReLU
│
├── Normalization
│ └── BatchNorm
│
├── Optimization
│ ├── Loss
│ ├── Backprop
│ └── Optimizer
│
├── Architecture
│ ├── LeNet
│ ├── AlexNet
│ ├── VGG
│ ├── ResNet
│ ├── MobileNet
│ └── ConvNeXt
│
└── Applications
 ├── Classification
 ├── Detection
 ├── Segmentation
 ├── OCR
 └── Video

五十三、作为AI Engineer，CNN应该学到什么程度？

如果目标是AI应用开发，不一定需要自己实现一个完整CNN训练框架。

但是以下内容必须理解：

第一层：必须掌握

Tensor
Conv
Kernel
Channel
Stride
Padding
Pooling
ReLU
Feature Map

第二层：深入理解

Forward
Backpropagation
Gradient
Loss
Optimizer
Receptive Field
BatchNorm
Residual

第三层：模型架构

LeNet
AlexNet
VGG
ResNet
MobileNet
EfficientNet
ConvNeXt

第四层：工程实践

PyTorch
CUDA
GPU
Mixed Precision
Data Augmentation
Distributed Training
Model Export
Inference

五十四、CNN最重要的本质

如果只记住CNN的几个核心思想，可以记住：

 CNN
 │
 ┌─────────┼─────────┐
 ↓ ↓ ↓
 Local Sharing Hierarchy
 │ │ │
 ↓ ↓ ↓
 局部 参数共享 层级特征
 │ │ │
 └─────────┼─────────┘
 ↓
 Visual Representation
 ↓
 Classification / Detection
 Segmentation / Recognition

CNN真正厉害的地方不是：

“用一个3×3的Kernel扫描图片。”

而是：

通过局部连接和参数共享，把原始像素逐层转换成越来越抽象的视觉表示。

最终：

Pixels
 ↓
Edges
 ↓
Textures
 ↓
Shapes
 ↓
Objects
 ↓
Semantics

这就是CNN最核心的思想。

五十五、从CNN进一步理解现代AI

如果继续向现代AI发展，可以沿着下面的技术演化理解：

CNN
 │
 ├── ResNet
 │
 ├── Object Detection
 │
 ├── Semantic Segmentation
 │
 ├── Vision Transformer
 │
 ├── CLIP
 │
 ├── Vision-Language Model
 │
 └── Multimodal LLM

最终会发现：

CNN
 ↓
Computer Vision
 ↓
Visual Representation
 ↓
Multimodal Representation
 ↓
Vision-Language Model
 ↓
Multimodal Agent

所以学习CNN并不是学习一项“过时技术”，而是在学习：

现代视觉AI的基础计算思想。

结语

CNN经历了从LeNet、AlexNet、VGG到ResNet，再到MobileNet、EfficientNet和ConvNeXt的发展。

它解决的核心问题始终没有改变：

如何让神经网络高效地从空间结构数据中学习层级化特征。

从工程角度看，CNN最值得掌握的不是背诵网络结构，而是理解：

Input Tensor
 ↓
Convolution
 ↓
Feature Extraction
 ↓
Non-linearity
 ↓
Downsampling
 ↓
Hierarchical Representation
 ↓
Prediction
 ↓
Loss
 ↓
Backpropagation
 ↓
Weight Update

一旦真正理解这条链路，后面学习：

ResNet
MobileNet
EfficientNet
ConvNeXt
ViT
Swin Transformer
CLIP
Vision-Language Model
Multimodal LLM

都会容易很多。

CNN不是计算机视觉的终点，而是理解现代视觉AI的一个重要起点。

DNN：从神经元数学原理到现代深度学习架构

Wed, 05 Aug 2026 00:00:00 +0000

DNN（Deep Neural Network，深度神经网络）是现代人工智能最基础、最重要的模型体系之一。

CNN解决了空间结构数据的问题，RNN解决了序列数据的问题，而Transformer进一步解决了长距离依赖和大规模并行计算问题。

但它们的共同基础仍然是：

神经元 + 线性变换 + 非线性激活 + 损失函数 + 反向传播 + 梯度下降。

因此，真正理解DNN，是理解CNN、RNN、Transformer、LLM乃至现代Agent模型底层训练机制的重要基础。

一、DNN到底是什么？

DNN：

Deep Neural Network

中文：

深度神经网络

最简单的神经网络：

Input
 ↓
Output

而DNN：

Input
 ↓
Hidden Layer
 ↓
Hidden Layer
 ↓
Hidden Layer
 ↓
Output

这里的核心概念是：

存在多个隐藏层。

因此：

Shallow Neural Network

通常指隐藏层较少的网络。

而：

Deep Neural Network

则通过多层网络逐渐学习更加复杂的特征。

二、DNN解决的核心问题

假设我们要预测：

用户是否会购买商品？

输入：

年龄
收入
访问次数
停留时间
历史购买次数
设备类型
地区

可以表示：

x = [age, income, visits, duration, purchases, ...]

传统程序可能写：

if income > X
and visits > Y
and purchases > Z:
 buy

问题是：

人工很难写出复杂的数据规律。

DNN的思路是：

Data
 ↓
Neural Network
 ↓
自动学习规律
 ↓
Prediction

也就是说：

DNN通过数据自动学习输入与输出之间的复杂非线性映射。

数学上：

y = f(x)

DNN希望学习：

fθ(x)

其中：

θ = 所有需要学习的参数

三、DNN最基本的组成：神经元

一个神经元可以表示：

x1 ──w1──┐
x2 ──w2──┤
x3 ──w3──┤
 ↓
 Σ + bias
 ↓
 Activation
 ↓
 y

数学公式：

z = w1x1 + w2x2 + w3x3 + b

也可以写成：

z = wᵀx + b

然后经过激活函数：

a = f(z)

所以一个神经元实际上就是：

Linear Transformation
 +
Non-linear Activation

四、Weight到底是什么？

Weight是模型需要学习的参数。

例如：

x1 = 年龄
x2 = 收入
x3 = 购买次数

模型可能学习：

w1 = 0.2
w2 = 0.7
w3 = 1.8

意味着：

购买次数

对最终结果的影响可能比：

年龄

更大。

训练过程中，模型不断调整：

w1
w2
w3
...

最终找到一组比较合适的参数。

五、Bias是什么？

神经元：

z = wᵀx

可能无法灵活调整。

因此加入：

变成：

z = wᵀx + b

Bias可以理解成：

对神经元输出进行额外偏移。

六、DNN最重要的结构：Layer

一个Layer可以包含大量Neuron。

例如：

Input Layer
 ↓
[ x1 x2 x3 x4 ]
 ↓
Hidden Layer
[ ○ ○ ○ ○ ○ ○ ]
 ↓
Hidden Layer
[ ○ ○ ○ ○ ]
 ↓
Output
[ ○ ]

如果：

Input = 10
Hidden1 = 128
Hidden2 = 64
Output = 1

那么：

就是一个典型DNN。

七、Fully Connected Layer

DNN中最常见的层：

Fully Connected Layer

PyTorch：

nn.Linear()

例如：

nn.Linear(10, 128)

表示：

10 inputs
 ↓
128 neurons

参数数量：

10 × 128 + 128

即：

其中：

10 × 128

是Weight。

是Bias。

八、DNN的矩阵表示

如果：

是输入向量：

x ∈ R^n

Weight：

W ∈ R^(m×n)

那么：

z = Wx + b

输出：

z ∈ R^m

这就是DNN最核心的计算。

例如：

Input:
10

Weight:
128 × 10

Output:
128

九、为什么需要“深度”？

假设只有一层：

x
 ↓
Linear
 ↓
y

本质上还是：

y = Wx + b

这是线性模型。

如果连续堆叠：

x
 ↓
Linear
 ↓
Linear
 ↓
Linear
 ↓
y

如果中间没有激活函数：

W3(W2(W1x))

最终仍然可以合并成：

W'x

也就是说：

单纯增加Linear层并不会产生真正的深度表达能力。

因此必须加入非线性激活函数。

十、Activation Function为什么重要？

核心结构：

Linear
 ↓
Activation
 ↓
Linear
 ↓
Activation

例如：

z1 = W1x + b1

a1 = ReLU(z1)

z2 = W2a1 + b2

a2 = ReLU(z2)

于是模型变成：

y = f(W2 f(W1x + b1) + b2)

由于：

f()

是非线性的，网络才能表达复杂函数。

十一、ReLU：最经典的激活函数

ReLU：

ReLU(x) = max(0, x)

例如：

-3 → 0
-1 → 0
 0 → 0
 2 → 2
 5 → 5

PyTorch：

nn.ReLU()

ReLU的优势：

计算简单
梯度传播相对稳定
训练速度快

因此长期成为深度学习中的经典激活函数。

十二、Sigmoid

Sigmoid：

σ(x) = 1 / (1 + e^-x)

输出范围：

(0, 1)

因此特别适合：

Binary Classification

例如：

Spam = 0.95

可以理解为：

95% probability

但是Sigmoid在深层网络中容易出现：

Vanishing Gradient

因此隐藏层通常不再首选Sigmoid。

十三、Tanh

Tanh：

tanh(x)

输出范围：

(-1, 1)

相比Sigmoid：

中心在0附近

因此在一些传统RNN网络中比较常见。

但在现代深度网络中：

ReLU
GELU
SiLU

更加常见。

十四、GELU

Transformer和现代深度学习模型中常见：

GELU

GELU可以理解为一种更加平滑的激活函数。

Transformer类模型中常见：

Linear
 ↓
GELU
 ↓
Linear

例如：

nn.GELU()

十五、DNN的完整前向传播

假设：

Input
 ↓
Linear
 ↓
ReLU
 ↓
Linear
 ↓
ReLU
 ↓
Linear
 ↓
Output

数学：

z1 = W1x + b1

a1 = ReLU(z1)

z2 = W2a1 + b2

a2 = ReLU(z2)

z3 = W3a2 + b3

最终：

ŷ = z3

这就是：

Forward Propagation

即：

前向传播。

十六、Loss：模型怎么知道自己错了？

模型预测：

ŷ

真实值：

我们需要衡量：

ŷ 和 y 差多少？

因此定义：

Loss Function

例如回归：

MSE

分类：

Cross Entropy

十七、Mean Squared Error

MSE：

MSE = 1/n Σ(y - ŷ)²

例如：

真实值：

预测：

误差：

平方：

预测：

则：

Loss = 0

因此：

Loss越小，说明模型预测通常越接近目标。

十八、Cross Entropy

分类问题中经常使用：

Cross Entropy Loss

假设真实类别：

Cat

模型：

Cat = 0.9
Dog = 0.1

Loss较低。

如果：

Cat = 0.01
Dog = 0.99

Loss非常高。

因此模型会通过Loss获得反馈：

Prediction
 ↓
Loss
 ↓
Gradient
 ↓
Weight Update

十九、DNN真正的学习过程：反向传播

DNN最重要的机制之一：

Backpropagation

完整过程：

Input
 ↓
Forward
 ↓
Prediction
 ↓
Loss
 ↓
Backward
 ↓
Gradient
 ↓
Optimizer
 ↓
Update Weight

二十、什么是Gradient？

Gradient表示：

Loss对于某个参数变化的敏感程度。

例如：

Loss = f(w)

梯度：

dLoss / dw

如果：

gradient > 0

说明增加w可能导致Loss增加。

如果：

gradient < 0

说明增加w可能使Loss下降。

所以模型可以根据梯度调整参数。

二十一、Gradient Descent

最简单的更新公式：

w_new = w_old - η * gradient

其中：

η = Learning Rate

例如：

w = 10
gradient = 2
learning_rate = 0.1

更新：

w_new
=
10 - 0.1 × 2
=
9.8

不断重复：

Forward
 ↓
Loss
 ↓
Gradient
 ↓
Update

最终寻找一个Loss较低的位置。

二十二、Learning Rate为什么非常重要？

Learning Rate：

η

决定：

每次参数走多远。

太大：

Loss
 ↑
 │ /\ /\
 │ /\ / \ / \
 └────────────────→

模型可能：

震荡
发散

太小：

Loss下降非常慢

因此：

Learning Rate

是训练DNN最重要的超参数之一。

二十三、SGD

最经典优化器：

Stochastic Gradient Descent

基本公式：

w = w - η∇L

PyTorch：

optimizer = torch.optim.SGD(
 model.parameters(),
 lr=0.01
)

二十四、Momentum

SGD可能：

上下震荡

Momentum引入历史梯度：

velocity

大致思想：

当前方向
+
历史运动方向

类似：

一个带惯性的优化过程。

这样可以帮助模型更快地沿正确方向前进。

二十五、Adam

现代深度学习中非常常用：

Adam

Adam结合了：

Momentum
+
Adaptive Learning Rate

PyTorch：

optimizer = torch.optim.Adam(
 model.parameters(),
 lr=0.001
)

DNN实验中：

Adam

通常是非常好的起点。

二十六、Batch是什么？

假设有：

1,000,000

训练数据。

不可能每次把100万个样本全部送入GPU。

因此划分：

Batch

例如：

Batch Size = 32

每次训练：

32 samples

然后：

Next Batch

二十七、Epoch是什么？

一个Epoch表示：

整个训练数据集完整训练一次。

例如：

Dataset = 32000
Batch = 32

那么：

32000 / 32
= 1000 steps

一个Epoch：

1000 iterations

如果训练：

50 epochs

那么：

50000 iterations

二十八、Batch Size如何影响训练？

Batch太小：

Gradient Noise
↑
GPU利用率可能较低

Batch太大：

显存消耗
↑
Generalization可能变化

因此需要根据：

GPU Memory
Dataset
Model
Learning Rate

进行调整。

二十九、Overfitting：DNN最常见的问题

训练集：

Accuracy = 99.9%

测试集：

Accuracy = 75%

这说明模型：

记住了训练数据，却没有很好地学习一般规律。

这就是：

Overfitting

三十、如何解决Overfitting？

常见方法：

Data Augmentation
Dropout
Weight Decay
Early Stopping
More Data
Simpler Model
BatchNorm

核心目标：

让模型学习规律，而不是记忆训练样本。

三十一、Dropout

假设隐藏层：

○ ○ ○ ○ ○ ○ ○ ○

训练过程中随机关闭：

○ × ○ ○ × ○ × ○

这样可以减少：

神经元之间过度依赖。

PyTorch：

nn.Dropout(0.5)

表示训练过程中大约50%的激活被随机丢弃。

三十二、Weight Decay

Weight Decay通常对应L2正则化思想。

目标函数：

Loss_total
=
Loss_data
+
λ Σw²

这样可以惩罚过大的权重。

PyTorch：

optimizer = torch.optim.AdamW(
 model.parameters(),
 lr=1e-3,
 weight_decay=1e-4
)

现代深度学习中：

AdamW

非常常见。

三十三、Batch Normalization

BatchNorm可以对中间激活进行归一化。

大致：

x
 ↓
Normalize
 ↓
Scale
 ↓
Shift

公式：

x̂ = (x - μ) / √(σ² + ε)

y = γx̂ + β

其中：

γ
β

也是可以学习的参数。

三十四、为什么BatchNorm有帮助？

它可以：

稳定激活分布
 ↓
改善训练
 ↓
加快收敛
 ↓
一定程度减少对初始化的敏感性

CNN中：

Conv
 ↓
BatchNorm
 ↓
ReLU

非常经典。

三十五、LayerNorm

Transformer中更加常见：

LayerNorm

它和BatchNorm的归一化维度不同。

简单理解：

BatchNorm
→ 关注Batch维度上的统计

LayerNorm
→ 关注单个样本内部的特征维度

因此：

CNN
→ BatchNorm很常见

Transformer
→ LayerNorm / RMSNorm很常见

三十六、DNN参数初始化

如果所有参数：

W = 0

会出现：

Symmetry Problem

不同神经元会学习到相同的东西。

因此通常需要：

Random Initialization

常见：

Xavier Initialization
He Initialization

三十七、Xavier Initialization

适合：

Sigmoid
Tanh

核心思想是：

控制不同层之间的激活和梯度方差。

避免：

激活越来越大

或者：

激活越来越小

三十八、He Initialization

对于：

ReLU

通常使用：

He Initialization

PyTorch：

nn.init.kaiming_normal_()

核心目的是保持深层网络中：

Variance

相对稳定。

三十九、Vanishing Gradient

深层DNN中可能出现：

Gradient
 ↓
越来越小
 ↓
0

于是：

前面的Layer

几乎无法学习。

这就是：

Vanishing Gradient

常见原因：

Sigmoid
Tanh
Network太深
初始化不合理

解决方式包括：

ReLU
Better Initialization
BatchNorm
Residual Connection

四十、Exploding Gradient

另一种情况：

Gradient
 ↓
越来越大
 ↓
∞

导致训练：

NaN

或者：

Loss突然爆炸

常用：

Gradient Clipping
Better Initialization
Normalization
Lower Learning Rate

PyTorch：

torch.nn.utils.clip_grad_norm_(
 model.parameters(),
 max_norm=1.0
)

四十一、为什么Residual Connection可以解决深层网络问题？

传统：

x
 ↓
Layer
 ↓
Layer
 ↓
Layer
 ↓
y

Residual：

 ┌───────────────┐
 │ │
x ─────┼→ Layers ──────┤
 │ ↓
 └──────────────→+
 ↓
 y

数学：

y = F(x) + x

这样梯度可以沿着：

Identity Path

直接传播。

这也是：

ResNet能够训练很深网络的重要原因。

四十二、DNN与CNN是什么关系？

CNN可以理解成：

针对空间数据优化过的神经网络。

普通DNN：

Input
 ↓
Linear
 ↓
Linear
 ↓
Output

CNN：

Image
 ↓
Convolution
 ↓
Feature Map
 ↓
Pooling
 ↓
Convolution
 ↓
Output

核心区别：

DNN
→ Fully Connected

CNN
→ Local Connectivity + Parameter Sharing

四十三、DNN与RNN是什么关系？

RNN针对：

序列数据。

例如：

我
喜欢
学习
AI

RNN：

x1 → RNN → h1
 ↓
x2 → RNN → h2
 ↓
x3 → RNN → h3
 ↓
x4 → RNN → h4

而DNN没有这种天然的：

Temporal Dependency

四十四、DNN与Transformer是什么关系？

Transformer中的核心组件：

Attention
+
Feed Forward Network
+
Normalization
+
Residual

其中：

Feed Forward Network

本质上就是一个特殊的DNN：

Linear
 ↓
Activation
 ↓
Linear

例如：

x
 ↓
Linear
 ↓
GELU
 ↓
Linear
 ↓
Output

所以：

DNN并没有消失，而是成为Transformer内部的重要组成部分。

四十五、Transformer中的FFN到底是什么？

经典Transformer：

Input
 ↓
Self-Attention
 ↓
Add & Norm
 ↓
FFN
 ↓
Add & Norm

FFN：

FFN(x)
=
W2 · Activation(W1x + b1) + b2

这实际上就是：

两层DNN

例如：

Hidden Size = 4096

4096
 ↓
16384
 ↓
4096

这也是为什么理解DNN之后，再学习Transformer会容易很多。

四十六、LLM中的DNN在哪里？

一个Transformer Block：

 Transformer Block
 │
 ┌─────────────┴─────────────┐
 ↓ ↓
 Self Attention FFN
 ↓ ↓
 Linear Linear
 ↓ ↓
 └─────────────┬─────────────┘
 ↓
 Residual
 ↓
 Norm

其中FFN就是：

DNN

因此一个LLM并不是完全不同于传统神经网络的神秘系统。

它仍然建立在：

Linear
Activation
Gradient
Backpropagation
Optimization

这些基础机制之上。

四十七、用PyTorch实现一个完整DNN

下面实现一个简单的分类网络。

import torch
import torch.nn as nn


class DNN(nn.Module):

 def __init__(self, input_dim, num_classes):
 super().__init__()

 self.network = nn.Sequential(
 nn.Linear(input_dim, 256),
 nn.BatchNorm1d(256),
 nn.ReLU(),
 nn.Dropout(0.2),

 nn.Linear(256, 128),
 nn.BatchNorm1d(128),
 nn.ReLU(),
 nn.Dropout(0.2),

 nn.Linear(128, 64),
 nn.ReLU(),

 nn.Linear(64, num_classes)
 )

 def forward(self, x):
 return self.network(x)

结构：

Input
 ↓
Linear 256
 ↓
BatchNorm
 ↓
ReLU
 ↓
Dropout
 ↓
Linear 128
 ↓
BatchNorm
 ↓
ReLU
 ↓
Dropout
 ↓
Linear 64
 ↓
ReLU
 ↓
Output

四十八、DNN训练代码

model = DNN(
 input_dim=100,
 num_classes=10
)

criterion = nn.CrossEntropyLoss()

optimizer = torch.optim.AdamW(
 model.parameters(),
 lr=1e-3,
 weight_decay=1e-4
)

训练：

for epoch in range(10):

 model.train()

 for x, y in dataloader:

 optimizer.zero_grad()

 output = model(x)

 loss = criterion(output, y)

 loss.backward()

 optimizer.step()

 print(
 f"epoch={epoch}, loss={loss.item():.4f}"
 )

这几行代码实际上浓缩了整个深度学习训练机制：

zero_grad()
 ↓
Forward
 ↓
Loss
 ↓
Backward
 ↓
Optimizer Step

四十九、为什么要zero_grad()？

PyTorch默认会：

累积Gradient。

例如：

loss.backward()

计算：

∂Loss/∂W

之后Gradient会保存在：

parameter.grad

如果下一次不清理：

Gradient_previous
+
Gradient_current

所以训练循环通常：

optimizer.zero_grad()

然后：

loss.backward()

五十、DNN的计算图

现代深度学习框架核心思想之一是：

Computational Graph

例如：

x
 ↓
W1x+b1
 ↓
ReLU
 ↓
W2x+b2
 ↓
Loss

PyTorch会记录这些操作。

当执行：

loss.backward()

就可以沿着计算图反向计算：

∂Loss/∂W2
∂Loss/∂W1
∂Loss/∂b2
∂Loss/∂b1

这就是：

Automatic Differentiation

五十一、DNN训练的完整生命周期

一个生产级DNN项目通常不是：

写模型
 ↓
训练

而是：

Data Collection
 ↓
Data Cleaning
 ↓
Feature Engineering
 ↓
Train / Validation / Test
 ↓
Model Design
 ↓
Initialization
 ↓
Training
 ↓
Evaluation
 ↓
Hyperparameter Tuning
 ↓
Model Export
 ↓
Inference
 ↓
Monitoring

五十二、Train / Validation / Test

数据通常分成：

Training Set
Validation Set
Test Set

例如：

70% Training
15% Validation
15% Test

Training：

学习参数

Validation：

选择模型和超参数

Test：

最终评估

不能用Test数据不断调整模型，否则会产生：

Data Leakage

五十三、DNN中的超参数

需要人工决定：

Learning Rate
Batch Size
Epoch
Hidden Size
Number of Layers
Dropout
Weight Decay
Optimizer
Activation

这些叫：

Hyperparameters

而：

Weight
Bias

是模型自己学习的：

Parameters

这是两个非常重要的概念。

五十四、DNN为什么容易过拟合？

假设：

Dataset
= 10000 samples

而模型：

100 million parameters

模型拥有非常强的表达能力。

于是可能：

训练集
99.99%

测试集
70%

因此模型容量：

Model Capacity

必须和数据量匹配。

五十五、DNN的模型容量

通常：

Layers ↑
Hidden Units ↑
Parameters ↑

意味着模型容量增加。

但是：

Capacity ↑

不代表：

Generalization ↑

可能出现：

Underfitting
 ↓
Good Fit
 ↓
Overfitting

五十六、Underfitting

训练集表现就不好：

Train Accuracy = 60%
Test Accuracy = 58%

说明：

模型甚至没有学好训练数据。

可能原因：

模型太简单
训练不足
Learning Rate不合理
Feature不足

五十七、Overfitting

训练：

99%

测试：

70%

说明：

模型过度拟合训练数据。

可以尝试：

更多数据
Data Augmentation
Dropout
Weight Decay
Early Stopping
降低模型复杂度

五十八、DNN为什么不是万能的？

传统DNN最大的特点：

Fully Connected

这也意味着它对输入结构缺乏先验。

对于图像：

Pixel

如果Flatten：

Image
 ↓
Vector
 ↓
DNN

会丢失大量：

Spatial Relationship

因此：

Image
→ CNN

更加合理。

对于：

Sequence

则通常使用：

RNN / Transformer

五十九、DNN最适合什么数据？

DNN非常适合：

Tabular Data
Structured Data
Feature Vectors
Classification
Regression
Ranking

例如：

用户年龄
收入
交易次数
点击次数
信用评分

可以：

Feature Vector
 ↓
DNN
 ↓
Prediction

六十、DNN在推荐系统中的应用

例如推荐系统：

User Features
 +
Item Features
 +
Context
 ↓
Embedding
 ↓
DNN
 ↓
Click Probability

例如：

User
 ├── Age
 ├── Gender
 ├── History
 └── Location

Item
 ├── Category
 ├── Price
 └── Brand

经过Embedding后：

User Vector
+
Item Vector
+
Context Vector

送入DNN：

DNN
 ↓
CTR Prediction

这类架构在推荐系统中非常常见。

六十一、DNN在风控中的应用

例如：

Transaction
 ↓
Feature Engineering
 ↓
DNN
 ↓
Risk Score

输入：

交易金额
交易时间
用户历史
设备
IP
地点
账户行为

输出：

Risk = 0.93

然后：

Risk > Threshold

触发：

Block
Review
MFA

六十二、DNN与传统机器学习的区别

传统机器学习：

Raw Data
 ↓
Feature Engineering
 ↓
ML Model
 ↓
Prediction

DNN：

Raw / Processed Data
 ↓
Neural Network
 ↓
Representation Learning
 ↓
Prediction

最大的区别之一：

DNN可以同时学习Representation和Prediction。

这也是深度学习的重要优势。

六十三、DNN、CNN、RNN、Transformer的统一理解

可以把它们理解成：

 Neural Network
 │
 ┌──────────────┼──────────────┐
 ↓ ↓ ↓
 DNN CNN RNN
 │ │ │
 Fully Connected Spatial Sequence
 │ │ │
 └──────────────┼──────────────┘
 ↓
 Transformer
 │
 Self-Attention
 │
 ↓
 LLM

但从底层计算来看，它们仍然共享：

Tensor
+
Parameter
+
Forward
+
Loss
+
Gradient
+
Backpropagation
+
Optimizer

六十四、DNN是理解LLM的基础

一个现代LLM虽然拥有：

几十亿
甚至数千亿

参数，但底层仍然是大量：

Linear Layer
+
Activation
+
Normalization
+
Attention
+
Residual

例如Transformer FFN：

就是一个非常典型的DNN结构。

因此：

理解DNN的矩阵计算、参数、梯度和优化机制，是深入理解LLM训练原理的基础。

六十五、从DNN到现代AI的技术演进

整个深度学习技术可以大致理解为：

Perceptron
 ↓
MLP
 ↓
DNN
 ↓
CNN
 ↓
RNN
 ↓
LSTM / GRU
 ↓
Attention
 ↓
Transformer
 ↓
BERT / GPT
 ↓
LLM
 ↓
Multimodal Model
 ↓
Agent

每一次架构升级，本质上都是在解决前一代网络的某种限制。

六十六、DNN最值得掌握的十大概念

如果准备AI Engineer或者算法面试，我建议至少掌握：

1. Neuron
2. Linear Layer
3. Activation Function
4. Forward Propagation
5. Loss Function
6. Backpropagation
7. Gradient Descent
8. Optimizer
9. Normalization
10. Regularization

进一步：

11. Initialization
12. Vanishing Gradient
13. Exploding Gradient
14. Residual Connection
15. Batch / Epoch
16. Learning Rate
17. Overfitting
18. Generalization
19. Computational Graph
20. Automatic Differentiation

六十七、DNN最核心的一条公式

如果把DNN压缩成一个公式：

a₀ = x

z₁ = W₁a₀ + b₁
a₁ = σ(z₁)

z₂ = W₂a₁ + b₂
a₂ = σ(z₂)

...

zL = WLaL-1 + bL

最终：

ŷ = fθ(x)

训练目标：

minθ L(fθ(x), y)

使用梯度下降：

θ ← θ - η∇θL

这几行数学公式基本就是DNN训练的核心。

六十八、从工程师角度理解DNN

如果你有Java/Spring Boot等传统软件开发背景，可以把DNN类比成一个复杂的参数化计算系统：

Input
 ↓
Layer
 ↓
Transformation
 ↓
Layer
 ↓
Transformation
 ↓
Output

传统软件：

Developer
 ↓
编写规则
 ↓
Program
 ↓
Output

深度学习：

Developer
 ↓
设计Network
 ↓
Training Data
 ↓
Optimization
 ↓
Learned Parameters
 ↓
Model
 ↓
Prediction

最本质的区别：

传统软件的规则主要由程序员编写；DNN的规则主要通过数据和优化算法学习。

六十九、DNN真正改变了什么？

传统程序：

Rules + Data
 ↓
 Output

机器学习：

Data + Labels
 ↓
 Learning Algorithm
 ↓
 Model

深度学习：

Raw Data
 ↓
Representation Learning
 ↓
Prediction

因此DNN最大的贡献并不是：

“用了很多层神经网络。”

而是：

让机器能够通过多层非线性变换自动学习越来越抽象的表示。

七十、总结：真正理解DNN

最终可以用下面这张图理解DNN：

 DNN
 │
 ┌────────────┴────────────┐
 ↓ ↓
 Forward Pass Training
 │ │
 ↓ ↓
 Linear Layer Loss
 │ │
 ↓ ↓
 Activation Gradient
 │ │
 ↓ ↓
 Hidden Layer Backprop
 │ │
 ↓ ↓
 Prediction Optimizer
 │
 ↓
 Update Weight

而DNN与现代AI的关系：

DNN
 │
 ├── CNN
 │ └── Computer Vision
 │
 ├── RNN
 │ └── Sequence
 │
 └── Transformer
 ├── BERT
 ├── GPT
 ├── LLM
 └── Multimodal AI

所以学习DNN最重要的不是背诵：

ReLU公式
Adam公式
BatchNorm公式

而是建立一个完整的因果链：

为什么需要Layer？
 ↓
为什么需要Activation？
 ↓
为什么需要Loss？
 ↓
为什么需要Gradient？
 ↓
为什么需要Backpropagation？
 ↓
为什么需要Optimizer？
 ↓
为什么会出现Vanishing Gradient？
 ↓
为什么需要Normalization？
 ↓
为什么需要Residual Connection？
 ↓
为什么最终出现CNN、RNN、Transformer？

一旦这条链真正理解清楚，后面学习：

CNN
RNN
LSTM
Attention
Transformer
BERT
GPT
LLM
Vision-Language Model

就不再是孤立的技术点，而会变成一条完整的深度学习技术演进路线。

DNN是现代深度学习的“通用计算骨架”，而CNN、RNN、Transformer则是在这个骨架之上针对不同数据结构设计出来的专用架构。

LangChain

Wed, 05 Aug 2026 00:00:00 +0000

LangChain 是一个用于构建 大语言模型（LLM）应用 的开源开发框架。它最初主要支持 Python，后来也推出了 JavaScript/TypeScript 版本，目的是让开发者能够更方便地将大模型与外部数据、工具和业务流程结合起来，而不仅仅是简单地调用模型 API。

可以把它理解为：

如果 OpenAI、Anthropic 等提供的是“大脑”，那么 LangChain 提供的是把大脑连接到工具、数据库和业务系统的“神经系统”。

LangChain 能做什么？

它主要解决以下几类问题：

1. 统一调用各种大模型

不管你使用的是：

OpenAI GPT
Anthropic Claude
Google Gemini
DeepSeek
本地模型（如 Llama）

LangChain 提供了统一的接口，方便切换模型，而不用大改代码。

例如：

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1")
response = llm.invoke("介绍一下LangChain")

2. Prompt 管理

把 Prompt 模板化，而不是字符串拼接。

例如：

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template(
 "请把下面内容翻译成英文：{text}"
)

prompt.invoke({
 "text": "你好"
})

这样方便维护复杂 Prompt。

3. 连接外部数据（RAG）

这是 LangChain 最流行的用途之一。

例如：

PDF
Word
数据库
网页
知识库
 │
 ▼
 文档切分
 │
 ▼
Embedding
 │
 ▼
向量数据库
 │
 ▼
LLM回答问题

这就是大家常说的 RAG（Retrieval-Augmented Generation，检索增强生成）。

常用组件包括：

Document Loader
Text Splitter
Embedding
Vector Store
Retriever

4. 调用工具（Tools）

例如：

模型不会算：

345678 × 2345

它可以调用：

Python
搜索引擎
天气 API
数据库
企业接口

例如：

用户：
北京天气

↓

LLM

↓

Weather API

↓

返回天气

↓

LLM组织语言回复

5. Agent（智能体）

Agent 是 LangChain 的核心能力之一。

例如用户说：

帮我查一下苹果公司股价，然后写一份分析。

Agent 可以：

① 理解任务

↓

② 调用股票API

↓

③ 获取价格

↓

④ 分析数据

↓

⑤ 输出报告

Agent 会决定：

是否调用工具
调哪个工具
调几次

6. Memory（对话记忆）

例如：

用户：
我叫Tom

AI：
好的。

用户：
我叫什么？

Memory 可以保存上下文。

不过，现代应用通常更倾向于自己管理对话历史，而不是依赖 LangChain 早期的 Memory 抽象。

LangChain 的核心模块

LangChain
│
├── Models（模型）
│
├── Prompts（提示词）
│
├── Chains（流程）
│
├── Tools（工具）
│
├── Agents（智能体）
│
├── Retrievers（检索）
│
├── Vector Stores（向量库）
│
└── Output Parsers（输出解析）

一个简单流程

例如：

用户提问

↓

Prompt

↓

LLM

↓

调用搜索工具

↓

LLM

↓

返回答案

或者：

用户

↓

RAG

↓

检索知识库

↓

LLM

↓

回答

LangChain 与其他框架的区别

框架	特点	适合场景
LangChain	功能全面、生态成熟	RAG、Agent、多模型集成
LangGraph	基于状态机/图的 Agent 编排，更适合复杂、多步骤工作流	多智能体、长流程应用
LlamaIndex	更专注于数据接入和 RAG	知识库问答、文档检索
OpenAI Agents SDK	与 OpenAI 模型和工具深度集成	基于 OpenAI 生态开发 Agent

LangChain 的优点

支持多种模型，切换成本低。
提供丰富的组件，覆盖 RAG、Agent、工具调用等常见场景。
社区活跃，生态完善，与众多向量数据库、模型和第三方服务集成良好。

需要注意的地方

学习曲线相对较陡，概念和组件较多。
API 在近几年迭代较快，不同版本之间可能存在较大变化。
对于简单应用（例如单次调用模型），直接使用模型官方 SDK 往往更轻量，不一定需要引入 LangChain。

什么时候该用 LangChain？

如果你的项目只是：

调用一次 LLM 完成聊天、翻译或总结；

直接使用模型官方 SDK 通常已经足够。

如果你的项目需要：

接入企业知识库（RAG）；
调用搜索、数据库、API 等外部工具；
构建多步骤工作流或 Agent；
在不同模型之间灵活切换；

那么 LangChain 能显著减少开发工作量，并提供更好的模块化能力。随着近年来 Agent 应用的发展，很多开发者也会结合 LangGraph 使用 LangChain，以构建更复杂、更可靠的智能体系统。

LangGraph

Wed, 05 Aug 2026 00:00:00 +0000

LangGraph 可以理解成：

专门用来构建“有状态、可循环、可控制”的 AI Agent 工作流框架。

如果说 LangChain 是工具箱，那么 LangGraph 更像是流程引擎 / 状态机。

这两个经常一起使用。

1. 为什么需要 LangGraph？

先看一个普通的 LLM：

用户
 ↓
Prompt
 ↓
LLM
 ↓
回答

很简单。

但是实际的 AI Agent 往往是：

用户问题
 ↓
分析问题
 ↓
需要查询数据库？
 ├── 是 → 查询数据库
 │ ↓
 │ 分析结果
 │ ↓
 │ 结果是否正确？
 │ ├── 否 → 再次查询
 │ └── 是
 ↓
生成答案

甚至：

用户
 ↓
Agent
 ↓
调用工具
 ↓
得到结果
 ↓
Agent重新思考
 ↓
调用另一个工具
 ↓
得到结果
 ↓
Agent重新思考
 ↓
最终答案

这种有状态、分支、循环、人工介入、多 Agent 协作的流程，就非常适合 LangGraph。

2. LangGraph 最核心的思想

LangGraph 的名字里面有一个 Graph（图）。

它把 Agent 应用抽象成：

 ┌──────────────┐
 │ ↓
START → 分析问题 → 查询数据库
 │ │
 │ ↓
 └────────── 检查结果
 │
 ┌──────┴──────┐
 ↓ ↓
 正确 错误
 ↓ │
 生成答案 ←──────┘
 │
 END

这里有三个非常重要的概念：

State
Node
Edge

3. State —— 状态

State 可以理解成：

整个 Agent 工作过程中需要保存的数据。

例如：

class State(TypedDict):
 question: str
 sql: str
 result: str
 answer: str

执行过程中：

question
 ↓
sql
 ↓
result
 ↓
answer

State 会不断被更新。

例如：

State：

question = "查询昨天销售额"

sql = ""

result = ""

answer = ""

SQL Agent 执行之后：

State：

question = "查询昨天销售额"

sql = "SELECT SUM(amount) ..."

result = "125000"

answer = ""

最后：

State：

question = "查询昨天销售额"

sql = "SELECT SUM(amount) ..."

result = "125000"

answer = "昨天销售额为125000元"

4. Node —— 节点

Node 就是一个具体的处理步骤。

例如：

Node 1：分析问题

Node 2：生成 SQL

Node 3：执行 SQL

Node 4：检查 SQL

Node 5：生成答案

可以理解成 Java 中的方法：

analyzeQuestion()

generateSQL()

executeSQL()

checkResult()

generateAnswer()

5. Edge —— 边

Edge 决定：

下一步执行哪个 Node。

例如：

generateSQL
 ↓
executeSQL
 ↓
checkSQL

但是 checkSQL 可能有两种结果：

 checkSQL
 / \
 正确 错误
 ↓ ↓
 answer generateSQL

这就是 Conditional Edge（条件边）。

6. LangGraph 最重要的能力：循环

这是 LangGraph 和普通 Chain 一个非常重要的区别。

例如 Agent：

思考
 ↓
调用工具
 ↓
观察结果
 ↓
思考
 ↓
调用工具
 ↓
观察结果
 ↓
思考
 ↓
最终答案

可以形成：

 ┌─────────────┐
 ↓ │
 Think │
 ↓ │
 Tool │
 ↓ │
 Observation │
 ↓ │
 是否完成？ ── 否 ──┘
 │
 是
 ↓
 Answer

这种循环非常适合 Agent。

7. LangChain vs LangGraph

	LangChain	LangGraph
核心思想	LLM 应用组件	Agent 工作流
抽象	Chain / Tool / Retriever	Graph / State / Node / Edge
简单 LLM	⭐⭐⭐⭐⭐	⭐⭐
RAG	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Agent	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
循环	一般	⭐⭐⭐⭐⭐
状态管理	一般	⭐⭐⭐⭐⭐
条件分支	有	很强
Human-in-the-loop	有相关能力	很适合
多 Agent	可以	很适合
复杂工作流	一般	⭐⭐⭐⭐⭐

简单来说：

LangChain
 ↓
提供各种 AI 组件

LangGraph
 ↓
把这些组件组织成复杂的 Agent 工作流

8. 一个实际例子：SQL Agent

假设你做一个企业数据分析 AI。

用户：

帮我分析一下今年销售额下降的原因。

Agent 可能需要：

 用户问题
 ↓
 分析问题
 ↓
 生成 SQL
 ↓
 查询数据库
 ↓
 分析数据
 ↓
 是否需要更多数据？
 ↙ ↘
 是 否
 ↓ ↓
 再次查询 生成报告
 ↓
 分析
 │
 └───────────┐
 ↓
 最终答案

用 LangGraph，就可以把它表示成：

State
 │
 ├── question
 ├── sql
 ├── database_result
 ├── analysis
 └── answer

Node
 │
 ├── analyze_question
 ├── generate_sql
 ├── execute_sql
 ├── analyze_result
 └── generate_answer

Edge
 │
 ├── analyze → generate_sql
 ├── generate_sql → execute_sql
 ├── execute_sql → analyze_result
 └── analyze_result → generate_sql / answer

这就非常像一个有状态的工作流引擎。

9. 为什么 Java 后端工程师特别容易理解 LangGraph？

你本身有 Java、Spring、微服务、Kubernetes 等后端背景的话，可以把 LangGraph 类比成：

Spring Application
 ↓
业务流程
 ↓
Service A
 ↓
Service B
 ↓
Service C

而 LangGraph：

Agent Workflow
 ↓
Node A
 ↓
Node B
 ↓
Node C
 ↓
根据 State 决定下一步
 ↓
Node A / Node D / END

甚至可以把它理解成：

State Machine + Workflow Engine + LLM Agent

这个理解非常接近它的核心思想。

10. LangGraph 和 Spring StateMachine 的感觉很像

如果你以前接触过状态机，可以这样理解：

StateMachine

State
 ↓
Event
 ↓
Transition
 ↓
Next State

LangGraph：

State
 ↓
Node
 ↓
Edge
 ↓
Next Node

例如订单：

CREATED
 ↓
PAID
 ↓
SHIPPED
 ↓
DELIVERED

Agent：

QUESTION
 ↓
THINK
 ↓
TOOL_CALL
 ↓
OBSERVATION
 ↓
THINK
 ↓
ANSWER

所以对于后端开发者来说，LangGraph 的思维其实并不陌生。

11. LangGraph 在 AI Agent 架构中的位置

现在你可以把整个 AI 技术栈理解成：

 AI Application
 │
 ┌───────────┴───────────┐
 ↓ ↓
 RAG Agent
 │ │
 ┌─────┴─────┐ ┌──────┴──────┐
 ↓ ↓ ↓ ↓
 Vector DB Retriever Tools Workflow
 │ │
 │ LangGraph
 ↓
 API
 │
 ↓
 Database

而底层：

 LLM
 │
 ┌────────┼────────┐
 ↓ ↓ ↓
 GPT Claude Gemini

LSTM：从 RNN 的梯度问题到门控记忆机制

Wed, 05 Aug 2026 00:00:00 +0000

LSTM（Long Short-Term Memory） 是深度学习历史上最重要的序列模型之一。它解决了传统 RNN 在长序列训练过程中容易出现的梯度消失、梯度爆炸以及长期依赖难以学习等问题。

虽然今天 Transformer 已经成为 NLP、LLM 和多模态模型的主流架构，但理解 LSTM 依然非常重要，因为它能够帮助我们真正理解：

序列建模 → 状态记忆 → 梯度传播 → Attention → Transformer

这一整条技术演进路线。

一、LSTM 是什么？

LSTM 全称：

Long Short-Term Memory

中文：

长短期记忆网络

它属于：

Recurrent Neural Network
 ↓
 RNN
 ↓
 LSTM

LSTM 最核心的思想只有一句话：

通过门控机制决定哪些信息应该保留、哪些信息应该遗忘、哪些信息应该输出。

传统神经网络：

x
 ↓
Network
 ↓
y

而 LSTM：

xₜ
 ↓
LSTM
 ↓
hₜ
 ↓
LSTM
 ↓
hₜ₊₁
 ↓
LSTM

模型在处理当前输入的同时，还会保留之前的信息。

因此 LSTM 天然适合：

时间序列
语音
文本
股票数据
传感器数据
日志序列
用户行为序列

二、为什么需要 LSTM？

理解 LSTM，必须先理解 RNN。

假设有一个句子：

我出生在中国，后来去了美国，现在我说一口流利的 ______ 。

模型在预测最后一个词的时候，需要记住：

中国

甚至可能需要记住前面很远的信息。

传统 DNN：

Input
 ↓
DNN
 ↓
Output

每个输入基本独立。

而 RNN：

x₁ → RNN → h₁
 ↓
x₂ → RNN → h₂
 ↓
x₃ → RNN → h₃
 ↓
...
 ↓
xₙ → RNN → hₙ

其中：

hₜ

就是隐藏状态。

可以理解为：

hₜ 是 RNN 对过去信息的压缩记忆。

三、传统 RNN 的核心公式

RNN 的基本公式：

hₜ = tanh(Wₓxₜ + Wₕhₜ₋₁ + b)

其中：

xₜ 当前输入
hₜ₋₁ 上一个隐藏状态
hₜ 当前隐藏状态
Wₓ 输入权重
Wₕ 隐藏状态权重
b bias

结构：

 hₜ₋₁
 │
 ↓
xₜ ───→ RNN ───→ hₜ

所以：

当前状态
=
当前输入
+
过去状态

这就是 RNN 的核心。

四、RNN 最大的问题：长期依赖

假设：

x₁
 ↓
x₂
 ↓
x₃
 ↓
...
 ↓
x₁₀₀

如果：

x₁

的信息对于：

x₁₀₀

非常重要，那么 RNN 必须让这个信息经过：

99次状态传递

才能到达最终位置。

训练时则涉及：

Backpropagation Through Time

简称：

BPTT

梯度需要：

∂L/∂h₁₀₀
 ↓
∂L/∂h₉₉
 ↓
∂L/∂h₉₈
 ↓
...
 ↓
∂L/∂h₁

于是出现一个严重问题：

梯度需要经过大量连续乘法。

五、为什么会出现梯度消失？

假设每次梯度传播都会乘以：

0.5

连续10次：

0.5¹⁰ ≈ 0.00098

连续100次：

0.5¹⁰⁰ ≈ 7.9 × 10⁻³¹

梯度几乎变成：

于是前面的网络层几乎无法学习。

这就是：

Vanishing Gradient

梯度消失导致：

RNN 很难学习非常长距离的依赖关系。

六、LSTM 的核心思想

LSTM 不再简单地：

过去状态 + 当前输入

而是增加一个非常重要的状态：

Cell State

完整结构：

 ┌─────────────────────┐
 │ Cell State │
 │ Cₜ │
 └─────────────────────┘
 ↑
 │
 Forget / Input
 │
xₜ ───────→ LSTM ───────→ hₜ
 ↑
 │
 hₜ₋₁

LSTM 有两个核心状态：

hₜ
Cₜ

其中：

hₜ = Hidden State
Cₜ = Cell State

可以粗略理解为：

hₜ
→ 当前对外表现出来的状态

Cₜ
→ 内部长期记忆

七、LSTM 为什么叫“记忆网络”？

可以把：

Cₜ

想象成一条贯穿整个序列的：

Memory Highway

数据沿着：

Cₜ₋₁
 ↓
Cₜ
 ↓
Cₜ₊₁
 ↓
Cₜ₊₂

传播。

LSTM 不会每一步都彻底重写记忆。

而是通过：

Forget Gate
Input Gate
Output Gate

控制：

忘掉什么
记住什么
输出什么

这就是 LSTM 最核心的设计。

八、LSTM 的三个 Gate

LSTM 有三个主要门：

Forget Gate
Input Gate
Output Gate

可以理解成一个“记忆管理系统”。

 LSTM
 │
 ┌────────┼────────┐
 ↓ ↓ ↓
 Forget Input Output
 Gate Gate Gate
 │ │ │
 ↓ ↓ ↓
 忘记 写入 输出

九、Forget Gate：应该忘记什么？

Forget Gate：

决定之前的记忆哪些应该被删除。

公式：

fₜ = σ(W_f[hₜ₋₁, xₜ] + b_f)

其中：

σ = Sigmoid

输出范围：

0 ~ 1

例如：

fₜ = 0.1

表示：

这个信息基本忘掉

如果：

fₜ = 0.9

表示：

这个信息大部分保留

所以可以理解成：

0 → Forget
1 → Keep

十、Input Gate：应该记住什么？

Input Gate 决定：

当前输入中哪些信息值得写入长期记忆。

首先计算：

iₜ = σ(W_i[hₜ₋₁, xₜ] + b_i)

然后产生候选记忆：

C̃ₜ = tanh(W_c[hₜ₋₁, xₜ] + b_c)

这里有两个概念：

iₜ
→ 写入多少

C̃ₜ
→ 写入什么

十一、Cell State 如何更新？

这是 LSTM 最核心的公式之一：

Cₜ = fₜ ⊙ Cₜ₋₁ + iₜ ⊙ C̃ₜ

拆开：

旧记忆
 ↓
fₜ × Cₜ₋₁

表示：

保留多少旧信息。

然后：

新信息
 ↓
iₜ × C̃ₜ

表示：

写入多少新信息。

最终：

新记忆
=
旧记忆 × Forget Gate
+
新信息 × Input Gate

这就是 LSTM 的核心机制。

十二、Output Gate：应该输出什么？

LSTM 内部可能保存了大量信息。

但不是所有信息都需要输出。

因此有：

oₜ = σ(W_o[hₜ₋₁, xₜ] + b_o)

最终：

hₜ = oₜ ⊙ tanh(Cₜ)

所以：

Cell State
 ↓
 tanh()
 ↓
Output Gate
 ↓
Hidden State

十三、LSTM 完整数学公式

把整个 LSTM 放在一起：

Forget Gate

fₜ = σ(W_f[hₜ₋₁, xₜ] + b_f)

Input Gate

iₜ = σ(W_i[hₜ₋₁, xₜ] + b_i)

Candidate Cell State

C̃ₜ = tanh(W_c[hₜ₋₁, xₜ] + b_c)

Cell State

Cₜ = fₜ ⊙ Cₜ₋₁ + iₜ ⊙ C̃ₜ

Output Gate

oₜ = σ(W_o[hₜ₋₁, xₜ] + b_o)

Hidden State

hₜ = oₜ ⊙ tanh(Cₜ)

这六个公式就是标准 LSTM 的数学核心。

十四、为什么 LSTM 能缓解梯度消失？

重点观察：

Cₜ = fₜ ⊙ Cₜ₋₁ + iₜ ⊙ C̃ₜ

传统 RNN：

hₜ = tanh(...)

每一步都经历：

非线性变换

而 LSTM 有一条：

Cell State

允许信息进行相对直接的传播。

梯度可以沿着：

Cₜ₋₁
 ↓
Cₜ
 ↓
Cₜ₊₁

传播。

这就是所谓的：

Memory Highway

它显著缓解了长期依赖学习中的梯度消失问题。

注意：

LSTM 是“缓解”而不是数学意义上彻底消除梯度消失。

十五、一个非常直观的类比

可以把 LSTM 想象成一个项目经理。

每天都会收到新的信息：

xₜ

项目经理脑子里有：

长期记忆 Cₜ

同时还需要决定：

Forget Gate

这个信息已经没用了
→ 删除

Input Gate

这个新信息非常重要
→ 记录

Output Gate

这个信息现在需要告诉团队
→ 输出

因此：

LSTM
=
记忆
+
遗忘
+
写入
+
读取

十六、LSTM 与普通 RNN 的结构区别

普通 RNN：

xₜ
 │
 ↓
┌───────────┐
│ RNN │
│ │
│ tanh │
└───────────┘
 │
 ↓
hₜ

LSTM：

 Cₜ₋₁
 │
 ┌───────┴───────┐
 │ │
 Forget Input
 │ │
 └───────┬───────┘
 ↓
 Cₜ
 │
 Output
 │
 ↓
 hₜ

LSTM 内部明显更加复杂。

但是这种复杂性换来了：

更强的长期记忆能力。

十七、为什么 LSTM 使用 Sigmoid？

三个 Gate：

fₜ
iₜ
oₜ

都需要表达：

0 ~ 1

因此使用：

Sigmoid

例如：

表示：

完全关闭

而：

表示：

完全打开

所以 Sigmoid 非常适合作为：

Gate

十八、为什么 Candidate 使用 Tanh？

候选记忆：

C̃ₜ

需要表示：

正的信息
+
负的信息

因此：

tanh

输出：

-1 ~ 1

比 Sigmoid 更适合表示有正负方向的信息。

因此经典 LSTM：

Gate
→ Sigmoid

Candidate
→ Tanh

十九、LSTM 的参数量

假设：

input_size = D
hidden_size = H

LSTM 有四组主要计算：

Forget
Input
Candidate
Output

每一组都有：

Input Weight
Hidden Weight
Bias

所以参数量大致：

4 × (D×H + H×H + H)

即：

4H(D + H + 1)

例如：

D = 128
H = 256

参数：

4 × 256 × (128 + 256 + 1)

约：

394,240

这比普通 RNN：

H(D + H + 1)

大约多四倍。

因此：

LSTM 的表达能力增强，同时计算成本也明显增加。

二十、PyTorch 实现 LSTM

PyTorch：

import torch
import torch.nn as nn

lstm = nn.LSTM(
 input_size=128,
 hidden_size=256,
 num_layers=2,
 batch_first=True
)

输入：

[batch_size, sequence_length, input_size]

例如：

[32, 100, 128]

表示：

Batch = 32
Sequence = 100
Feature = 128

输出：

output, (h_n, c_n) = lstm(x)

其中：

output
h_n
c_n

分别对应不同层面的序列输出和最终状态。

二十一、完整 LSTM 分类模型

例如文本分类：

import torch
import torch.nn as nn


class LSTMClassifier(nn.Module):

 def __init__(
 self,
 input_size,
 hidden_size,
 num_layers,
 num_classes
 ):
 super().__init__()

 self.lstm = nn.LSTM(
 input_size=input_size,
 hidden_size=hidden_size,
 num_layers=num_layers,
 batch_first=True
 )

 self.fc = nn.Linear(
 hidden_size,
 num_classes
 )

 def forward(self, x):

 output, (h_n, c_n) = self.lstm(x)

 last_hidden = h_n[-1]

 output = self.fc(last_hidden)

 return output

结构：

Input Sequence
 ↓
Embedding / Features
 ↓
LSTM
 ↓
Last Hidden State
 ↓
Fully Connected
 ↓
Classification

二十二、LSTM 中的 `h` 和 `c`

这是初学者非常容易混淆的地方。

LSTM：

output, (h_n, c_n) = lstm(x)

有：

h_n
c_n

h_n

Hidden State

可以理解成：

当前时刻对外暴露的状态。

c_n

Cell State

可以理解成：

LSTM 内部长期记忆。

简单记：

h = hidden
c = cell

二十三、output 和 h_n 的区别

假设：

batch = 32
sequence = 100
hidden = 256

那么：

output
=
[32, 100, 256]

表示：

每一个时间步的 Hidden State。

而：

h_n

通常是：

[num_layers, batch, hidden]

表示：

每一层最后一个时间步的 Hidden State。

例如：

[2, 32, 256]

表示：

2 layers
32 batch
256 hidden

二十四、Many-to-One

LSTM 很适合：

Sequence
 ↓
Single Output

例如：

一整段文本
 ↓
情感分类

结构：

x₁ → LSTM
x₂ → LSTM
x₃ → LSTM
...
xₙ → LSTM
 ↓
 hₙ
 ↓
 Classifier
 ↓
 Positive

典型：

Sentiment Analysis

二十五、Many-to-Many

也可以：

Sequence
 ↓
Sequence

例如：

输入：
我 爱 北京

输出：
I love Beijing

或者：

Token
 ↓
NER
 ↓
Token Label

例如：

我 O
爱 O
北京 B-LOC

二十六、Many-to-One 和 Many-to-Many

总结：

Many-to-One

x1
x2
x3
 ↓
LSTM
 ↓
y

应用：

文本分类
情感分析
异常检测

Many-to-Many：

x1 → y1
x2 → y2
x3 → y3

应用：

序列标注
NER
时间序列预测

二十七、Bidirectional LSTM

普通 LSTM：

过去 → 现在

Bidirectional LSTM：

过去 → 现在
现在 ← 未来

即：

Forward LSTM
Backward LSTM
 ↓
Concatenate

例如：

x1 → x2 → x3 → x4

x1 ← x2 ← x3 ← x4

最后：

hₜ = [h_forward ; h_backward]

因此模型同时利用：

过去信息
+
未来信息

二十八、为什么 NLP 中 BiLSTM 很有价值？

例如：

我去银行存钱

判断：

银行

的含义时，前后文都很重要。

BiLSTM可以：

Forward
→ 利用左侧上下文

Backward
→ 利用右侧上下文

因此：

双向 LSTM 在传统 NLP 任务中非常有效。

二十九、Stacked LSTM

可以堆叠多层 LSTM：

Input
 ↓
LSTM Layer 1
 ↓
LSTM Layer 2
 ↓
LSTM Layer 3
 ↓
Output

例如：

nn.LSTM(
 input_size=128,
 hidden_size=256,
 num_layers=3
)

这样可以学习：

低层序列特征
 ↓
中层序列特征
 ↓
高层序列特征

类似 DNN 的：

Deep Representation Learning

三十、LSTM 的 Dropout

当：

num_layers > 1

可以使用：

nn.LSTM(
 input_size=128,
 hidden_size=256,
 num_layers=3,
 dropout=0.2
)

Dropout主要作用于：

不同 LSTM 层之间的连接。

它可以降低：

Overfitting

三十一、LSTM 与时间序列

LSTM 曾经在时间序列预测中非常流行。

例如股票：

Day1
 ↓
Day2
 ↓
Day3
 ↓
...
 ↓
Day30
 ↓
Prediction Day31

输入：

Open
High
Low
Close
Volume

可以构建：

[30, 5]

送入：

LSTM
 ↓
Hidden State
 ↓
Linear
 ↓
Price

三十二、LSTM 与异常检测

例如服务器监控：

CPU
Memory
QPS
Latency
Error Rate

每分钟：

t1
t2
t3
...
t100

LSTM学习正常模式：

Normal Sequence
 ↓
LSTM
 ↓
Prediction

如果：

Prediction

与实际值差异很大：

Error > Threshold

可以判断：

Anomaly

三十三、LSTM 与日志分析

如果系统日志：

Login
 ↓
Query
 ↓
Payment
 ↓
Order
 ↓
Logout

可以看成：

Event Sequence

LSTM可以学习：

正常行为模式

然后发现：

异常行为

例如：

Login
 ↓
Login
 ↓
Login
 ↓
Admin
 ↓
Delete

可能具有异常模式。

三十四、LSTM 的主要缺点

虽然 LSTM 很优秀，但它存在明显缺点。

1. 顺序计算

LSTM：

x1
 ↓
x2
 ↓
x3
 ↓
x4

必须按照时间顺序处理。

因此：

很难充分利用 GPU 的并行计算能力。

2. 长序列效率低

例如：

Sequence Length = 10000

LSTM需要：

10000 steps

依次计算。

Transformer则可以：

Parallel Attention

大规模训练更加高效。

3. 参数多

相比普通 RNN：

LSTM
≈ 4 × 参数量

计算成本更高。

三十五、GRU 为什么出现？

LSTM：

Forget Gate
Input Gate
Output Gate
Cell State
Hidden State

结构比较复杂。

于是出现：

GRU

全称：

Gated Recurrent Unit

GRU的核心思想：

用更少的门实现类似的记忆机制。

主要包括：

Update Gate
Reset Gate

没有独立的：

Cell State

因此结构更加简单。

三十六、LSTM vs GRU

特性	LSTM	GRU
Forget Gate	有	融合到 Update
Input Gate	有	融合
Output Gate	有	没有独立
Cell State	有	没有
Hidden State	有	有
参数量	较多	较少
计算速度	较慢	较快
长期依赖	强	强
模型复杂度	高	较低

可以简单理解：

LSTM
→ 更完整的记忆机制

GRU
→ 更简洁的门控机制

三十七、LSTM 为什么最终被 Transformer 超越？

这是理解现代 AI 架构演进非常重要的问题。

LSTM：

x1 → x2 → x3 → x4 → ... → xn

信息必须一步一步传播。

Transformer：

x1 ─┐
x2 ─┤
x3 ─┼→ Self-Attention
x4 ─┤
x5 ─┘

一个 Token 可以直接关注：

任何其他 Token

例如：

x₁ ───────────────→ x₁₀₀

不需要：

x₂
x₃
x₄
...
x₉₉

一个一个传递。

这就是：

Self-Attention 对长距离依赖的巨大优势。

三十八、LSTM 与 Transformer 的根本区别

LSTM：

Memory-Based

依赖：

Hidden State
Cell State

Transformer：

Attention-Based

依赖：

Attention Matrix

LSTM：

过去
 ↓
状态
 ↓
现在

Transformer：

所有Token
 ↓
Attention
 ↓
Context

因此 Transformer 更容易进行：

Large Scale Parallel Training

三十九、LSTM 与 Attention 的结合

在 Transformer 之前，还有一个非常重要的阶段：

LSTM + Attention

例如 Encoder：

x1 → LSTM → h1
x2 → LSTM → h2
x3 → LSTM → h3
x4 → LSTM → h4

传统 Decoder可能只使用：

h4

问题是：

h4需要压缩整个输入序列。

Attention则允许：

Decoder
 ↓
Attention
 ├── h1
 ├── h2
 ├── h3
 └── h4

动态选择重要信息。

这成为 Transformer 出现前的重要技术过渡。

四十、LSTM → Attention → Transformer

可以把技术演进理解成：

RNN
 ↓
LSTM
 ↓
解决长期记忆
 ↓
LSTM + Attention
 ↓
减少信息压缩问题
 ↓
Transformer
 ↓
Self-Attention
 ↓
大规模并行计算
 ↓
BERT / GPT
 ↓
LLM

这条技术路线非常重要。

四十一、LSTM 对理解 LLM 有什么价值？

现在学习 LSTM 仍然有很大意义。

因为它能帮助理解：

1. State

hₜ
Cₜ

为什么序列模型需要状态。

2. Memory

为什么：

过去的信息

会影响：

当前预测

3. Gradient

理解：

Vanishing Gradient

4. Attention

理解：

为什么 Transformer 不再依赖传统 RNN 的顺序记忆。

5. Sequence Modeling

理解：

Token
Sequence
Context
Dependency

这些概念对 LLM 都非常重要。

四十二、从 AI 工程师角度理解 LSTM

如果从工程角度看，LSTM 可以理解成：

Input Event
 ↓
State
 ↓
Memory Update
 ↓
Output
 ↓
Next Event

这和传统后端系统中的：

Request
 ↓
Session State
 ↓
State Update
 ↓
Response

有一定的类比。

例如：

User Event
 ↓
LSTM
 ↓
User State
 ↓
Next Action Prediction

这类思路可以用于：

推荐系统
用户行为预测
异常检测
时间序列
事件预测

四十三、LSTM 训练过程

完整训练过程：

Training Data
 ↓
Sequence
 ↓
Embedding / Feature
 ↓
LSTM
 ↓
Prediction
 ↓
Loss
 ↓
BPTT
 ↓
Gradient
 ↓
Optimizer
 ↓
Update Parameters

注意：

LSTM仍然使用：

Backpropagation

只是由于存在时间维度，所以称为：

Backpropagation Through Time

即：

BPTT

四十四、BPTT 是怎么回事？

假设：

x1 → LSTM → h1
 ↓
x2 → LSTM → h2
 ↓
x3 → LSTM → h3
 ↓
x4 → LSTM → h4

最终：

h4
 ↓
Loss

反向传播：

Loss
 ↓
h4
 ↓
h3
 ↓
h2
 ↓
h1

所以叫：

Backpropagation
Through
Time

这也是为什么序列越长，训练越困难。

四十五、LSTM 的工程优化

生产环境中使用 LSTM，需要考虑：

Sequence Length
Batch Size
Hidden Size
Number of Layers
Bidirectional
GPU Memory
Padding
Packing

特别是：

Variable Length Sequence

例如：

Sequence A = 10
Sequence B = 50
Sequence C = 100

通常需要：

Padding

或者：

PackedSequence

减少无效计算。

四十六、LSTM 中 Padding 的问题

假设：

A = [x1,x2,x3]

B = [x1,x2,x3,x4,x5]

统一长度：

A = [x1,x2,x3,PAD,PAD]
B = [x1,x2,x3,x4,x5]

那么：

PAD

实际上没有意义。

因此需要：

Masking

或者 PyTorch：

pack_padded_sequence()

让 LSTM 尽可能避免处理无效 Padding。

四十七、LSTM 的典型应用场景

今天 LSTM 虽然不再是 NLP 主流，但仍然适合很多场景。

时间序列

CPU
Memory
Temperature
Stock
Demand
Traffic

工业

Sensor
Machine State
Failure Prediction

异常检测

Log Sequence
Transaction Sequence

语音

Audio Feature Sequence

NLP

Sequence Classification
NER
Text Classification

尤其在：

数据量有限、模型规模不大、实时性要求高的场景中，LSTM 依然可能具有工程价值。

四十八、LSTM 最重要的知识结构

如果准备 AI Engineer / Machine Learning Engineer 面试，可以建立下面的知识树：

LSTM
 │
 ├── RNN
 │ ├── Hidden State
 │ ├── Recurrence
 │ └── BPTT
 │
 ├── Problem
 │ ├── Vanishing Gradient
 │ └── Long-Term Dependency
 │
 ├── Memory
 │ ├── Hidden State
 │ └── Cell State
 │
 ├── Gates
 │ ├── Forget Gate
 │ ├── Input Gate
 │ └── Output Gate
 │
 ├── Activation
 │ ├── Sigmoid
 │ └── Tanh
 │
 ├── Architecture
 │ ├── Stacked LSTM
 │ ├── BiLSTM
 │ └── LSTM + Attention
 │
 └── Modern Evolution
 └── Transformer

四十九、面试中最容易问的 LSTM 问题

Q1：LSTM 为什么能够解决 RNN 的长期依赖问题？

核心：

Cell State
+
Gated Mechanism

通过：

Forget Gate
Input Gate
Output Gate

控制信息流。

Q2：LSTM 为什么有两个 State？

hₜ
→ Hidden State

Cₜ
→ Cell State

其中：

Cₜ

负责更加长期的信息传递。

Q3：为什么 Gate 使用 Sigmoid？

因为：

Sigmoid ∈ (0,1)

可以自然表示：

关闭程度
保留程度

Q4：Candidate 为什么使用 Tanh？

因为：

Tanh ∈ (-1,1)

能够表达：

正向信息
+
负向信息

Q5：LSTM 为什么比 RNN 参数更多？

因为 LSTM 有四组核心计算：

Forget
Input
Candidate
Output

因此参数量约为普通 RNN 的四倍。

Q6：LSTM 为什么最终被 Transformer 替代？

主要原因：

LSTM
→ Sequential Computation

Transformer
→ Parallel Attention

Transformer 更适合：

GPU
TPU
Large Dataset
Long Sequence
Large Model

五十、最终总结

LSTM 可以浓缩成下面这一张图：

 LSTM
 │
 ┌──────┴──────┐
 ↓ ↓
 Hidden State Cell State
 │ │
 │ │
 └──────┬──────┘
 ↓
 ┌─────────────┐
 │ │
 Forget Input
 Gate Gate
 │ │
 └──────┬──────┘
 ↓
 Memory
 │
 ↓
 Output Gate
 │
 ↓
 hₜ

最重要的公式：

fₜ = σ(W_f[hₜ₋₁,xₜ] + b_f)

iₜ = σ(W_i[hₜ₋₁,xₜ] + b_i)

C̃ₜ = tanh(W_c[hₜ₋₁,xₜ] + b_c)

Cₜ = fₜ ⊙ Cₜ₋₁ + iₜ ⊙ C̃ₜ

oₜ = σ(W_o[hₜ₋₁,xₜ] + b_o)

hₜ = oₜ ⊙ tanh(Cₜ)

真正理解 LSTM，需要抓住三个关键词：

State
Memory
Gate

而从整个 AI 技术演进来看：

DNN
 ↓
RNN
 ↓
LSTM
 ↓
LSTM + Attention
 ↓
Transformer
 ↓
BERT / GPT
 ↓
LLM
 ↓
Agent

其中 LSTM 最重要的历史贡献是：

它第一次非常成功地把“记忆”和“信息流控制”结合起来，让神经网络能够更加有效地学习长期依赖。

而 Transformer 的革命性突破，则是进一步把：

“依靠递归状态记忆过去”

转变成：

“通过 Attention 直接访问上下文”

这也是从传统序列模型走向今天 LLM 的关键一步。

建议下一篇

如果按照你现在的 DNN → CNN → LSTM 学习脉络继续，下一篇最值得深入的是：

《Transformer 深度技术博客：从 Self-Attention、Multi-Head Attention 到 GPT/LLM》

重点可以直接进入源码级和数学级分析：

LSTM
 ↓
为什么需要 Attention
 ↓
Self-Attention 数学原理
 ↓
Q / K / V
 ↓
Scaled Dot-Product Attention
 ↓
Multi-Head Attention
 ↓
Positional Encoding
 ↓
Transformer Encoder / Decoder
 ↓
GPT
 ↓
LLM

RNN（循环神经网络）：从序列建模到 LSTM/GRU

Wed, 05 Aug 2026 00:00:00 +0000

本文从 AI 工程师和系统架构师的视角，系统分析 RNN（Recurrent Neural Network，循环神经网络）的核心思想、数学原理、反向传播、梯度消失、LSTM、GRU、训练方法以及工程实践。

RNN 虽然已经不是现代大模型的主流架构，但理解 RNN 是理解 Transformer、Attention、LLM、Agent Memory 和序列建模的重要基础。

1. 为什么需要 RNN？

传统神经网络通常假设输入之间相互独立。

例如：

x1 → Neural Network → y1
x2 → Neural Network → y2
x3 → Neural Network → y3

但是现实世界大量数据具有明显的序列特征：

自然语言
语音
时间序列
股票价格
用户行为
传感器数据
日志
网络流量
视频帧

例如：

我 → 喜欢 → 学习 → 人工智能

当模型看到：

“我喜欢学习……”

它应该能够利用前面的上下文预测后面的内容。

这意味着模型需要具备一种能力：

当前计算不仅依赖当前输入，还应该依赖之前看到的信息。

RNN 的核心思想就是：

把过去的信息通过 hidden state 传递到当前时刻。

2. RNN 的核心思想

RNN 与普通神经网络最大的区别，是存在一个循环结构。

基本结构：

 ┌──────────────┐
 │ ↓
x_t → [ RNN Cell ] → h_t → [ RNN Cell ]
 ↑
 │
 h_(t-1)

在时间维度展开以后：

x1 ──→ [RNN] ──→ h1
 │
x2 ──→ [RNN] ──→ h2
 │
x3 ──→ [RNN] ──→ h3
 │
x4 ──→ [RNN] ──→ h4

其中：

x_t：当前时间步输入
h_t：当前隐藏状态
h_(t-1)：前一个时间步隐藏状态
y_t：当前输出

核心公式：

h_t = f(W_xh x_t + W_hh h_(t-1) + b_h)

输出：

y_t = g(W_hy h_t + b_y)

其中：

W_xh

负责：

当前输入 → Hidden State

而：

W_hh

负责：

Previous Hidden State → Current Hidden State

这就是 RNN 能够“记住过去”的关键。

3. RNN 本质上是什么？

从工程角度看，RNN 可以理解成一个：

带状态的神经网络。

普通神经网络：

Input
 ↓
Network
 ↓
Output

RNN：

Input + Previous State
 ↓
 Network
 ↓
Current State + Output

因此：

State_t = F(Input_t, State_(t-1))

这实际上和很多传统系统设计思想非常类似。

例如：

state = update(state, event);

RNN 做的事情就是：

h_t = update(h_(t-1), x_t)

所以可以把 RNN 看成一种：

可学习的状态机（Learnable State Machine）。

这是理解 RNN 非常重要的一个视角。

4. RNN 的数学结构

假设输入：

x_t ∈ R^D

隐藏状态：

h_t ∈ R^H

那么：

W_xh ∈ R^(H×D)

W_hh ∈ R^(H×H)

偏置：

b_h ∈ R^H

计算：

z_t = W_xh x_t + W_hh h_(t-1) + b_h

然后经过激活函数：

h_t = tanh(z_t)

最终：

y_t = W_hy h_t + b_y

所以完整模型：

x_t
 │
 ▼
W_xh x_t
 │
 ├─────────────┐
 │ │
 ▼ │
 (+) ← W_hh h_(t-1)
 │
 ▼
 tanh
 │
 ▼
 h_t
 │
 ▼
 Output

5. 为什么 RNN 能处理变长输入？

这是 RNN 非常重要的特点。

例如：

Hello

长度：

或者：

I love artificial intelligence

长度：

RNN 并不要求固定长度输入。

它可以：

x1 → h1
x2 → h2
x3 → h3
...
xn → hn

因此：

Sequence Length = n

可以动态变化。

这使 RNN 非常适合：

NLP
Speech Recognition
Time Series
Event Stream
Sensor Data

6. RNN 的关键问题：长期记忆

RNN 虽然能够传递状态，但存在一个非常严重的问题：

长期依赖（Long-Term Dependency）问题。

例如：

The cat that was sitting on the table near the window
was hungry.

模型需要知道：

cat → was

但是中间存在很多词。

信息需要经过：

h1 → h2 → h3 → h4 → ... → h50

随着序列越来越长，早期的信息可能逐渐丢失。

这就是：

Long-Term Dependency Problem

7. RNN 的梯度消失问题

这是理解 RNN 最重要的理论知识之一。

RNN 通过时间反向传播：

Backpropagation Through Time（BPTT）

假设：

h_t = tanh(W_hh h_(t-1) + ...)

在反向传播过程中：

∂L/∂h_(t-k)

需要连续乘很多 Jacobian：

∂L/∂h_t
×
∂h_t/∂h_(t-1)
×
∂h_(t-1)/∂h_(t-2)
×
...

简化理解：

gradient ≈ W^k

如果：

|W| < 1

那么：

W^k → 0

例如：

0.5^10 ≈ 0.00098

0.5^50 ≈ 8.88 × 10^-16

随着时间步增加，梯度迅速趋近于：

这就是：

Vanishing Gradient（梯度消失）

8. 梯度爆炸

另外一种情况是：

|W| > 1

例如：

1.5^10 ≈ 57.7

1.5^50 ≈ 6.37 × 10^8

梯度会越来越大。

这就是：

Exploding Gradient（梯度爆炸）

表现为：

loss → NaN

或者：

gradient → extremely large

9. Gradient Clipping

解决梯度爆炸的常见方法：

Gradient Clipping

例如：

if ||gradient|| > threshold:
 gradient = gradient * threshold / ||gradient||

PyTorch：

torch.nn.utils.clip_grad_norm_(
 model.parameters(),
 max_norm=1.0
)

其思想非常简单：

正常梯度
 ↓
直接更新

超大梯度
 ↓
限制最大范数
 ↓
再更新

需要注意：

Gradient Clipping 可以缓解梯度爆炸，但不能从根本上解决 RNN 的长期依赖问题。

真正重要的解决方案是：

LSTM / GRU

10. LSTM：RNN 的重要升级

LSTM：

Long Short-Term Memory

中文：

长短期记忆网络。

LSTM 的核心思想是：

增加一个独立的 Cell State，并通过 Gate 控制信息流。

普通 RNN：

h_(t-1)
 ↓
 RNN
 ↓
h_t

LSTM：

 Cell State
 │
 ▼
h_(t-1) → [ Gates + Memory ] → h_t
 ↑
 │
 x_t

LSTM 主要包含三个 Gate：

Forget Gate
Input Gate
Output Gate

11. Forget Gate

Forget Gate 决定：

过去的信息哪些应该忘掉？

公式：

f_t = σ(W_f [h_(t-1), x_t] + b_f)

其中：

σ = sigmoid

输出范围：

0 ~ 1

例如：

f_t = 0

表示：

完全忘记。

f_t = 1

表示：

完全保留。

因此：

Old Memory
 │
 ▼
Forget Gate
 │
 ▼
Filtered Memory

12. Input Gate

Input Gate 决定：

当前输入哪些信息应该写入 Memory？

首先：

i_t = σ(W_i[h_(t-1), x_t] + b_i)

然后产生候选记忆：

C̃_t = tanh(W_C[h_(t-1), x_t] + b_C)

最终：

C_t =
f_t ⊙ C_(t-1)
+
i_t ⊙ C̃_t

这里的：

⊙

表示逐元素乘法。

这一步是 LSTM 最核心的地方。

13. Output Gate

Output Gate 决定：

当前 Memory 中哪些信息应该输出？

公式：

o_t = σ(W_o[h_(t-1), x_t] + b_o)

然后：

h_t = o_t ⊙ tanh(C_t)

因此完整 LSTM：

 ┌───────────────┐
 │ Cell State │
 │ C_t │
 └───────────────┘
 ↑
 Forget/Input
 ↑
 │
x_t ─────────→ [ LSTM Cell ]
 │
 ↓
 h_t

14. 为什么 LSTM 能解决长期依赖？

这是理解 LSTM 的核心。

普通 RNN：

h1 → h2 → h3 → h4 → h5 → ...

每一步都需要经过：

tanh

信息很容易衰减。

LSTM 引入：

Cell State

它提供了一条相对稳定的信息传递路径：

C1 ───────────────→ C2 ───────────────→ C3 ─────────────→ Cn
 ↑ ↑ ↑
 Gate Gate Gate

Gate 可以决定：

保留
删除
写入
输出

所以 LSTM 本质上是在学习：

什么信息应该记住，什么信息应该忘记。

15. GRU：更简单的 LSTM

GRU：

Gated Recurrent Unit

它可以理解为：

简化版 LSTM。

GRU 没有独立的 Cell State。

主要有两个 Gate：

Update Gate
Reset Gate

Update Gate：

z_t = σ(W_z[x_t, h_(t-1)] + b_z)

Reset Gate：

r_t = σ(W_r[x_t, h_(t-1)] + b_r)

候选状态：

h̃_t =
tanh(
W_h[x_t, r_t ⊙ h_(t-1)]
)

最终：

h_t =
(1-z_t) ⊙ h_(t-1)
+
z_t ⊙ h̃_t

16. LSTM vs GRU

特性	RNN	LSTM	GRU
Hidden State	✅	✅	✅
Cell State	❌	✅	❌
Gate	❌	3	2
参数量	少	多	中
长期依赖	弱	强	强
计算成本	低	高	中
训练速度	快	较慢	较快

工程实践中：

简单序列 → RNN
复杂长期依赖 → LSTM
希望降低复杂度 → GRU

17. RNN 的四种典型结构

RNN 不只是“一进一出”。

常见结构包括：

17.1 One-to-One

Input → Model → Output

实际上普通神经网络即可。

17.2 One-to-Many

 ┌→ y1
x → RNN ├→ y2
 └→ y3

例如：

Image Caption

输入一张图片：

Image
 ↓
CNN
 ↓
RNN
 ↓
A cat is sitting...

17.3 Many-to-One

x1
 ↓
x2 → RNN → y
 ↓
x3

例如：

Sentiment Analysis

输入：

I really love this movie

输出：

Positive

17.4 Many-to-Many

x1 → RNN → y1
x2 → RNN → y2
x3 → RNN → y3

例如：

POS Tagging

I → PRON
love → VERB
AI → NOUN

18. Bidirectional RNN

普通 RNN：

x1 → x2 → x3 → x4

信息只能：

过去 → 现在

BiRNN：

Forward:
x1 → x2 → x3 → x4

Backward:
x4 → x3 → x2 → x1

最终：

h_t = [h_forward ; h_backward]

这样模型同时利用：

Past Context
+
Future Context

例如：

I went to the bank to deposit money.

“bank”的语义需要上下文判断。

双向模型可以利用：

前文 + 后文

因此在 NLP 中非常有效。

19. RNN 的训练：BPTT

RNN 训练使用：

Backpropagation Through Time

首先把 RNN 在时间维度展开：

 ┌───────────────┐
x1 → [RNN] → h1 │
 │ │
x2 → [RNN] → h2 │
 │ │
x3 → [RNN] → h3 │
 │ │
x4 → [RNN] → h4 │

虽然看起来像多个网络：

RNN1
RNN2
RNN3
RNN4

实际上它们共享参数：

W_xh
W_hh
W_hy

这也是 RNN 参数量不会随着序列长度线性增加的原因。

20. Truncated BPTT

如果序列特别长：

x1 → x2 → ... → x100000

完整 BPTT 的成本非常高。

因此实际训练经常使用：

Truncated Backpropagation Through Time

例如每：

20 steps

截断一次：

x1 → ... → x20
 ↓
 Backprop

x21 → ... → x40
 ↓
 Backprop

这样能够：

降低内存消耗
降低计算成本
提高训练效率

但代价是：

模型无法通过反向传播学习非常长的依赖关系。

21. RNN 在 NLP 中的应用

早期 NLP 系统大量使用：

Embedding
 ↓
RNN / LSTM
 ↓
Classifier

例如文本分类：

"I love this product"
 ↓
Tokenization
 ↓
Embedding
 ↓
LSTM
 ↓
Hidden State
 ↓
Fully Connected
 ↓
Positive

22. Word Embedding + RNN

RNN 本身不能直接理解：

cat
dog
machine

通常需要 Embedding。

例如：

"cat"
 ↓
Embedding
 ↓
[0.21, -0.33, 0.72, ...]

得到：

x1
x2
x3
...

然后：

x1 → RNN
x2 → RNN
x3 → RNN

因此经典 NLP 架构：

Text
 ↓
Tokenizer
 ↓
Embedding
 ↓
RNN/LSTM/GRU
 ↓
Dense
 ↓
Prediction

23. RNN 为什么最终被 Transformer 大量替代？

这是理解现代 AI 技术栈非常重要的问题。

RNN 最大的问题不是“表达能力不足”，而是：

序列计算天然具有强依赖关系。

例如：

h1
 ↓
h2
 ↓
h3
 ↓
h4

必须等待：

h1 → h2 → h3 → h4

因此难以完全并行。

而 Transformer 可以：

x1 ─┐
x2 ─┤
x3 ─┼→ Self-Attention
x4 ─┤
x5 ─┘

大量计算可以并行执行。

这对 GPU/TPU 非常重要。

24. RNN 与 Transformer 的本质区别

可以从“信息访问方式”理解。

RNN：

Current Token
 ↓
Previous Hidden State
 ↓
Previous Context

信息必须逐步传递。

Transformer：

 ┌─────────────┐
x1 ─────────→│ │
x2 ─────────→│ Self │
x3 ─────────→│ Attention │
x4 ─────────→│ │
x5 ─────────→│ │
 └─────────────┘

每个 Token 可以直接关注其他 Token。

例如：

The cat sat on the mat because it was tired.

模型可以通过 Attention 直接建立：

it → cat

而不需要像 RNN 一样依赖：

cat → ... → it

逐步传递。

25. RNN → LSTM → Attention → Transformer

从 AI 技术演进来看：

RNN
 │
 ├── LSTM
 │
 └── GRU
 │
 ↓
 Attention
 │
 ↓
 Transformer
 │
 ↓
 LLM

这条技术路线非常重要。

可以把它理解成：

第一阶段：RNN

解决：

如何处理序列？

第二阶段：LSTM / GRU

解决：

如何记住长期信息？

第三阶段：Attention

解决：

当前信息应该重点关注过去的哪些信息？

第四阶段：Transformer

解决：

如何高效、并行地进行大规模序列建模？

第五阶段：LLM

进一步解决：

如何利用 Transformer 学习语言、知识、推理和复杂任务能力？

26. 从系统架构角度理解 RNN

作为软件工程师，可以把 RNN 看成：

Input Stream
 ↓
┌──────────────┐
│ State Machine│
│ │
│ state = h_t │
└──────────────┘
 ↓
Output

每次输入一个 Event：

event_t
 ↓
state transition
 ↓
new state

即：

h_t = F(h_(t-1), x_t)

这和：

Event Sourcing
Stream Processing
Stateful Processing

存在非常直观的概念联系。

例如 Kafka Stream：

Event1
Event2
Event3
Event4
 ↓
Stateful Processor
 ↓
Current State

RNN：

x1
x2
x3
x4
 ↓
RNN
 ↓
h4

区别在于：

Kafka Processor 的状态更新规则由程序员定义，而 RNN 的状态更新函数由神经网络通过训练学习出来。

27. 一个简单的 PyTorch RNN

下面是一个最基本的 RNN 模型：

import torch
import torch.nn as nn


class SimpleRNN(nn.Module):

 def __init__(self, input_size, hidden_size, output_size):
 super().__init__()

 self.rnn = nn.RNN(
 input_size=input_size,
 hidden_size=hidden_size,
 batch_first=True
 )

 self.fc = nn.Linear(
 hidden_size,
 output_size
 )

 def forward(self, x):

 output, hidden = self.rnn(x)

 last_hidden = hidden[-1]

 return self.fc(last_hidden)

数据：

[batch_size, sequence_length, input_size]

例如：

x.shape

可能是：

[32, 50, 128]

含义：

32 = batch size
50 = sequence length
128 = feature dimension

28. LSTM PyTorch 实现

class LSTMModel(nn.Module):

 def __init__(
 self,
 input_size,
 hidden_size,
 output_size
 ):
 super().__init__()

 self.lstm = nn.LSTM(
 input_size=input_size,
 hidden_size=hidden_size,
 batch_first=True
 )

 self.fc = nn.Linear(
 hidden_size,
 output_size
 )

 def forward(self, x):

 output, (hidden, cell) = self.lstm(x)

 last_hidden = hidden[-1]

 return self.fc(last_hidden)

这里：

hidden

代表：

h_t

而：

cell

代表：

C_t

这正对应 LSTM 的两个状态。

29. 实际工程中 RNN 的重要超参数

使用 RNN/LSTM/GRU 时，需要重点关注：

hidden_size

例如：

越大：

模型容量 ↑
计算成本 ↑
内存 ↑

num_layers

例如：

nn.LSTM(
 input_size=128,
 hidden_size=256,
 num_layers=3
)

代表：

LSTM Layer 1
 ↓
LSTM Layer 2
 ↓
LSTM Layer 3

dropout

用于降低过拟合。

例如：

nn.LSTM(
 input_size=128,
 hidden_size=256,
 num_layers=3,
 dropout=0.2
)

bidirectional

nn.LSTM(
 input_size=128,
 hidden_size=256,
 bidirectional=True
)

此时输出维度通常变为：

256 × 2 = 512

30. RNN 的主要优点

虽然 Transformer 已经成为主流，但 RNN 仍然有一些优势。

30.1 参数共享

同一个 RNN Cell 可以处理：

x1
x2
x3
...
xn

参数不随序列长度增长。

30.2 适合流式处理

RNN 可以逐个处理输入：

Event1 → State1
Event2 → State2
Event3 → State3

因此非常适合：

Streaming
Online Prediction
Real-time Sensor
Edge Computing

30.3 内存需求可以较低

不需要像某些 Transformer 训练场景那样显式处理整个序列的 Attention Matrix。

对于某些特殊的：

Streaming / Online

场景，RNN 仍然具有价值。

31. RNN 的主要缺点

31.1 长期依赖

普通 RNN：

Long Sequence
 ↓
Information Loss

31.2 梯度消失

Gradient
 ↓
Repeated Multiplication
 ↓
Very Small
 ↓
Learning Stops

31.3 梯度爆炸

Gradient
 ↓
Repeated Multiplication
 ↓
Very Large
 ↓
Training Instability

31.4 难以并行

h1 → h2 → h3 → h4

后一个时间步依赖前一个时间步。

因此：

GPU Parallelism
 ↓
受限

32. RNN 的现代价值

学习 RNN 不是为了在今天所有 AI 项目中直接使用 RNN。

真正重要的是理解它解决问题的方式。

RNN 教会我们三个非常重要的概念：

1. State

Past → State → Future

2. Sequence Modeling

x1, x2, ..., xn

不是独立数据，而是一个整体。

3. Attention 的动机

RNN：

过去的信息
 ↓
逐步压缩
 ↓
Hidden State

这个设计天然存在信息瓶颈。

Attention 的出现，本质上就是在解决：

为什么一定要把整个历史压缩到一个固定大小的 Hidden State？

Attention 让模型可以直接访问历史信息。

这是从 RNN 理解 Transformer 最重要的桥梁之一。

33. RNN、LSTM、Transformer 的认知模型

可以用一句话概括：

RNN：
我把过去压缩成一个状态。

LSTM：
我会决定哪些过去的信息应该保留。

Attention：
我可以直接查看过去的信息，并决定关注什么。

Transformer：
我可以并行地让大量 Token 相互建立关系。

LLM：
我在 Transformer 的基础上学习语言、知识、推理和复杂任务。

34. RNN 学习中的核心知识地图

建议把 RNN 的知识体系理解成：

 RNN
 │
 ┌────────────┼────────────┐
 │ │ │
 Forward State Output
 │ │ │
 ↓ ↓ ↓
 h_t h_(t-1) y_t
 │
 ↓
 BPTT
 │
 ┌──────────┴──────────┐
 ↓ ↓
 Gradient Vanishing Gradient Explosion
 │ │
 ↓ ↓
 LSTM Gradient Clipping
 │
 ↓
 GRU
 │
 ↓
 Attention
 │
 ↓
 Transformer
 │
 ↓
 LLM

这张知识地图实际上连接了：

Deep Learning
 ↓
Sequence Modeling
 ↓
RNN
 ↓
LSTM / GRU
 ↓
Attention
 ↓
Transformer
 ↓
Generative AI
 ↓
LLM
 ↓
Agent

35. 作为 AI 工程师，RNN 最应该掌握什么？

如果目标是进入现代 AI / LLM 工程，而不是专门做传统序列模型，那么 RNN 不需要停留在大量公式推导上。

建议重点掌握以下 8 个概念：

优先级	知识	重要性
1	Hidden State	⭐⭐⭐⭐⭐
2	Sequence Modeling	⭐⭐⭐⭐⭐
3	BPTT	⭐⭐⭐⭐
4	Vanishing Gradient	⭐⭐⭐⭐⭐
5	LSTM	⭐⭐⭐⭐⭐
6	GRU	⭐⭐⭐⭐
7	Bidirectional RNN	⭐⭐⭐
8	RNN → Attention → Transformer	⭐⭐⭐⭐⭐

其中最重要的是：

RNN 为什么需要 State？
 ↓
为什么长期依赖困难？
 ↓
为什么出现 LSTM？
 ↓
为什么又出现 Attention？
 ↓
为什么最终发展到 Transformer？

一旦理解了这条逻辑链，现代大模型架构会容易理解很多。

36. 总结

RNN 是深度学习历史上非常重要的一类序列模型。

它通过：

Current Input
+
Previous Hidden State
 ↓
 RNN Cell
 ↓
Current Hidden State

建立了对序列数据的建模能力。

但普通 RNN 存在：

Long-Term Dependency
Gradient Vanishing
Gradient Explosion
Sequential Computation

等问题。

于是产生：

RNN
 ↓
LSTM / GRU
 ↓
Attention
 ↓
Transformer
 ↓
LLM

从今天 AI 技术发展的角度看，RNN 最大的价值已经不仅仅是“一个可以使用的神经网络”。

更重要的是：

RNN 是理解现代序列建模思想的一块基石。

如果真正理解：

Hidden State
Cell State
BPTT
Gradient Vanishing
LSTM Gate
GRU Gate

再进一步理解：

Attention
Self-Attention
Transformer

就能够形成一条非常完整的 AI 技术演进链。

Transformer：从 Self-Attention 到现代大语言模型

Wed, 05 Aug 2026 00:00:00 +0000

Transformer 是过去十年人工智能领域最重要的神经网络架构之一。从机器翻译、BERT、GPT，到今天的 ChatGPT、代码模型、多模态模型和 Agent，现代生成式 AI 的核心技术栈几乎都建立在 Transformer 及其衍生架构之上。

本文不把 Transformer 简单理解为一个“神经网络模型”，而是从 序列建模 → Attention → Self-Attention → Multi-Head Attention → Transformer Block → Encoder/Decoder → GPT → LLM → KV Cache → MoE 的完整技术链路进行分析。

1. Transformer 到底解决了什么问题？

在 Transformer 出现之前，NLP 的主流模型之一是 RNN/LSTM。

例如：

I → love → artificial → intelligence

RNN 按顺序处理：

x1 → RNN → h1
 ↓
x2 → RNN → h2
 ↓
x3 → RNN → h3
 ↓
x4 → RNN → h4

存在两个核心问题。

问题一：无法充分并行

因为：

h2 依赖 h1
h3 依赖 h2
h4 依赖 h3

所以：

h1 → h2 → h3 → h4

必须按照顺序执行。

GPU 最擅长：

Parallel Computation

而 RNN 的时间依赖限制了并行能力。

问题二：长期依赖困难

例如：

The book that I bought yesterday from the bookstore
was expensive.

模型在预测：

was

时，需要理解：

book → was

但是两个词之间可能相隔几十甚至几百个 Token。

RNN 需要：

h1 → h2 → h3 → ... → h100

逐步传播信息。

Transformer 的思路完全不同：

不要强迫信息逐步传播，而是让 Token 直接访问其他 Token。

这就是：

Attention

2. Attention 的核心思想

Attention 可以理解成：

当前 Token 应该关注哪些其他 Token？

例如：

The animal didn't cross the street because it was too tired.

这里：

it

究竟指：

animal

还是：

street

模型需要根据上下文建立关联。

Attention 可以计算：

it → animal

的高相关性。

因此：

RNN：

Token
 ↓
Hidden State
 ↓
Next Token


Transformer：

Token
 ↓
Attention
 ↙ ↓ ↘
Token Token Token

3. Self-Attention

Transformer 最核心的技术：

Self-Attention

所谓 Self，是因为：

Query、Key、Value 都来自同一个输入序列。

假设：

X = [x1, x2, x3, x4]

Self-Attention 会产生：

x1 → 看 x1 x2 x3 x4
x2 → 看 x1 x2 x3 x4
x3 → 看 x1 x2 x3 x4
x4 → 看 x1 x2 x3 x4

也就是说：

每个 Token 都可以和其他 Token 建立关系。

这就是 Transformer 强大的核心原因。

4. Query、Key、Value

Self-Attention 最重要的三个概念：

Q = Query
K = Key
V = Value

可以用数据库查询来类比。

假设你搜索：

"Java concurrency"

可以理解为：

Query = Java concurrency

数据库中的：

Key

用于匹配。

匹配之后取出：

Value

Transformer 中也是类似思想。

5. Q、K、V 如何产生？

输入：

经过三个不同的线性变换：

Q = XW_Q

K = XW_K

V = XW_V

其中：

W_Q
W_K
W_V

都是模型需要训练的参数。

所以：

Input
 │
 ├──→ W_Q → Q
 │
 ├──→ W_K → K
 │
 └──→ W_V → V

这是 Transformer 最重要的基础计算之一。

6. Attention Score

有了 Q 和 K 后，需要计算：

Query 与 Key 到底有多相关？

使用：

QKᵀ

例如：

Q = [q1, q2, q3]

K = [k1, k2, k3]

计算：

QKᵀ

得到：

这个矩阵表示：

Token1 对 Token1/2/3 的关注程度
Token2 对 Token1/2/3 的关注程度
Token3 对 Token1/2/3 的关注程度

7. 为什么要除以 sqrt(d_k)？

Transformer 的经典 Attention 公式：

Attention(Q,K,V)
=
softmax(
QKᵀ / √d_k
)V

这里：

d_k

是 Key 的维度。

为什么需要：

√d_k

？

因为当维度变大时：

QKᵀ

的数值可能越来越大。

例如：

d_k = 64

如果不进行缩放：

QKᵀ

可能产生非常大的数值。

经过 Softmax 后：

[0.000001, 0.999998, 0.000001]

容易导致：

Softmax 饱和。

梯度也可能变得非常小。

因此：

QKᵀ / √d_k

可以让数值保持在更加稳定的范围。

这就是：

Scaled Dot-Product Attention

8. Softmax

得到 Attention Score 后：

S = QKᵀ / √d_k

需要转换成概率分布：

A = softmax(S)

例如：

[2.0, 1.0, 0.1]

经过 Softmax：

[0.66, 0.24, 0.10]

于是模型可以理解：

Token A
 ↓
66% attention → Token1
24% attention → Token2
10% attention → Token3

这就是：

Attention Weight

9. 最终 Attention 输出

最后：

Attention(Q,K,V)
=
softmax(
QKᵀ / √d_k
)V

实际上就是：

Attention Weight
 ×
 Value
 ↓
Weighted Sum

例如：

Attention Weight:

[0.7, 0.2, 0.1]

Value：

V1
V2
V3

最终：

Output
=
0.7V1
+
0.2V2
+
0.1V3

因此 Attention 本质上是：

根据相关性，对 Value 做加权聚合。

10. Self-Attention 的完整流程

完整过程：

Input X
 │
 ├─────────────┐
 │ │
 ↓ ↓
 W_Q W_K
 ↓ ↓
 Q K
 \ /
 \ /
 QKᵀ
 │
 ↓
 Scale
 │
 ↓
 Softmax
 │
 ↓
 Attention Weights
 │
 ×
 │
 V
 │
 ↓
 Output

公式：

Attention(Q,K,V)
=
softmax(
QKᵀ / √d_k
)V

如果只记住 Transformer 一个公式：

记住这个。

11. Multi-Head Attention

单个 Attention Head 只能学习一种关系。

但是自然语言中存在很多不同类型的关系：

语法关系
语义关系
指代关系
位置关系
实体关系
上下文关系

因此 Transformer 不使用一个 Attention，而是：

Multi-Head Attention

例如：

Head 1 → 语法关系
Head 2 → 语义关系
Head 3 → 指代关系
Head 4 → 长距离关系

12. Multi-Head Attention 的结构

假设：

d_model = 512

使用：

8 heads

那么每个 Head：

d_head = 512 / 8 = 64

结构：

 Input
 │
 ┌──────────┼──────────┐
 ↓ ↓ ↓
 Head1 Head2 Head8
 │ │ │
 ↓ ↓ ↓
 Attn Attn Attn
 │ │ │
 └──────────┼───────────┘
 ↓
 Concat
 ↓
 Linear
 ↓
 Output

公式：

MultiHead(Q,K,V)
=
Concat(head1,...,headh)W_O

其中：

head_i
=
Attention(
QW_Q^i,
KW_K^i,
VW_V^i
)

13. 为什么 Multi-Head 有意义？

假设一句话：

The developer fixed the bug because he understood the system.

不同 Head 可以学习不同关系：

Head 1:
developer → he

Head 2:
fixed → bug

Head 3:
understood → system

因此：

Multi-Head Attention 让模型能够在不同表示子空间中同时学习不同类型的关系。

14. Positional Encoding

Transformer 有一个非常重要的问题：

Attention 本身不知道 Token 的顺序。

例如：

I love AI

和：

AI love I

如果只看 Token 集合，Self-Attention 本身无法天然区分顺序。

因此必须加入：

Position Information

15. 原始 Transformer 的 Positional Encoding

论文中的经典方法：

PE(pos, 2i)
=
sin(
pos / 10000^(2i/d_model)
)

PE(pos, 2i+1)
=
cos(
pos / 10000^(2i/d_model)
)

最终：

Input Embedding
+
Position Encoding

得到：

Transformer Input

16. 为什么使用 Sin/Cos？

因为正弦和余弦具有连续周期结构。

模型可以利用：

sin
cos

表示不同位置。

例如：

Position 1
Position 2
Position 3
...

产生不同的向量。

而且不同维度具有不同频率。

因此可以编码：

绝对位置
+
相对位置信息

17. 现代 Transformer 的位置编码

需要特别注意：

现代 LLM 并不一定使用原始 Transformer 的 Sin/Cos Positional Encoding。

例如很多现代模型采用：

RoPE

即：

Rotary Positional Embedding

另外还有：

ALiBi
Relative Position Encoding

等方法。

尤其在现代 GPT 类模型中：

RoPE 是理解现代 LLM 架构非常重要的知识点。

18. Transformer Encoder

经典 Transformer 论文：

Attention Is All You Need

提出了 Encoder-Decoder 架构。

Encoder：

Input
 ↓
Embedding
 ↓
Positional Encoding
 ↓
Encoder Block
 ↓
Encoder Block
 ↓
...
 ↓
Output

每个 Encoder Block 主要包含：

Multi-Head Self-Attention
 ↓
Add & Norm
 ↓
Feed Forward Network
 ↓
Add & Norm

19. Transformer Encoder Block

结构：

 Input
 │
 ↓
 Multi-Head Attention
 │
 ↓
 Add + Norm
 │
 ↓
 Feed Forward
 │
 ↓
 Add + Norm
 │
 ↓
 Output

两个非常重要的组件：

Residual Connection
Layer Normalization

20. Residual Connection

Residual Connection：

Output = F(x) + x

而不是：

Output = F(x)

结构：

 ┌──────────────┐
 │ │
 │ ↓
x ─────→ F(x) ───────→ (+)
 │
 ↓
 Output

为什么这样做？

因为深层网络容易：

梯度消失
训练困难

Residual Connection 提供了一条：

Gradient Highway

使梯度可以更稳定地传播。

ResNet、Transformer 都大量使用这种思想。

21. Layer Normalization

Transformer 大量使用：

LayerNorm

它与 BatchNorm 有重要区别。

BatchNorm：

Batch Dimension

LayerNorm：

Feature Dimension

对于 NLP/Transformer 来说：

LayerNorm 更适合序列数据。

基本形式：

LN(x)
=
γ
(
x - μ
)
/
√(σ² + ε)
+
β

其中：

μ
σ²

是当前样本特征维度上的统计量。

22. Feed Forward Network

Transformer Block 中另一个重要组件：

Feed Forward Network

通常：

FFN(x)
=
Activation(xW1 + b1)W2 + b2

例如：

结构：

Input
 ↓
Linear
 ↓
Activation
 ↓
Linear
 ↓
Output

经典 Transformer 使用：

ReLU

现代 LLM 常见：

GELU
SwiGLU
GeGLU

23. FFN 到底在干什么？

Attention 主要负责：

Token 与 Token 之间的信息交互。

FFN 更像：

对每一个 Token 独立进行非线性特征变换。

因此可以简单理解：

Attention
=
Token之间通信

FFN
=
Token内部计算

这是理解 Transformer Block 非常好的抽象。

24. Attention + FFN

因此一个 Transformer Block 可以抽象成：

Input
 │
 ↓
Attention
 │
 ↓
Token Communication
 │
 ↓
FFN
 │
 ↓
Feature Transformation
 │
 ↓
Output

从这个角度看：

Transformer 本质上是一个不断进行“信息通信 + 特征计算”的深层网络。

25. Transformer Decoder

Decoder 与 Encoder 不完全相同。

Decoder 主要包含：

Masked Self-Attention
 ↓
Cross Attention
 ↓
Feed Forward

结构：

Input
 ↓
Masked Self-Attention
 ↓
Add & Norm
 ↓
Cross Attention
 ↓
Add & Norm
 ↓
FFN
 ↓
Add & Norm

26. 为什么 Decoder 需要 Mask？

考虑生成：

I love artificial intelligence

当模型生成：

artificial

时，它不能偷看：

intelligence

否则训练任务就作弊了。

因此 Decoder 使用：

Causal Mask / Look-Ahead Mask

形成：

Token1 → Token1

Token2 → Token1 Token2

Token3 → Token1 Token2 Token3

Token4 → Token1 Token2 Token3 Token4

Attention Matrix：

这就是：

Causal Attention

27. GPT 为什么只需要 Decoder？

现代 GPT 类模型通常采用：

Decoder-only Transformer

结构：

Tokens
 ↓
Embedding
 ↓
Transformer Block
 ↓
Transformer Block
 ↓
...
 ↓
Transformer Block
 ↓
LM Head
 ↓
Next Token

它不需要传统 Transformer 中的 Encoder。

原因是 GPT 的核心任务是：

Autoregressive Language Modeling

即：

P(x_t | x_1, x_2, ..., x_(t-1))

预测下一个 Token。

28. GPT 的本质

假设：

Input:

The weather today is

模型计算：

P(
 next_token
 |
 The weather today is
)

可能得到：

good 0.32
beautiful 0.18
sunny 0.12
...

然后选择：

good

得到：

The weather today is good

继续：

P(
 next_token
 |
 The weather today is good
)

于是不断生成：

Token1
 ↓
Token2
 ↓
Token3
 ↓
Token4

这就是 LLM 最基础的生成机制。

29. Transformer 与 LLM 的关系

需要明确：

Transformer ≠ LLM

Transformer 是：

Neural Network Architecture

LLM 是：

Large Language Model

关系可以理解为：

Transformer
 ↓
模型架构
 ↓
GPT / LLaMA / Qwen 等
 ↓
大规模参数 + 大规模数据 + 大规模训练
 ↓
LLM

因此：

Transformer

是建筑结构。

而：

LLM

是利用这种建筑结构建出来的大型系统。

30. Tokenization

LLM 并不是直接处理：

"Hello world"

而是：

Text
 ↓
Tokenizer
 ↓
Token IDs

例如：

Hello world

可能变成：

[15496, 995]

具体 Token ID 取决于 Tokenizer。

然后：

Token ID
 ↓
Embedding
 ↓
Vector

最终 Transformer 接收的是：

Vector Sequence

31. Embedding

假设：

Vocabulary = 100000
Embedding Dimension = 4096

Embedding Matrix：

E ∈ R^(100000 × 4096)

每一个 Token 都对应一个向量：

Token ID
 ↓
Embedding Lookup
 ↓
[0.12, -0.37, ..., 0.82]

所以：

Embedding 是把离散 Token 映射到连续向量空间。

32. Transformer 的完整数据流

现代 Decoder-only LLM 可以抽象为：

 Text
 │
 ↓
 Tokenizer
 │
 ↓
 Token IDs
 │
 ↓
 Embedding
 │
 ↓
 Position Encoding
 │
 ↓
 ┌─────────────────────┐
 │ Transformer Block │
 │ │
 │ LayerNorm │
 │ ↓ │
 │ Self-Attention │
 │ ↓ │
 │ Residual │
 │ ↓ │
 │ LayerNorm │
 │ ↓ │
 │ FFN │
 │ ↓ │
 │ Residual │
 └─────────────────────┘
 │
 ...
 │
 ↓
 Final LayerNorm
 │
 ↓
 LM Head
 │
 ↓
 Logits
 │
 ↓
 Softmax
 │
 ↓
 Next Token

这基本就是现代 GPT 类 LLM 的核心计算链路。

33. Logits

Transformer 最终不会直接输出：

"hello"

而是输出：

logits

例如词表：

hello
world
AI
Java
Python
...

模型可能输出：

hello → 2.3
world → 1.8
AI → 4.2
Java → 0.7
...

经过 Softmax：

hello → 0.08
world → 0.05
AI → 0.72
Java → 0.01
...

然后根据：

Greedy
Temperature
Top-K
Top-P

等策略选择下一个 Token。

34. Temperature

Temperature 用于控制随机性。

Softmax：

P_i =
exp(z_i / T)
/
Σ exp(z_j / T)

当：

T < 1

分布更加尖锐：

更确定

当：

T > 1

分布更加平滑：

更随机

因此：

T ↓ → deterministic
T ↑ → creative

35. Top-K

假设：

Vocabulary = 100000

Top-K：

K = 50

只保留概率最高的：

50 tokens

其他：

99950 tokens

直接忽略。

这样可以减少：

极低概率 Token 导致的异常生成。

36. Top-P

Top-P 又叫：

Nucleus Sampling

例如：

P = 0.9

按照概率从高到低累加：

0.40
0.25
0.15
0.07
0.03
...

直到：

累计概率 ≥ 0.9

只从这些 Token 中采样。

相比固定：

Top-K

Top-P 更动态。

37. Transformer 的计算复杂度

Self-Attention 最大的问题：

QKᵀ

如果：

Sequence Length = n

Attention Matrix：

n × n

因此时间/空间复杂度大致与：

O(n²)

38. 为什么 LLM 需要 KV Cache？

生成式 LLM 是逐 Token 生成的。

例如：

Token1
 ↓
Token2
 ↓
Token3
 ↓
Token4

如果每生成一个 Token 都重新计算之前所有 Token 的：

K
V

会产生大量重复计算。

因此缓存：

Key
Value

即：

KV Cache

39. KV Cache 的工作原理

第一次：

Token1
 ↓
K1 V1

第二次：

Token1 Token2
 ↓
K1 V1
K2 V2

第三次：

Token1 Token2 Token3
 ↓
K1 V1
K2 V2
K3 V3

之前计算过的：

K1 V1
K2 V2

可以直接复用。

因此：

KV Cache
=
避免重复计算

40. KV Cache 的工程代价

KV Cache 虽然提升了推理速度，但需要大量 GPU Memory。

大致可以理解：

KV Memory
∝
Batch Size
×
Sequence Length
×
Number of Layers
×
KV Heads
×
Head Dimension

因此 LLM Serving 系统中非常重要的问题包括：

GPU Memory
KV Cache Management
Batching
Paged Attention
Continuous Batching

这已经从：

AI Model

进入：

AI Systems Engineering

领域。

41. MQA 和 GQA

为了降低 KV Cache 的内存成本，现代模型引入：

MQA

Multi-Query Attention

多个 Query Head：

Q1 Q2 Q3 Q4

共享：

K V

GQA

Grouped-Query Attention

多个 Query Head 分组共享：

K/V Heads

例如：

Q1 Q2 → KV1
Q3 Q4 → KV2
Q5 Q6 → KV3
Q7 Q8 → KV4

相比传统 MHA：

Q1 → K1 V1
Q2 → K2 V2
Q3 → K3 V3
...

GQA 可以明显降低：

KV Cache

同时保持较好的模型能力。

42. FlashAttention

Transformer 的另一个重要优化：

FlashAttention

它并不是简单地修改 Attention 数学公式，而是：

通过 IO-aware 的 GPU Kernel 优化 Attention 计算。

传统 Attention：

Q
 ↓
QKᵀ
 ↓
Softmax
 ↓
× V

中间可能产生巨大的：

N × N

矩阵。

FlashAttention 通过更加高效的：

Tiling
Memory Hierarchy
Kernel Fusion

减少 GPU HBM 与 SRAM 之间的数据搬运。

核心思想可以简单理解成：

不要只是优化 FLOPs，更要优化 GPU Memory Access。

这是现代 LLM 系统优化的重要思想。

43. Pre-Norm vs Post-Norm

原始 Transformer：

x
 ↓
Attention
 ↓
Add
 ↓
LayerNorm

属于：

Post-Norm

现代 LLM 更常见：

x
 ↓
LayerNorm
 ↓
Attention
 ↓
Add

属于：

Pre-Norm

即：

x + Attention(LN(x))

相比：

LN(x + Attention(x))

Pre-Norm 通常具有更好的深层训练稳定性。

44. RMSNorm

现代 LLM 中还经常看到：

RMSNorm

它比 LayerNorm 更简单。

LayerNorm：

减均值
+
除标准差

RMSNorm：

只考虑 RMS

形式大致：

RMS(x)
=
sqrt(
mean(x²) + ε
)

然后：

RMSNorm(x)
=
x / RMS(x) × weight

优点：

计算简单
参数少
效率高

45. 激活函数：从 ReLU 到 SwiGLU

经典 Transformer：

FFN
 ↓
ReLU

现代 LLM 经常使用：

SwiGLU

例如：

SwiGLU(x)
=
(SiLU(xW_g))
⊙
(xW_u)

然后：

Output
=
SwiGLU(x)W_d

SwiGLU 的目标是：

在控制计算成本的同时增强模型表达能力。

因此现代 LLM 的 Transformer Block 与 2017 年原始论文中的 Transformer 已经存在不少差异。

46. MoE：Transformer 的进一步演化

当模型越来越大：

7B
13B
70B
400B
...

一个问题出现：

如果所有参数每次都参与计算，成本非常高。

于是出现：

Mixture of Experts（MoE）

基本思想：

Input
 ↓
Router
 ↓
┌────┬────┬────┬────┐
Expert1 Expert2 Expert3 Expert4
└────┴────┴────┴────┘
 ↓
Selected Experts
 ↓
Output

例如：

总参数：
100B

每个 Token 实际激活：
20B

于是：

Total Parameters ≠ Active Parameters

这成为现代大模型架构的重要方向。

47. Transformer 的工程视角

对于传统软件工程师来说，可以把 Transformer 看成一个大型分布式计算系统的“计算核心”。

一个 Token 进入系统后：

Token
 ↓
Embedding
 ↓
Position
 ↓
Attention
 ↓
Communication
 ↓
FFN
 ↓
Transformation
 ↓
Next Block
 ↓
...
 ↓
Logits

从软件架构角度：

Embedding
 ↓
Data Representation

Attention
 ↓
Information Routing

FFN
 ↓
Feature Processing

Residual
 ↓
Stable Data Flow

LayerNorm
 ↓
Numerical Stabilization

KV Cache
 ↓
State / Cache Management

Batching
 ↓
Throughput Optimization

GPU Kernel
 ↓
Execution Optimization

因此：

现代 LLM 不只是机器学习问题，也是一个极其复杂的分布式系统和高性能计算问题。

48. Transformer 与 Agent 的关系

如果进一步进入 Agent 领域，可以看到：

User
 ↓
LLM
 ↓
Reasoning
 ↓
Tool Selection
 ↓
Tool
 ↓
Observation
 ↓
LLM
 ↓
Next Action

这里 Transformer 负责：

Context Understanding
Reasoning
Generation
Tool Calling
Planning

而 Agent 系统负责：

Memory
Tools
State
Workflow
Execution
Observation

因此可以理解：

Transformer 是 Agent 的“大脑计算核心”，而 Agent 系统则是在 Transformer 外部构建了状态、工具、环境和执行能力。

49. Transformer 的完整知识地图

把整个 Transformer 技术体系串起来：

 Transformer
 │
 ┌────────────────┼────────────────┐
 │ │ │
 Embedding Attention FFN
 │ │ │
 │ ┌──────┴──────┐ │
 │ │ │ │
 │ Self Multi-Head │
 │ Attention Attention │
 │ │ │ │
 │ └──────┬──────┘ │
 │ │ │
 └────────────────┼────────────────┘
 │
 Residual + Norm
 │
 ↓
 Transformer Block
 │
 ↓
 ┌─────────┴─────────┐
 │ │
 Encoder Decoder
 │ │
 BERT GPT
 │
 ↓
 LLM
 │
 ┌───────────────────┼───────────────────┐
 │ │ │
 RoPE KV Cache MoE
 │ │ │
 ↓ ↓ ↓
 Position Info Serving Scaling

50. Transformer 最重要的几个公式

如果准备 AI Engineer / LLM Engineer 面试，建议至少熟悉下面几个公式。

Attention

Attention(Q,K,V)
=
softmax(
QKᵀ / √d_k
)V

Multi-Head Attention

MultiHead(Q,K,V)
=
Concat(head1,...,headh)W_O

FFN

FFN(x)
=
Activation(xW1+b1)W2+b2

Autoregressive Language Modeling

P(x1,...,xn)
=
∏ P(x_t | x_<t)

Cross Entropy

语言模型训练通常最小化：

L
=
-Σ y_t log(p_t)

本质上：

让正确的下一个 Token 获得更高概率。

51. Transformer 为什么如此成功？

可以归纳成五个原因。

第一：Attention

解决长距离依赖。

第二：高度并行

适合：

GPU
TPU
Distributed Training

第三：可扩展

可以通过增加：

Layers
Hidden Size
Attention Heads
Training Data
Parameters

持续扩大模型。

第四：统一架构

文本：

Token

图片：

Patch

音频：

Audio Token

代码：

Code Token

本质上都可以转化成：

Embedding Sequence

然后交给 Transformer。

第五：Scaling Law

Transformer 与大规模：

Data
Compute
Parameters

结合后表现出非常强的 Scaling 能力。

这为今天的：

Foundation Model
LLM
Multimodal Model
Agent

奠定了基础。

52. 从 RNN 到 Transformer 的真正技术演进

可以把整个过程理解成：

RNN
 │
 │ 解决序列建模
 ↓
LSTM
 │
 │ 解决长期记忆
 ↓
Attention
 │
 │ 解决信息瓶颈
 ↓
Transformer
 │
 │ 解决并行计算与大规模训练
 ↓
GPT / BERT / T5
 │
 │ 模型规模扩大
 ↓
LLM
 │
 │ Tool / Memory / Multimodal
 ↓
Agent

因此学习 Transformer 时，不应该只记：

Q
K
V

真正应该理解的是：

Transformer 为什么出现？

答案是：

RNN 的顺序计算
 +
长期依赖问题
 +
信息压缩瓶颈
 ↓
Attention
 ↓
Transformer

53. AI 工程师学习 Transformer 的正确层次

如果目标是从传统后端工程进入：

AI Engineer
LLM Engineer
Agent Engineer

建议分四层掌握。

Level 1：原理

必须理解：

Embedding
Attention
Q/K/V
Softmax
Multi-Head Attention
Residual
LayerNorm
FFN
Position Encoding

Level 2：模型

理解：

Encoder
Decoder
BERT
GPT
T5
RoPE
RMSNorm
SwiGLU
GQA
MoE

Level 3：推理

重点学习：

KV Cache
Batching
Continuous Batching
FlashAttention
Quantization
Tensor Parallel
Pipeline Parallel
Speculative Decoding

Level 4：AI Systems

进一步进入：

LLM Serving
Model Gateway
Prompt Management
RAG
Vector Database
Tool Calling
Agent
Memory
Observability
Evaluation

最终形成：

 AI Application
 │
 ┌────┴────┐
 ↓ ↓
 RAG Agent
 │ │
 └────┬────┘
 ↓
 LLM
 ↓
 Transformer
 ↓
 GPU / Distributed System

54. 最终总结

Transformer 最核心的思想可以浓缩成一句话：

让序列中的每一个 Token 能够动态地选择自己应该关注的信息。

它通过：

Embedding
 ↓
Position
 ↓
Q/K/V
 ↓
Self-Attention
 ↓
Multi-Head Attention
 ↓
Residual + Norm
 ↓
FFN
 ↓
Transformer Blocks
 ↓
Logits
 ↓
Next Token

构成现代 LLM 的基本计算框架。

如果 RNN 的核心是：

State

那么 Transformer 的核心就是：

Attention

如果进一步看现代 LLM：

Attention
+
FFN
+
Residual
+
Normalization
+
Position Encoding
+
Scaling
+
KV Cache
+
GPU Optimization
+
Distributed Training

共同构成了今天的大模型技术栈。

而对于 AI Engineer 来说，最重要的认知不是：

“Transformer 是一个很复杂的神经网络。”

而应该是：

Transformer 是一种高度可并行、可扩展的序列信息处理架构；Attention 负责信息路由，FFN 负责特征变换，Residual/Normalization 保证深层训练稳定，而 KV Cache、FlashAttention、GQA、MoE 等技术则把它从一个论文模型逐渐演化成了今天能够支撑大规模 LLM 的工业级计算系统。

从 RNN 到 Transformer，再到 LLM 和 Agent，这实际上是一条非常完整的 AI 技术演进主线。

你下一步更适合深入 ① Attention/Transformer 手写源码、② GPT/LLM 内部架构，还是 ③ KV Cache + FlashAttention + LLM 推理系统？