# 附录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 + 具身智能 | 本书第六篇 |
