fix: 修正附录目录嵌套，移除旧 officefile 附录文件

- 将 officefile/appendix/appendix/ 下的文件提升一级 - 旧 officefile 的 glossary/references/tools.md 移入 Archive Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-25 14:02:01 +08:00
parent 219232de74
commit 49ceadeb0d
12 changed files with 0 additions and 573 deletions
@@ -0,0 +1,863 @@
+# 附录1：计算机基础与编程环境
+
+本附录介绍计算机的基本构成、操作系统常见操作、程序设计语言的概念、Python编程语言的系统学习指南，以及机器学习与深度学习的实践入门。
+
+## 1 计算机的基本构成与操作系统常见操作
+
+### 1.1 计算机基本构成
+
+了解计算机的基本组成有助于理解AI程序运行时的资源需求。
+
+| 组件 | 作用 | AI相关说明 |
+|------|------|-----------|
+| CPU | 中央处理器，执行指令 | 数据预处理、逻辑控制 |
+| GPU | 图形处理器，并行计算 | 深度学习训练与推理的核心硬件 |
+| 内存（RAM） | 临时存储运行中的数据 | 影响能处理的批量大小和数据规模 |
+| 硬盘（SSD/HDD） | 持久化存储数据 | 模型文件、数据集的存储 |
+| 网络 | 数据传输 | 下载模型、调用云端API |
+
+### 1.2 操作系统常见操作
+
+本书以 macOS/Linux 为主要环境，Windows 用户推荐使用 WSL2（Windows Subsystem for Linux）。
+
+**文件与目录操作**：
+
+```bash
+# 查看当前路径
+pwd
+
+# 列出文件
+ls -la
+
+# 创建目录
+mkdir my_project
+
+# 切换目录
+cd my_project
+
+# 复制、移动、删除
+cp file.txt backup.txt
+mv old.txt new.txt
+rm unwanted.txt
+```
+
+**环境与进程管理**：
+
+```bash
+# 查看系统资源
+top              # CPU和内存使用
+df -h            # 磁盘空间
+nvidia-smi       # GPU状态（NVIDIA显卡）
+
+# 包管理
+brew install xxx   # macOS Homebrew
+apt install xxx    # Ubuntu/Debian
+```
+
+### 1.3 硬件资源推荐
+
+**本地GPU配置**： - GPU：RTX 3060 (12GB) 或更高 - 内存：16GB+ - 存储：至少100GB SSD
+
+**云平台**：
+
+| 平台 | 特点 | 适合场景 |
+|------|------|---------|
+| Google Colab | 免费GPU | 学习实验 |
+| Kaggle Notebooks | 免费GPU | 竞赛 |
+| AutoDL | 按时计费 | 中期项目 |
+| 阿里云PAI | 国内稳定 | 生产部署 |
+
+### 1.4 软件安装与运行
+**"安装"的本质就是**：把编译好的二进制文件放到 PATH 某个目录下，让 shell 能找到它。例如git的安装和使用：
+**总结：三层抽象**
+
+```text
+┌─────────────────────────────────────────────┐
+│  用户层：brew install git / git clone        │  ← 你看到的
+├─────────────────────────────────────────────┤
+│  Shell 层：搜索 PATH → execve() 加载二进制   │  ← 为什么能找到命令
+├─────────────────────────────────────────────┤
+│  OS 层：系统调用 (open/read/write/socket)    │  ← 为什么能真正干活
+├─────────────────────────────────────────────┤
+│  硬件层：CPU 执行指令、网卡收发数据、磁盘写入  │  ← 物理上发生了什么
+└─────────────────────────────────────────────┘
+```
+
+  所以整个链条是：**包管理器下载编译好的二进制 → 放到 PATH 目录 → shell 通过 PATH 找到它 → execve 加载到内存 →**
+
+   **二进制内部调用 OS API 完成实际工作**。没有任何"魔法"，本质上就是文件操作和进程管理的组合。
+
+
+## 2 程序设计语言与软件开发
+
+### 2.1 什么是程序设计语言
+
+计算机只能执行由0和1组成的**机器码**（machine code），但人类直接阅读和编写机器码极其困难。程序设计语言就是人与计算机之间的桥梁——用人类可读的语法表达逻辑，再通过特定工具转换为机器可执行的指令。
+
+从底层到高层的演进：
+
+| 层级 | 语言示例 | 特点 |
+|------|---------|------|
+| 机器码 | 二进制 `01101000` | 计算机直接执行，人类不可读 |
+| 汇编语言 | `MOV AX, 1` | 与机器码一一对应，可读性低 |
+| 低级语言 | C | 接近硬件，性能高，需要手动管理内存 |
+| 高级语言 | Python, Java, JavaScript | 接近自然语言，开发效率高 |
+
+### 2.2 编译型与解释型语言
+
+高级语言需要转换为机器码才能运行，根据转换方式的不同，分为两大类：
+
+**编译型语言（Compiled）**：程序编写完成后，通过编译器一次性将全部代码翻译成机器码，生成可执行文件。
+
+```
+源代码 → 编译器 → 可执行文件 → 运行
+```
+
+- **C/C++**：系统级开发、高性能计算、游戏引擎
+- **Go**：云服务、容器工具（Docker 即用 Go 编写）
+- **Rust**：系统编程，兼顾性能与安全
+
+特点：运行速度快，但每次修改代码都需要重新编译。
+
+**解释型语言（Interpreted）**：程序运行时，由解释器逐行读取代码并即时执行，不需要预先编译。
+
+```
+源代码 → 解释器逐行执行
+```
+
+- **Python**：AI/数据科学的首选语言
+- **JavaScript**：网页交互、前端开发
+- **Ruby**：Web开发（Ruby on Rails）
+
+特点：开发灵活、调试方便，但运行速度通常慢于编译型语言。
+
+**混合模式**：Java 采用"编译为字节码 → 虚拟机解释执行"的混合方式，兼顾了跨平台和性能。
+
+### 2.3 常见编程语言概览
+
+| 语言 | 类型 | 主要用途 | 与AI/设计的关系 |
+|------|------|---------|---------------|
+| Python | 解释型 | AI、数据科学、自动化 | 本书主要编程语言 |
+| C/C++ | 编译型 | 操作系统、嵌入式、高性能计算 | 深度学习框架的底层实现 |
+| Java | 混合型 | 企业应用、Android开发 | 大数据处理（Hadoop/Spark） |
+| JavaScript | 解释型 | 网页前端、Node.js后端 | Web可视化、交互设计 |
+| Shell/Bash | 解释型 | 命令行脚本、系统管理 | 自动化任务、环境管理 |
+| SQL | 声明式 | 数据库查询 | 数据管理与提取 |
+
+**命令行界面（CLI）**：CLI（Command Line Interface）是通过文本命令与计算机交互的方式。终端中输入的每一条命令（如 `ls`、`git commit`）本质上都是调用某个程序。掌握 CLI 是进行AI开发的基础技能，许多工具（如 conda、pip、git）主要通过命令行操作。
+
+### 2.4 软件开发基本概念
+
+| 概念 | 英文 | 说明 |
+|------|------|------|
+| 集成开发环境 | IDE | 集成代码编辑、调试、运行的开发工具（如 VS Code、PyCharm） |
+| 编译器 | Compiler | 将源代码翻译为机器码的程序 |
+| 解释器 | Interpreter | 逐行读取并执行源代码的程序 |
+| 调试器 | Debugger | 帮助定位和修复代码错误的工具 |
+| 包管理器 | Package Manager | 管理第三方库的安装和更新（如 pip、conda、npm） |
+| API | Application Programming Interface | 程序之间交互的接口（如调用AI模型的API） |
+| 开源 | Open Source | 源代码公开，可自由使用和修改 |
+| 版本控制 | Version Control | 管理代码的修改历史（如 Git） |
+
+### 2.5 Python环境配置
+
+Python是本书使用的核心编程语言，以下介绍环境搭建方法。
+
+#### Anaconda vs Miniconda
+
+| 工具 | 大小 | 特点 | 下载地址 |
+|------|------|------|---------|
+| Anaconda | ~500MB | 预装常用库 | [anaconda.com](https://www.anaconda.com/download) |
+| Miniconda | ~50MB | 精简安装 | [docs.conda.io](https://docs.conda.io/en/latest/miniconda.html) |
+
+#### 安装步骤
+
+```bash
+# 1. 下载并安装 Anaconda 或 Miniconda
+
+# 2. 创建虚拟环境
+conda create -n ai-env python=3.10
+conda activate ai-env
+
+# 3. 安装核心科学计算库
+conda install numpy pandas scipy
+
+# 4. 安装深度学习框架
+pip install torch torchvision
+```
+
+## 3 Python编程语言
+
+### 3.1 Python概述与特点
+
+Python由Guido van Rossum于1991年发布，以"优雅""简洁""可读性强"为设计哲学。它是当前AI和数据科学领域使用最广泛的编程语言。
+
+**核心特点**：
+- 语法简洁，接近自然语言，入门门槛低
+- 丰富的第三方库生态（AI、数据处理、Web等）
+- 跨平台运行（Windows、macOS、Linux）
+- 活跃的开源社区支持
+
+### 3.2 基础语法
+
+#### 变量与数据类型
+
+```python
+# 变量赋值（无需声明类型）
+name = "设计人工智能"       # 字符串 str
+version = 1.0               # 浮点数 float
+chapter_count = 26           # 整数 int
+is_published = True          # 布尔值 bool
+
+# 查看类型
+print(type(name))            # <class 'str'>
+```
+
+#### 字符串操作
+
+```python
+title = "设计人工智能"
+
+# 字符串拼接
+full_title = title + "：基础与应用"
+
+# 格式化输出
+print(f"本书名为《{full_title}》，共{chapter_count}章")
+
+# 常用方法
+print(title.lower())          # 设小写
+print(title.replace("人工智能", "AI"))  # 替换
+print(len(title))             # 长度
+```
+
+#### 注释
+
+```python
+# 这是单行注释
+
+"""
+这是多行注释（文档字符串）
+常用于函数和类的说明
+"""
+
+# 好的注释解释"为什么"，而不是"做什么"
+```
+
+### 3.3 数据结构
+
+#### 列表（List）
+
+有序、可变的序列，最常用的数据结构。
+
+```python
+# 创建列表
+models = ["CNN", "RNN", "Transformer", "Diffusion"]
+
+# 访问元素（索引从0开始）
+print(models[0])              # CNN
+print(models[-1])             # Diffusion（倒数第一个）
+
+# 修改
+models.append("GAN")          # 添加元素
+models.remove("RNN")          # 删除元素
+models.sort()                 # 排序
+
+# 切片
+print(models[1:3])            # 第2到第3个元素
+```
+
+#### 字典（Dictionary）
+
+键值对结构，用于存储映射关系。
+
+```python
+# 创建字典
+model_info = {
+    "name": "ResNet",
+    "year": 2015,
+    "layers": 152,
+    "task": "图像分类"
+}
+
+# 访问
+print(model_info["name"])     # ResNet
+
+# 添加/修改
+model_info["accuracy"] = 0.96
+
+# 遍历
+for key, value in model_info.items():
+    print(f"{key}: {value}")
+```
+
+#### 元组（Tuple）
+
+有序、不可变的序列，适合存储不变的数据。
+
+```python
+# 创建元组
+rgb = (255, 128, 0)
+
+# 解包
+r, g, b = rgb
+```
+
+#### 集合（Set）
+
+无序、不重复的元素集合。
+
+```python
+tools_a = {"Photoshop", "Figma", "Sketch"}
+tools_b = {"Figma", "Blender", "Rhino"}
+
+# 集合运算
+print(tools_a & tools_b)      # 交集: {"Figma"}
+print(tools_a | tools_b)      # 并集
+```
+
+### 3.4 控制流
+
+#### 条件判断
+
+```python
+loss = 0.05
+
+if loss < 0.01:
+    print("模型收敛良好")
+elif loss < 0.1:
+    print("模型基本收敛")
+else:
+    print("模型需要继续训练")
+```
+
+#### 循环
+
+```python
+# for 循环
+epochs = [1, 2, 3, 4, 5]
+for epoch in epochs:
+    print(f"训练第 {epoch} 轮")
+
+# range 生成序列
+for i in range(10):
+    print(f"第{i}次迭代")
+
+# while 循环
+loss = 1.0
+while loss > 0.01:
+    loss = loss * 0.9    # 模拟训练过程
+```
+
+#### 列表推导式
+
+简洁地创建新列表：
+
+```python
+# 传统写法
+squares = []
+for x in range(10):
+    squares.append(x ** 2)
+
+# 列表推导式（推荐）
+squares = [x ** 2 for x in range(10)]
+
+# 带条件过滤
+even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
+```
+
+### 3.5 函数与模块
+
+#### 定义函数
+
+```python
+def calculate_accuracy(correct, total):
+    """计算准确率"""
+    return correct / total
+
+# 调用函数
+acc = calculate_accuracy(95, 100)
+print(f"准确率: {acc:.2%}")
+```
+
+#### 默认参数与关键字参数
+
+```python
+def train_model(epochs, lr=0.001, optimizer="Adam"):
+    print(f"训练 {epochs} 轮, 学习率={lr}, 优化器={optimizer}")
+
+# 多种调用方式
+train_model(100)
+train_model(100, lr=0.01)
+train_model(100, optimizer="SGD", lr=0.1)
+```
+
+#### 导入模块
+
+```python
+# 导入标准库
+import os
+import json
+
+# 导入第三方库
+import numpy as np
+import pandas as pd
+
+# 从模块中导入特定功能
+from pathlib import Path
+from collections import Counter
+
+# 安装第三方库（在终端中执行）
+# pip install numpy pandas matplotlib
+```
+
+### 3.6 文件读写
+
+```python
+# 读取文件
+with open("data.txt", "r", encoding="utf-8") as f:
+    content = f.read()
+
+# 逐行读取
+with open("data.csv", "r", encoding="utf-8") as f:
+    for line in f:
+        print(line.strip())
+
+# 写入文件
+with open("output.txt", "w", encoding="utf-8") as f:
+    f.write("分析结果\n")
+    f.write(f"准确率: {acc:.4f}\n")
+
+# 读写JSON（AI应用中常用的数据格式）
+import json
+
+data = {"model": "ResNet", "accuracy": 0.96}
+
+# 写入JSON
+with open("result.json", "w") as f:
+    json.dump(data, f, indent=2)
+
+# 读取JSON
+with open("result.json", "r") as f:
+    loaded = json.load(f)
+```
+
+### 3.7 面向对象编程基础
+
+面向对象编程（OOP）是Python的重要范式，许多AI库都基于OOP设计。
+
+```python
+class NeuralNetwork:
+    """简单的神经网络类"""
+
+    def __init__(self, input_size, hidden_size, output_size):
+        """初始化网络结构"""
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.loss_history = []
+
+    def forward(self, x):
+        """前向传播"""
+        # 这里简化为概念演示
+        return f"输出: 输入{x}经过{self.hidden_size}个隐藏层神经元"
+
+    def train(self, data, epochs=10):
+        """训练网络"""
+        for epoch in range(epochs):
+            loss = 1.0 / (epoch + 1)  # 模拟损失下降
+            self.loss_history.append(loss)
+            print(f"Epoch {epoch+1}, Loss: {loss:.4f}")
+
+# 创建实例
+model = NeuralNetwork(input_size=784, hidden_size=128, output_size=10)
+
+# 使用
+output = model.forward([0.5, 0.3, 0.8])
+model.train(data=None, epochs=5)
+```
+
+### 3.8 核心科学计算库
+
+#### NumPy：数值计算基础
+
+```python
+import numpy as np
+
+# 创建数组
+x = np.array([1, 2, 3, 4])
+
+# 矩阵运算
+W = np.random.randn(4, 3)  # 4×3 权重矩阵
+h = np.dot(x, W)            # 矩阵乘法
+
+# 激活函数
+relu = np.maximum(0, h)     # ReLU
+
+# 统计运算
+print(np.mean(x))            # 均值
+print(np.std(x))             # 标准差
+print(np.max(x))             # 最大值
+```
+
+#### Pandas：数据处理
+
+```python
+import pandas as pd
+
+# 读取数据
+df = pd.read_csv('data.csv')
+
+# 查看数据
+print(df.head())             # 前几行
+print(df.shape)              # 行数和列数
+print(df.columns)            # 列名
+
+# 数据清洗
+df = df.dropna()             # 删除缺失值
+
+# 统计分析
+print(df.describe())         # 描述性统计
+
+# 筛选数据
+filtered = df[df['accuracy'] > 0.9]
+```
+
+#### Matplotlib：数据可视化
+
+```python
+import matplotlib.pyplot as plt
+
+# 折线图：训练损失曲线
+epochs = [1, 2, 3, 4, 5]
+losses = [0.8, 0.5, 0.3, 0.15, 0.08]
+
+plt.plot(epochs, losses, 'b-o')
+plt.xlabel('Epoch')
+plt.ylabel('Loss')
+plt.title('Training Loss Curve')
+plt.savefig('loss_curve.png', dpi=150)
+plt.show()
+```
+
+### 3.9 深度学习框架
+
+#### PyTorch
+
+```bash
+pip install torch torchvision torchaudio
+```
+
+**特点**： - 动态计算图 - 研究友好 - 广泛的社区支持
+
+**资源**： - [官方文档](https://pytorch.org/docs/) - [中文教程](https://pytorch.zhangxiann.com/)
+
+#### TensorFlow
+
+```bash
+pip install tensorflow
+```
+
+**特点**： - 生产部署优化 - Keras高级API - 跨平台支持
+
+### 3.10 AI工具库速查与模型资源
+
+#### 工具库速查
+
+| 类别 | 工具 | 安装命令 | 功能 |
+|------|------|---------|------|
+| 计算机视觉 | OpenCV | `pip install opencv-python` | 图像处理、视频分析 |
+| 目标检测 | Ultralytics | `pip install ultralytics` | YOLO目标检测、实例分割 |
+| 图像生成 | Diffusers | `pip install diffusers` | Stable Diffusion模型调用 |
+| Agent开发 | LangChain | `pip install langchain langchain-openai` | LLM应用开发框架 |
+| Agent开发 | LangGraph | `pip install langgraph` | 状态机式Agent开发 |
+| 数据检索 | LlamaIndex | `pip install llama-index` | 数据索引与检索（RAG） |
+
+#### 模型资源
+
+**Hugging Face**：[huggingface.co](https://huggingface.co/)
+
+功能：模型仓库、数据集、Spaces在线演示
+
+**常用预训练模型**：
+
+| 任务 | 推荐模型 | Hugging Face ID |
+|------|---------|----------------|
+| 文生图 | Stable Diffusion XL | stabilityai/stable-diffusion-xl-base-1.0 |
+| 目标检测 | YOLOv8 | Ultralytics |
+| 语义分割 | SAM | segment-anything |
+| 大语言模型 | Llama 3 | meta-llama/Meta-Llama-3-8B |
+
+## 4 机器学习与深度学习入门教程
+
+本节通过一个完整的实践流程，带领读者从数据准备到模型训练，体验机器学习和深度学习的核心步骤。
+
+### 4.1 机器学习 vs 深度学习
+
+| 维度 | 机器学习 | 深度学习 |
+|------|---------|---------|
+| 代表算法 | 线性回归、决策树、SVM、随机森林 | CNN、RNN、Transformer |
+| 特征工程 | 需要人工设计和选择特征 | 自动从原始数据中学习特征 |
+| 数据需求 | 中小规模数据即可 | 通常需要大量数据 |
+| 计算资源 | CPU即可 | 通常需要GPU |
+| 适用场景 | 结构化数据分析、基线模型 | 图像、文本、语音等非结构化数据 |
+
+### 4.2 scikit-learn：机器学习实践
+
+scikit-learn是Python最经典的机器学习库，提供了丰富的算法和工具。
+
+#### 安装
+
+```bash
+pip install scikit-learn
+```
+
+#### 完整示例：鸢尾花分类
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, classification_report
+
+# 1. 加载数据
+iris = datasets.load_iris()
+X = iris.data          # 特征：花萼长度、宽度，花瓣长度、宽度
+y = iris.target         # 标签：三种鸢尾花
+print(f"数据集大小: {X.shape}, 类别数: {len(np.unique(y))}")
+
+# 2. 划分训练集和测试集
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# 3. 数据标准化
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# 4. 训练多个模型并比较
+models = {
+    "逻辑回归": LogisticRegression(),
+    "决策树": DecisionTreeClassifier(max_depth=3),
+    "随机森林": RandomForestClassifier(n_estimators=100),
+}
+
+for name, model in models.items():
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    acc = accuracy_score(y_test, y_pred)
+    print(f"{name} 准确率: {acc:.2%}")
+
+# 5. 详细评估报告（以随机森林为例）
+best_model = models["随机森林"]
+y_pred = best_model.predict(X_test)
+print("\n分类报告:")
+print(classification_report(y_test, y_pred, target_names=iris.target_names))
+```
+
+#### 机器学习工作流总结
+
+```
+数据收集 → 数据预处理 → 特征工程 → 划分训练/测试集
+    → 选择模型 → 训练 → 评估 → 调优 → 部署
+```
+
+### 4.3 PyTorch：深度学习实践
+
+PyTorch是当前研究和实验中最流行的深度学习框架，以动态计算图和Pythonic API著称。
+
+#### 张量（Tensor）基础
+
+张量是PyTorch的核心数据结构，类似于NumPy数组，但可以在GPU上运算。
+
+```python
+import torch
+
+# 创建张量
+a = torch.tensor([1.0, 2.0, 3.0])
+b = torch.zeros(3, 4)         # 3×4 全零矩阵
+c = torch.randn(3, 4)         # 3×4 随机矩阵
+
+# 张量运算
+x = torch.tensor([1.0, 2.0, 3.0])
+y = torch.tensor([4.0, 5.0, 6.0])
+print(x + y)                    # 加法
+print(torch.dot(x, y))          # 点积
+
+# NumPy互转
+import numpy as np
+arr = np.array([1, 2, 3])
+tensor = torch.from_numpy(arr)  # NumPy → Tensor
+back = tensor.numpy()           # Tensor → NumPy
+```
+
+#### 自动求导（Autograd）
+
+PyTorch的autograd模块可以自动计算梯度，是训练神经网络的核心。
+
+```python
+# 创建需要梯度的张量
+x = torch.tensor([2.0], requires_grad=True)
+
+# 前向计算
+y = x ** 2 + 3 * x + 1    # y = x² + 3x + 1
+
+# 反向传播，自动计算 dy/dx
+y.backward()
+print(f"dy/dx = {x.grad}")    # 应为 2x + 3 = 7（x=2时）
+```
+
+#### 完整示例：手写数字识别
+
+以下是一个完整的神经网络训练流程，使用经典的MNIST数据集。
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+
+# 1. 数据准备
+transform = transforms.Compose([
+    transforms.ToTensor(),                              # 转为张量
+    transforms.Normalize((0.1307,), (0.3081,))          # 标准化
+])
+
+train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
+test_dataset = datasets.MNIST('./data', train=False, transform=transform)
+
+train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
+test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000)
+
+# 2. 定义模型
+class Net(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(28 * 28, 128)     # 输入层 → 隐藏层
+        self.fc2 = nn.Linear(128, 64)            # 隐藏层 → 隐藏层
+        self.fc3 = nn.Linear(64, 10)             # 隐藏层 → 输出层（10个数字）
+
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)                 # 展平图像
+        x = torch.relu(self.fc1(x))              # ReLU激活
+        x = torch.relu(self.fc2(x))
+        x = self.fc3(x)                          # 输出层不加激活
+        return x
+
+model = Net()
+
+# 3. 定义损失函数和优化器
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+# 4. 训练
+for epoch in range(5):
+    model.train()
+    total_loss = 0
+    for batch_x, batch_y in train_loader:
+        optimizer.zero_grad()                    # 清零梯度
+        output = model(batch_x)                  # 前向传播
+        loss = criterion(output, batch_y)        # 计算损失
+        loss.backward()                          # 反向传播
+        optimizer.step()                         # 更新参数
+        total_loss += loss.item()
+    print(f"Epoch {epoch+1}, Loss: {total_loss/len(train_loader):.4f}")
+
+# 5. 测试
+model.eval()
+correct = 0
+total = 0
+with torch.no_grad():
+    for batch_x, batch_y in test_loader:
+        output = model(batch_x)
+        _, predicted = torch.max(output, 1)
+        total += batch_y.size(0)
+        correct += (predicted == batch_y).sum()
+
+print(f"\n测试准确率: {correct/total:.2%}")
+```
+
+### 4.4 使用预训练模型
+
+在实际应用中，通常不需要从头训练模型，而是使用预训练模型进行微调或直接推理。
+
+#### 使用Hugging Face Transformers
+
+```python
+# 安装: pip install transformers
+
+from transformers import pipeline
+
+# 文本分类（情感分析）
+classifier = pipeline("sentiment-analysis")
+result = classifier("This design is amazing!")
+print(result)
+# [{'label': 'POSITIVE', 'score': 0.9998}]
+
+# 图像分类
+image_classifier = pipeline("image-classification")
+result = image_classifier("building.jpg")
+print(result)
+# [{'score': 0.92, 'label': 'palace'}, ...]
+```
+
+#### 使用Ultralytics YOLO
+
+```python
+# 安装: pip install ultralytics
+
+from ultralytics import YOLO
+
+# 加载预训练模型
+model = YOLO("yolov8n.pt")
+
+# 目标检测
+results = model("street_photo.jpg")
+
+# 查看结果
+for result in results:
+    boxes = result.boxes
+    for box in boxes:
+        cls = int(box.cls[0])
+        conf = float(box.conf[0])
+        label = model.names[cls]
+        print(f"检测到: {label}, 置信度: {conf:.2f}")
+```
+
+### 4.5 GPU加速
+
+深度学习训练在GPU上可以快数十倍。PyTorch的GPU使用非常简洁：
+
+```python
+# 检查GPU是否可用
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"使用设备: {device}")
+
+# 将模型和数据移动到GPU
+model = Net().to(device)
+
+# 训练时，数据也需要移到GPU
+for batch_x, batch_y in train_loader:
+    batch_x = batch_x.to(device)
+    batch_y = batch_y.to(device)
+    # ... 后续训练代码不变
+```
+
+在没有本地GPU的情况下，可以使用 [Google Colab](https://colab.research.google.com/) 免费使用云端GPU运行上述代码。
+
+### 4.6 学习路径建议
+
+| 阶段 | 内容 | 推荐资源 |
+|------|------|---------|
+| 入门 | Python基础 + NumPy/Pandas | 本附录 §3 |
+| 机器学习 | scikit-learn实践 | [scikit-learn官方教程](https://scikit-learn.org/stable/tutorial/) |
+| 深度学习基础 | PyTorch入门 + MLP | [PyTorch官方教程](https://pytorch.org/tutorials/) |
+| 计算机视觉 | CNN + 图像分类/检测 | 本书第三篇 + CS231n |
+| 自然语言处理 | Transformer + LLM | 本书第四篇 + CS224n |
+| 生成式AI | Diffusion + AIGC工具 | 本书第五篇 |
+| 前沿探索 | Agent + 具身智能 | 本书第六篇 |