v2rayN#

• 选择“添加订阅”或“从剪贴板导入”
• 粘贴后台生成的订阅链接
• 更新订阅后选择节点使用

Clash Verge / Clash Meta#

• 添加远程订阅
• 粘贴订阅 URL
• 更新配置并启用代理

sing-box#

• 导入订阅
• 同步配置后选择可用节点

1. 后台打不开怎么办？#

优先检查下面几项：

• 自定义域名是否已经生效
• ADMIN 环境变量是否添加成功
• 环境变量添加后是否重新部署
• 域名是否确实绑定到了当前 Pages 项目

2. 后台能打开，但保存配置失败怎么办？#

大多数情况下是 KV 绑定没配对。请重点检查：

• 是否已经创建 KV 命名空间
• 变量名是不是严格写成 KV
• 添加绑定后是否重新部署

3. 自定义域名访问失败怎么办？#

通常是 DNS 问题。重点检查：

• CNAME 是否填写正确
• 域名是否已接入 Cloudflare
• DNS 记录是否还在传播中

4. 为什么面板部署成功了，但代理还是不好用？#

这种情况通常不是 Pages 部署失败，而是节点参数、订阅格式或客户端配置有问题。建议先用仓库默认推荐参数跑通，再慢慢折腾高级配置，比如 ProxyIP、优选订阅或链式代理。

优点#

• 不需要购买 VPS
• 部署成本极低
• Cloudflare 平台可用性较好
• 有后台管理面板，维护方便
• 支持主流客户端订阅导入

限制#

• 依赖第三方开源项目维护
• 免费域名稳定性一般
• 高级配置对新手不够友好
• Cloudflare 的平台策略变化，可能影响长期使用体验

方式 1：一键脚本安装（推荐）#

1
# 海外服务器
2
bash <(curl -fsSL https://raw.githubusercontent.com/haierkeys/fast-note-sync-service/master/scripts/quest_install.sh)
3

4
# 国内服务器（腾讯云 CNB 镜像，速度快）
5
bash <(curl -fsSL https://cnb.cool/haierkeys/fast-note-sync-service/-/git/raw/master/scripts/quest_install.sh) --cnb

脚本自动完成：

• 下载对应系统的二进制文件到 /opt/fast-note
• 创建全局快捷命令 fns（位于 /usr/local/bin/fns）
• 注册 Systemd/Linux 或 Launchd/macOS 服务并设置开机自启
• 进入交互式菜单，支持安装/升级/启停/切换镜像源

方式 2：Docker 部署#

1
# 拉取镜像
2
docker pull haierkeys/fast-note-sync-service:latest
3

4
# 启动容器
5
docker run -tid --name fast-note-sync-service \
6
    -p 9000:9000 \
7
    -v /data/fast-note-sync/storage/:/fast-note-sync/storage/ \
8
    -v /data/fast-note-sync/config/:/fast-note-sync/config/ \
9
    haierkeys/fast-note-sync-service:latest

或用 docker-compose：

1
version: '3'
2
services:
3
  fast-note-sync-service:
4
    image: haierkeys/fast-note-sync-service:latest
5
    container_name: fast-note-sync-service
6
    restart: always
7
    ports:
8
      - "9000:9000"
9
    volumes:
10
      - ./storage:/fast-note-sync/storage
11
      - ./config:/fast-note-sync/config

1
docker compose up -d

1. 放行本地防火墙（ufw）#

安装脚本不会自动放行 ufw，这是最常见的”服务启动但端口不通”原因：

1
ufw allow 9000/tcp
2
ufw reload

2. 放行云服务器安全组#

登录云厂商控制台（阿里云/腾讯云/百度云/AWS），在安全组入方向添加：

• 协议：TCP
• 端口：9000
• 源地址：0.0.0.0/0

3. 修改默认 Token 密钥#

启动日志会提示：

1
WARN  Using default secret key - please change security.auth-token-key

生成安全密钥并修改配置：

1
openssl rand -base64 32

编辑 /opt/fast-note/config/config.yaml（一键脚本）或挂载的 ./config/config.yaml（Docker）：

1
security:
2
    auth-token-key: "你生成的64位密钥"

重启服务生效。

常用命令#

1
fns status    # 查看服务状态
2
fns start     # 启动
3
fns stop      # 停止
4
fns update    # 升级到最新版
5
fns menu      # 进入交互式菜单（安装/升级/启停/切换镜像）

关于 systemctl#

新版本 fns 脚本安装时会自动注册 Systemd 服务，因此也可以用 systemctl 管理：

1
systemctl status fast-note
2
systemctl start fast-note
3
systemctl stop fast-note

旧版本（v2.x 及之前）依赖交互菜单重启，当前版本已支持 systemctl 直接管理。

前置条件#

• 已安装 Nginx Proxy Manager（Docker 部署）
• 域名 DNS 已解析到服务器公网 IP
• NPM 容器与 FNS 在同一 Docker 网络或能访问宿主机

NPM 配置步骤#

1. 登录 NPM 后台（默认 http://服务器IP:81）
2. Proxy Hosts → Add Proxy Host

1. SSL 选项卡

   • SSL Certificate: Request a new SSL Certificate
   • Force SSL: 建议勾选（配合 Cloudflare Full 模式）
   • HTTP/2 Support: 勾选

2. Advanced 自定义配置

进入 Advanced → Custom Nginx Configuration，粘贴：

1
client_max_body_size 50m;
2
proxy_buffering off;
3
proxy_max_temp_file_size 0;
4
proxy_read_timeout 86400;
5
proxy_send_timeout 86400;

client_max_body_size 控制附件上传大小；proxy_buffering off 保证 WebSocket/大文件实时传输不缓冲。

1. 保存并测试

浏览器访问 https://notesync.yourdomain.com/webgui

通用请求头#

方式 A：StreamableHTTP（推荐）#

所有 MCP 客户端通用：

1
{
2
  "mcpServers": {
3
    "fns": {
4
      "url": "http://<IP>:9000/api/mcp",
5
      "type": "http",
6
      "headers": {
7
        "Authorization": "Bearer <Token>",
8
        "X-Default-Vault-Name": "<VaultName>"
9
      }
10
    }
11
  }
12
}

方式 B：SSE（向后兼容，适用于 Cherry Studio 等）#

1
{
2
  "mcpServers": {
3
    "fns": {
4
      "url": "http://<IP>:9000/api/mcp/sse",
5
      "type": "sse",
6
      "headers": {
7
        "Authorization": "Bearer <Token>",
8
        "X-Default-Vault-Name": "<VaultName>"
9
      }
10
    }
11
  }
12
}

1. 安装插件#

• 方式 A：Obsidian 社区插件市场搜索 Fast Note Sync
• 方式 B：手动下载 obsidian-fast-note-sync 最新 Release，解压到 .obsidian/plugins/obsidian-fast-note-sync/

2. 获取 API 配置#

1. 浏览器打开 FNS WebGUI：https://notesync.yourdomain.com/webgui
2. 首次使用需注册账号（第一个注册的账号即为管理员，UID 为 1）
3. 登录后，点击页面上的 “复制 API 配置”
4. 配置内容会自动复制到剪贴板：

1
{
2
  "serverUrl": "https://notesync.yourdomain.com",
3
  "token": "Bearer xxxxxxxx",
4
  "vault": "defaultVault"
5
}

3. 粘贴到 Obsidian 插件设置#

1. 打开 Obsidian → 设置 → 第三方插件 → Fast Note Sync
2. 将复制的 API 配置完整粘贴到输入框中
3. 插件自动解析 serverUrl、token、vault
4. 保存设置

4. 首次同步#

1. 在 Obsidian 中打开命令面板（Ctrl/Cmd + P）
2. 搜索 Fast Note Sync: 同步全部 或点击左侧栏的同步图标
3. 插件自动创建 Vault 并开始双向同步

5. 多设备同步#

在其他设备的 Obsidian 中重复上述步骤，使用同一套 API 配置即可。

数据库#

默认使用 SQLite，适合个人使用。如需 MySQL/PostgreSQL，修改 config.yaml：

1
database:
2
  type: mysql          # mysql | postgres | sqlite
3
  host: 127.0.0.1
4
  port: 3306
5
  username: fns
6
  password: "your-password"
7
  name: fast_note_sync

存储后端#

支持本地文件系统、阿里云 OSS、AWS S3、Cloudflare R2、MinIO、WebDAV：

1
storage:
2
  local-fs:
3
    is-enable: true
4
    httpfs-is-enable: true
5
    save-path: "storage/uploads"
6
  aliyun-oss:
7
    is-enable: false     # 设为 true 并配置 AccessKey 等

内网穿透#

FNS 原生支持 ngrok 和 Cloudflare Tunnel：

1
ngrok:
2
  enabled: true
3
  auth-token: "your-token"
4
  domain: "your-domain.ngrok.io"
5

6
cloudflare:
7
  enabled: true
8
  token: "your-tunnel-token"

Git 自动提交#

1
git:
2
  name: "FNS Service"
3
  email: "fns@email.com"

关闭注册（多用户场景）#

1
user:
2
  register-is-enable: false
3
  admin-uid: 1    # 指定管理员 UID

坑 1：服务启动但 9000 端口无法访问#

现象：fns status 显示运行中，但浏览器/curl 访问超时。
原因：ufw 或云安全组未放行 9000。
解决：

1
ufw allow 9000/tcp
2
# 同时检查云控制台安全组

坑 2：GitHub 支持文档下载超时#

现象：日志出现 Failed to fetch support records ... context deadline exceeded。
原因：服务器无法访问 raw.githubusercontent.com（国内常见）。
影响：仅影响 WebGUI 帮助文档加载，不影响核心同步功能。
解决：忽略或配置代理。

坑 3：修改 ext-api-url 后 IP 访问报错#

现象：ext-api-url 设为域名后，http://IP:9000/webgui 打开报错。
原因：前端强制向域名发起 API 请求，跨域或协议不匹配。
解决：

• 推荐（生产）：统一使用域名访问
• IP/域名共存：ext-api-url 和 share-base-url 留空 ""

坑 4：Cloudflare + NPM 导致 ERR_TOO_MANY_REDIRECTS#

现象：浏览器提示”重定向次数过多”。
原因：Cloudflare SSL 加密模式为 Flexible，回源 HTTP；NPM 开启 Force SSL 后检测到 HTTP 就 301 跳 HTTPS，死循环。
解决（二选一）：

坑 5：NPM 中 Forward IP 填 127.0.0.1 不通#

现象：NPM 返回 502 Bad Gateway。
原因：NPM 是 Docker 容器，127.0.0.1 指向容器自身。
解决：填写 Docker 网关 172.17.0.1，或宿主机内网 IP。

坑 6：SSL 证书申请失败（Cloudflare 代理开启时）#

原因：Cloudflare 橙色云拦截 HTTP-01 验证请求。
解决：

• 方案 A：申请证书时临时关闭 Cloudflare 代理（灰色云），申请完再开启
• 方案 B（推荐）：NPM 中用 DNS Challenge，Provider 选 Cloudflare，API Token 需 Zone:Read + DNS:Edit 权限

坑 7：大文件/附件同步失败或超时#

原因：NPM 默认 client_max_body_size 太小，或 proxy_buffering 开启。
解决：在 NPM Advanced 中加上：

1
client_max_body_size 50m;
2
proxy_buffering off;
3
proxy_max_temp_file_size 0;

坑 8：Obsidian 插件连接不上#

检查清单：

1. 服务器 9000 端口是否放行（ufw + 安全组）
2. 如使用域名，确认 ext-api-url 配置正确
3. 如使用 HTTPS，确认证书有效（非自签）
4. 如使用 Cloudflare，确认加密模式为 Full (strict)
5. 在 WebGUI 点击”复制 API 配置”，完整粘贴到插件设置
6. 确认 serverUrl 与浏览器访问地址一致（不混用 IP 和域名）

坑 9：Docker 部署的数据持久化#

现象：容器重启后数据丢失。
原因：未挂载 storage 和 config 卷。
解决：启动时务必通过 -v 或 volumes 挂载宿主机目录。

坑 10：国内服务器拉取 Docker 镜像慢#

解决：配置 Docker 镜像加速器（如阿里云加速器、中科大源）：

1
{
2
  "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
3
}

1.1 Tensor（张量）#

• 核心数据结构：类似于 NumPy 的 ndarray，但支持 GPU 加速和自动求导。

• 创建方式：

  1
  import torch
  2
  
  3
  # 从 Python 列表或 NumPy 数组创建
  4
  x = torch.tensor([1, 2, 3])
  5
  
  6
  # 创建特定值的张量
  7
  a = torch.zeros((2, 3))
  8
  b = torch.ones((2, 3))
  9
  c = torch.rand((2, 3))
  10
  d = torch.randn((2, 3))
  11
  
  12
  # 创建序列
  13
  r1 = torch.arange(0, 10, 2)
  14
  r2 = torch.linspace(0, 1, 5)
  15
  
  16
  # 创建单位矩阵
  17
  i = torch.eye(3)

  展开收起

• 属性：

  1
  x.dtype
  2
  x.shape
  3
  x.size()
  4
  x.device
  5
  x.requires_grad

• 操作：

  • 索引与切片：与 NumPy 类似。

  • 视图 (View) 与 复制 (Copy)：

    1
    y = x.view(-1)          # 返回一个新视图，共享底层数据（要求内存连续）
    2
    z = x.reshape(-1)       # 更灵活的形状变换，可能返回视图或副本
    3
    x_copy = x.clone()      # 返回数据的副本

  • 数学运算：

    1
    s = torch.sum(x)
    2
    m = torch.mean(x.float())
    3
    mx = torch.max(x)
    4
    e = torch.exp(x.float())
    5
    lg = torch.log(x.float())

  • 广播 (Broadcasting)：自动扩展张量以进行运算。

  • 类型转换：

    1
    xf = x.float()
    2
    xl = x.long()
    3
    x2 = x.to(dtype=torch.float32)

  • 设备转移：

    1
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    2
    x_gpu = x.to(device)
    3
    x_cpu = x_gpu.cpu()

1.2 自动求导（Autograd）#

• 核心机制：PyTorch 能自动计算张量的梯度。

• 关键属性：

  1
  import torch
  2
  
  3
  # requires_grad: 设置张量需要计算梯度（通常对模型参数设置）
  4
  w = torch.randn(10, requires_grad=True)
  5
  
  6
  # grad: 存储计算得到的梯度
  7
  w.grad
  8
  
  9
  # grad_fn: 指向创建该张量的 Function 对象，用于构建计算图
  10
  y = w * 2
  11
  y.grad_fn

• 基本流程：

  1
  import torch
  2
  
  3
  x = torch.randn(10)
  4
  w = torch.randn(10, requires_grad=True)
  5
  b = torch.randn(1, requires_grad=True)
  6
  
  7
  y = (x * w).sum() + b
  8
  loss = y
  9
  
  10
  loss.backward()
  11
  
  12
  with torch.no_grad():
  13
      w -= 0.01 * w.grad
  14
      b -= 0.01 * b.grad
  15
  
  16
  w.grad.zero_()
  17
  b.grad.zero_()

  展开收起

• 停止梯度：

  1
  import torch
  2
  
  3
  x = torch.randn(3, requires_grad=True)
  4
  
  5
  with torch.no_grad():
  6
      y = x * 2
  7
  
  8
  z = x.detach()
  9
  x.requires_grad_(False)

2.1 定义网络#

• 常见写法：

  1
  import torch
  2
  import torch.nn as nn
  3
  
  4
  class MyModel(nn.Module):
  5
      def __init__(self):
  6
          super().__init__()
  7
          self.net = nn.Sequential(
  8
              nn.Linear(10, 32),
  9
              nn.ReLU(),
  10
              nn.Linear(32, 10),
  11
          )
  12
  
  13
      def forward(self, x):
  14
          return self.net(x)

• 常用层：

  1
  import torch.nn as nn
  2
  
  3
  nn.Linear
  4
  nn.Conv2d
  5
  nn.MaxPool2d
  6
  nn.AvgPool2d
  7
  nn.BatchNorm1d
  8
  nn.BatchNorm2d
  9
  nn.BatchNorm3d
  10
  nn.Dropout
  11
  nn.Embedding
  12
  nn.LSTM
  13
  nn.GRU

• 激活函数：

  1
  import torch.nn as nn
  2
  
  3
  nn.ReLU
  4
  nn.Sigmoid
  5
  nn.Tanh
  6
  nn.Softmax

• 容器：

  1
  import torch.nn as nn
  2
  
  3
  nn.Sequential
  4
  nn.ModuleList
  5
  nn.ModuleDict

2.2 损失函数（Loss Functions）#

• 常用损失：

  1
  import torch.nn as nn
  2
  
  3
  nn.MSELoss                 # 回归
  4
  nn.CrossEntropyLoss        # 分类（输入 logits，内部会做 Softmax）
  5
  nn.BCELoss                 # 二元交叉熵（输入概率）
  6
  nn.BCEWithLogitsLoss       # Sigmoid + BCELoss，数值更稳定
  7
  nn.NLLLoss                 # 负对数似然（常与 LogSoftmax 配合）

• 使用：

  1
  loss = criterion(predicted_output, true_target)

2.3 优化器（Optimizers）#

• 作用：根据计算出的梯度更新模型参数。

• 常用优化器：

  1
  import torch
  2
  
  3
  torch.optim.SGD
  4
  torch.optim.Adam
  5
  torch.optim.RMSprop

• 基本使用流程：

  1
  optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
  2
  loss = criterion(outputs, labels)
  3
  
  4
  optimizer.zero_grad()
  5
  loss.backward()
  6
  optimizer.step()

3.1 Dataset#

• 抽象基类：

  1
  from torch.utils.data import Dataset

• 自定义数据集：

  1
  from torch.utils.data import Dataset
  2
  
  3
  class MyCustomDataset(Dataset):
  4
      def __len__(self):
  5
          return 0
  6
  
  7
      def __getitem__(self, idx):
  8
          return None

• 内置数据集：torchvision.datasets.MNIST/CIFAR10/ImageFolder 等。

  1
  import torchvision
  2
  
  3
  torchvision.datasets.MNIST
  4
  torchvision.datasets.CIFAR10
  5
  torchvision.datasets.ImageFolder

3.2 DataLoader#

• 作用：将数据集封装成可迭代对象，支持批量加载、打乱、多进程加载。

  1
  from torch.utils.data import DataLoader
  2
  
  3
  DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)

• 使用：

1
dataset = MyCustomDataset(...)
2
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)
3

4
for batch_data, batch_labels in dataloader:
5
    # 训练/验证逻辑
6
    pass

4.1 基本训练循环#

1
model.train()  # 设置为训练模式（影响 Dropout, BatchNorm 等层）
2
for epoch in range(num_epochs):
3
    for inputs, labels in train_loader:
4
        inputs, labels = inputs.to(device), labels.to(device)
5

6
        optimizer.zero_grad()  # 1. 清空梯度
7
        outputs = model(inputs)  # 2. 前向传播
8
        loss = criterion(outputs, labels)  # 3. 计算损失
9
        loss.backward()  # 4. 反向传播
10
        optimizer.step()  # 5. 更新参数
11

12
        # 可选：记录损失、准确率等

4.2 验证/测试循环#

1
model.eval()  # 设置为评估模式（关闭 Dropout, 固定 BatchNorm 统计量）
2
with torch.no_grad():  # 关闭梯度计算，节省内存和计算
3
    for inputs, labels in val_loader:
4
        inputs, labels = inputs.to(device), labels.to(device)
5
        outputs = model(inputs)
6
        loss = criterion(outputs, labels)
7
        # 计算准确率或其他指标
8
        # 记录验证损失和指标

7.1 TorchScript（模型部署）#

• 将 PyTorch 模型转换为可序列化的、独立于 Python 的中间表示，便于在 C++ 环境或生产环境中部署。

• 常用方式：

  1
  import torch
  2
  
  3
  torch.jit.trace(model, example_input)
  4
  torch.jit.script(model)

7.2 分布式训练#

• 常用方式：

  1
  import torch
  2
  
  3
  torch.nn.DataParallel
  4
  torch.nn.parallel.DistributedDataParallel

7.3 混合精度训练（AMP）#

• 常用工具：

  1
  import torch
  2
  
  3
  torch.cuda.amp.autocast
  4
  torch.cuda.amp.GradScaler

7.4 可视化与调试#

• TensorBoard：

  1
  from torch.utils.tensorboard import SummaryWriter

• 打印模型结构：

  1
  print(model)

• 结构摘要（需安装第三方包）：

  1
  summary(model, input_size)

1.1 生物视觉皮层启发#

CNN 的设计灵感来源于 1960 年代神经科学家 Hubel 和 Wiesel 对猫视觉皮层的研究：

• 简单细胞（Simple Cells）：只对特定位置、方向的边缘/条状刺激有反应 → 对应 CNN 的“卷积核”
• 复杂细胞（Complex Cells）：对某方向边缘有反应，但位置不敏感 → 对应“池化层”的平移不变性
• 层级结构：低级特征（边缘）→ 中级特征（形状）→ 高级特征（物体）→ 对应 CNN 的“层叠结构”

🧬 CNN 是对生物视觉系统的“工程化模拟”，不是完全复制，而是提取其核心思想：局部感受、层次抽象、权值共享 。

1.2 哲学思想：让机器“学会看”#

• 传统方法：人工设计特征（如SIFT、HOG）→ 费时费力，泛化差
• CNN 方法：端到端学习 ，从原始像素自动学习最优特征表示
• 核心哲学：Representation Learning（表示学习）

2.1 离散卷积公式（2D）#

对输入图像 I∈RH×WI \in \mathbb{R}^{H \times W}I∈RH×W 和卷积核 K∈Rk×kK \in \mathbb{R}^{k \times k} K∈Rk×k ，输出特征图 OOO 在位置 (i,j)(i,j)(i,j) 的值为：

O(i,j)=(I\*K)(i,j)=∑_m=0k−1∑_n=0k−1I(i+m,j+n)⋅K(m,n)O(i,j) = (I \* K)(i,j) = \sum\_{m=0}^{k-1} \sum\_{n=0}^{k-1} I(i+m, j+n) \cdot K(m,n)O(i,j)=(I\*K)(i,j)=∑_m=0k−1∑_n=0k−1I(i+m,j+n)⋅K(m,n)

注意：实际深度学习框架中多为“互相关（cross-correlation）”，即不翻转核，但习惯仍称“卷积”。

2.2 多通道输入/输出#

• 输入通道数：C_inC\_{in} C_in（如RGB=3）

• 输出通道数：C_out C\_{out}C_out（即卷积核个数）

• 每个卷积核尺寸：k×k×C_ink \times k \times C\_{in}k×k×C_in

• 总参数量：C_out×(k×k×C_in+1)C\_{out} \times (k \times k \times C\_{in} + 1)C_out×(k×k×C_in+1)（+1 是偏置项）

• ✅ 举例：

• 输入：224×224×3

• 卷积层：64个 3×3 卷积核

• 参数量 = 64×(3×3×3+1)=64×28=1,79264 \times (3 \times 3 \times 3 + 1) = 64 \times 28 = 1,79264×(3×3×3+1)=64×28=1,792

• 对比全连接：224×224×3×1000=150M224 \times 224 \times 3 \times 1000 = 150M224×224×3×1000=150M→ CNN 参数效率极高！

2.3 输出尺寸计算公式#

给定：

• 输入尺寸：W_in×H_inW\_{in} \times H\_{in}W_in×H_in
• 卷积核尺寸：KKK
• 步长：SSS
• 填充：PPP

输出尺寸：

W_out=⌊W_in+2P−KS⌋+1W\_{out} = \left\lfloor \frac{W\_{in} + 2P - K}{S} \right\rfloor + 1W_out=⌊SW_in+2P−K​⌋+1

📌 常用设置：K=3, S=1, P=1 → 尺寸不变；K=3, S=2, P=1 → 尺寸减半

3.1 卷积层（Conv Layer）——不止是“滑动窗口”#

3.2 激活函数 —— 为什么ReLU是王者？#

3.3 池化层 —— 为什么Max Pooling最常用？#

3.4 批归一化（Batch Normalization, BN）——训练加速神器#

3.5 全连接层与Softmax —— 最后的决策者#

4.1 数据预处理#

• 归一化：像素值 /255.0 → [0,1] 或 标准化 (x−mean)/std(x - mean)/std(x−mean)/std
• 数据增强（Data Augmentation）：
  • 随机裁剪、旋转、翻转、色彩抖动、CutMix、MixUp
  • 本质：增加数据多样性，提升泛化，防过拟合

4.2 优化器选择#

🚀 实践建议：新手用 Adam (lr=0.001) ，高手可尝试 SGD + Momentum + 学习率衰减

4.3 正则化技术#

• L2权重衰减（Weight Decay）：损失函数加 λ∥θ∥2\lambda \|\theta\|^2λ∥θ∥2
• Dropout：训练时随机丢弃神经元（通常FC层用，rate=0.5）
• Early Stopping：验证集loss不再下降时停止
• Label Smoothing：软化one-hot标签，防过自信

5.1 LeNet-5 (1998) —— 开山鼻祖#

INPUT → Conv1 → Pool1 → Conv2 → Pool2 → FC1 → FC2 → OUTPUT

• 用于手写数字识别（MNIST）
• 首次证明CNN可行性

5.2 AlexNet (2012) —— 深度学习革命#

• 8层（5Conv + 3FC）
• 首次使用ReLU、Dropout
• 数据增强 + GPU训练
• ImageNet Top-5错误率从26%→15.3%

5.3 VGGNet (2014) —— 简洁之美#

• 核心：统一使用3×3小卷积核堆叠
• 感受野等价于一个大核，但参数更少
• VGG16：13Conv + 3FC = 16层
• 至今仍被用作特征提取器（如风格迁移）

5.4 GoogLeNet / Inception (2014) —— 多尺度融合#

• Inception模块：并行使用1×1, 3×3, 5×5卷积 + Pooling → 捕捉多尺度特征
• 1×1卷积：降维/升维，减少计算量（“瓶颈层”）
• 22层，参数比AlexNet少12倍

5.5 ResNet (2015) —— 突破深度极限#

• 残差块（Residual Block）： y=F(x)+xy = F(x) + xy=F(x)+x
• 解决“网络退化”问题（深层网络训练误差反而上升）
• 可训练超1000层网络（ResNet-152常用）
• 核心思想：让网络学习残差（变化量），而非直接映射

🏆 ResNet是现代CNN的基石，几乎所有新模型都受其影响。

5.6 EfficientNet (2019) —— 平衡的艺术#

• 提出复合缩放（Compound Scaling） ：同时缩放网络深度（d）、宽度（w）、分辨率（r）
• 公式：d=αϕ,w=βϕ,r=γϕd = \alpha^\phi, w = \beta^\phi, r = \gamma^\phid=αϕ,w=βϕ,r=γϕ，约束 α⋅β2⋅γ2≈2\alpha \cdot \beta^2 \cdot \gamma^2 \approx 2α⋅β2⋅γ2≈2
• 在相同计算量下达到SOTA精度

6.1 图像分类 → ResNet, EfficientNet, Vision Transformer#

6.2 目标检测#

6.3 语义分割#

• FCN（全卷积网络）：将FC层替换为卷积，输出像素级预测
• U-Net：编码器-解码器结构 + 跳跃连接（医学图像标配）
• DeepLab系列：空洞卷积 + ASPP（多尺度上下文）

6.4 姿态估计#

• OpenPose：多阶段CNN，同时预测关键点和连接
• HRNet：保持高分辨率特征，精度更高

6.5 医学影像#

• nnU-Net：自动适配任何医学分割任务的框架
• CheXNet：121层DenseNet，用于胸部X光肺炎检测

6.6 视频理解#

• 3D CNN（如C3D）：卷积核扩展到时间维
• Two-Stream Network：RGB流 + 光流流
• I3D（Inflated 3D ConvNet）：将2D卷积核“膨胀”为3D

7.1 CNN vs Transformer#

• Vision Transformer (ViT)：将图像分块，用Transformer编码 → 在大数据下超越CNN
• 混合模型：CNN提取局部特征 + Transformer建模长程依赖（如Swin Transformer）
• 趋势：CNN不会消失，但与Attention机制深度融合

7.2 轻量化CNN#

• MobileNet系列：深度可分离卷积
• ShuffleNet：通道混洗减少计算
• GhostNet：用廉价操作生成“幻影”特征图

7.3 自监督学习#

• MoCo, SimCLR：无标签数据预训练CNN，再微调
• 减少对标注数据的依赖

7.4 可解释性与可视化#

• CAM / Grad-CAM：可视化CNN关注区域
• 特征反演：从特征图重建输入图像

8.1 学习路线图#

数学基础 → Python/PyTorch → CNN理论 → 经典论文 → 复现项目 → 参加比赛（Kaggle）→ 研究前沿

8.2 书籍推荐#

• 《深度学习》（花书）Ian Goodfellow — 理论基石
• 《动手学深度学习》（李沐）— 代码实践神器（有PyTorch版）
• 《神经网络与深度学习》（邱锡鹏）— 中文精品

8.3 视频课程#

• 吴恩达《Deep Learning Specialization》（Coursera）
• 李沐《动手学深度学习》B站课程
• 斯坦福CS231n（YouTube）— CNN圣经级课程

8.4 实战平台#

• Kaggle：大量图像比赛（入门推荐：Digit Recognizer, Dogs vs Cats）
• Google Colab：免费GPU，开箱即用
• Hugging Face：预训练模型库（含CNN）

9.1 数据加载与增强#

1
import torch
2
import torch.nn as nn
3
import torch.optim as optim
4
from torchvision import datasets, transforms
5

6
transform = transforms.Compose([
7
    transforms.Resize((32, 32)),
8
    transforms.ToTensor(),
9
    transforms.Normalize((0.5,), (0.5,))
10
])
11

12
trainset = datasets.CIFAR10(root="./data", train=True, download=True, transform=transform)
13
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

9.2 定义带BN和Dropout的CNN#

1
class CNN(nn.Module):
2
    def __init__(self):
3
        super().__init__()
4
        self.features = nn.Sequential(
5
            nn.Conv2d(3, 32, 3, padding=1),
6
            nn.BatchNorm2d(32),
7
            nn.ReLU(),
8
            nn.MaxPool2d(2),
9
            nn.Conv2d(32, 64, 3, padding=1),
10
            nn.BatchNorm2d(64),
11
            nn.ReLU(),
12
            nn.MaxPool2d(2),
13
            nn.Conv2d(64, 128, 3, padding=1),
14
            nn.BatchNorm2d(128),
15
            nn.ReLU(),
16
            nn.AdaptiveAvgPool2d((1, 1)),
17
        )
18
        self.classifier = nn.Sequential(
19
            nn.Dropout(0.5),
20
            nn.Linear(128, 10),
21
        )
22

23
    def forward(self, x):
24
        x = self.features(x)
25
        x = torch.flatten(x, 1)
26
        x = self.classifier(x)
27
        return x

9.3 训练循环#

1
model = CNN().cuda()
2
criterion = nn.CrossEntropyLoss()
3
optimizer = optim.Adam(model.parameters(), lr=0.001)
4

5
for epoch in range(10):
6
    for inputs, labels in trainloader:
7
        inputs, labels = inputs.cuda(), labels.cuda()
8
        optimizer.zero_grad()
9
        outputs = model(inputs)
10
        loss = criterion(outputs, labels)
11
        loss.backward()
12
        optimizer.step()
13
    print(f"Epoch {epoch + 1}, Loss: {loss.item():.4f}")