先回答一个我经常被问到的问题：零基础学深度学习，到底要不要先把数学学明白？
我见过太多人卡在这一步。有的抱着《高等数学》《线性代数》啃了两个月，越啃越心虚，觉得矩阵特征值还没搞懂、概率密度还没吃透，就不敢碰代码。也有反过来的，直接 pip install tensorflow，跑通一个 mnist 例子就觉得自己入门了，结果 loss 一不降就彻底抓瞎，连从哪儿排查都不知道。
我的建议是：别把数学当门槛，但也别彻底绕开它。深度学习入门真正用得上的数学，范围比你想的窄得多。你不需要成为数学家，你只需要建立三个直觉：导数是什么、矩阵乘法在干什么、概率里的期望和分布是怎么回事。这篇文章就是按这个思路来设计的完整路线图，从数学底子到跑通第一个神经网络，每一步该学什么、该跳什么、该注意什么，我都会给你一个可执行的版本。
1. 为什么说深度学习入门真正的数学门槛只有三块
很多教程一上来就甩出整本数学书的目录，这其实是把新手劝退的最大原因。深度学习虽然是"深度"学习，但它前向传播、反向传播、梯度下降这三板斧所依赖的数学工具，掰开揉碎就三样。
1.1 导数：整个神经网络学习的"方向盘"
先说导数。神经网络的训练核心是梯度下降，而梯度的本质就是偏导数组成的向量。你不需要会背所有求导公式，但你必须理解一件事：导数告诉你参数往哪个方向调，loss 会变小。
以最简单的损失函数 L = (y - ŷ)² 为例，ŷ 是模型预测值，y 是真实标签。如果我们对预测值求导，得到 dL/dŷ = -2(y - ŷ)。这个式子说明，当预测值大于真实值时，导数为负，意味着我们需要把预测值调小；反过来也一样。这个"看导数的正负决定参数调整方向"的直觉，比你会算一百道求导题都重要。
到了反向传播，你会看到链式法则。比如三层网络，输出层的误差要逐层传回输入层，中间每一层都用链式法则把梯度乘回去。你不需要手动推每一个梯度，PyTorch 的 autograd 机制会帮你算，但如果你不理解"梯度是沿着计算图逐层传播的"，那你连 loss 变成 NaN 时该查哪一层都不知道。
1.2 线性代数：张量运算的"交通规则"
线性代数里 90% 的定理可以暂时不看，但矩阵乘法必须融进骨头里。神经网络的一层就是 y = Wx + b，W 是权重矩阵，x 是输入向量，b 是偏置。矩阵乘法的维度匹配规则——(m, n) 乘以 (n, p) 得到 (m, p)——决定了你搭建网络时每一层的输入输出尺寸。
很多人第一次搭网络报错，十有八九是维度对不上。与其对着报错信息瞎猜，不如拿张纸把每一层的输入维度、权重矩阵维度、输出维度列出来，一算就知道问题出在哪儿。这比会证明什么奇异值分解有用得多。
还有一个概念叫"张量形状"，你可以把它理解成数据的容器规格。一张 32x32 的彩色图片，在 PyTorch 里是形状为 (3, 32, 32) 的张量，3 是 RGB 三个通道。批量训练时再加一个 batch 维度，变成 (64, 3, 32, 32)。你不需要懂张量代数，但你得习惯用 shape 的视角思考数据流动。
1.3 概率与统计：理解损失函数和评估指标的"度量衡"
概率里你真正要用的就两块：分布的概念和期望。分类问题里，我们把模型的输出经过 softmax 变成"属于每个类别的概率分布"，然后用交叉熵衡量预测分布和真实分布的差距。你如果完全不懂概率，就很难理解为什么分类问题用交叉熵而不是均方误差——因为交叉熵本质上是衡量两个分布的差异，这比数值上的平方差更符合"概率预测"的语义。
统计里的均值、方差、标准差也必须熟。数据标准化（减均值除标准差）几乎是所有深度学习项目的标配，不理解方差，你就不知道为什么梯度下降在某些数据集上跑得特别慢。
提示：这三块数学，不需要系统刷书，只需要在遇到具体问题时"按需学习"。深度学习入门不是数学考试，你的目标是让网络跑起来、结果合理，而不是证明定理。
2. 环境搭建与工具选型：2025年零基础最省心的方案
聊完数学，说说工具。2025 年的深度学习环境，比五年前友好太多了。你不需要自己从源码编译 CUDA，不需要手动配置 OpenCV 和 Caffe 的依赖，一个 Anaconda 加 PyTorch 基本能解决 90% 的需求。
2.1 为什么我推荐 PyTorch 而不是 TensorFlow
如果你是零基础，我的建议是直接选 PyTorch，不用犹豫。原因有三条：
第一，PyTorch 的调试体验对新手极其友好。它的计算图是动态的，你可以随时 print 中间张量的 shape 和数值，出错了能顺着代码一行行查。TensorFlow 2.x 虽然也默认了 eager mode，但历史包袱还在，社区里大量旧教程和代码都是 1.x 的写法，新手很容易被绕晕。
第二，PyTorch 的生态在学术界和工业界都已经成为事实标准。Hugging Face 的 Transformers、Ultralytics 的 YOLOv5/YOLOv8，底层都是 PyTorch。你以后想做人声分离、视觉检测、图神经网络，找到的开源项目大概率是 PyTorch 写的。
第三，PyTorch 的报错信息对新手相对友好。虽然也不能指望它像 ChatGPT 一样告诉你哪行写错了，但至少错误定位比 TensorFlow 的抽象图机制清晰得多。
2.2 完整的环境配置步骤
以 Windows 为例（Linux 和 Mac 类似），一个干净的环境配置流程如下：
第一步，安装 Anaconda。去官网下载最新版，安装时记得勾选"Add to PATH"，省得后面每次都要手动激活。装完后打开 Anaconda Prompt，输入conda --version验证。
第二步，创建独立的虚拟环境。我强烈建议你不要把深度学习库装在 base 环境里，否则以后项目多了，依赖冲突会让你痛不欲生：
conda create -n dl python=3.10 conda activate dl第三步，安装 PyTorch。这是最容易出问题的一步。千万别直接pip install torch，那个默认装的是 CPU 版本，虽然也能跑，但训练速度会让你怀疑人生。正确做法是去 PyTorch 官网（pytorch.org），选择你的操作系统、包管理器（pip 或 conda）、CUDA 版本，然后复制生成的命令。
# 以 CUDA 12.1 为例，具体以官网生成为准 pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121装完验证一下 GPU 是否可用：
import torch print(torch.__version__) print(torch.cuda.is_available()) # 输出 True 说明 GPU 可用如果输出 False，不要慌，先查两件事：你的显卡是不是 NVIDIA 的（AMD 显卡和纯核显笔记本用不了 CUDA）；显卡驱动是不是太旧。实在不行就先装 CPU 版把代码跑通，以后有 GPU 机器了再重装。
第四步，安装 Jupyter Notebook 或 VS Code。我推荐新手用 Jupyter，因为它的单元格执行方式非常适合"写一段、跑一段、看结果"的学习节奏。在 conda 环境里执行pip install jupyter，然后jupyter notebook就能打开浏览器界面。VS Code 也是个好选择，装上 Python 扩展后可以直接选 conda 环境作为解释器，写代码和调试体验都更专业。
2.3 新手最容易踩的环境坑
这里我必须专门提醒几个我见过无数次的坑：
第一个坑是 conda 和 pip 混用导致的依赖不一致。建议一个项目里尽量用一种包管理器，如果必须混用，先 pip 后 conda，或者在同一个环境里装的时候自己心里有数。
第二个坑是 CUDA 版本和 PyTorch 版本不匹配。你不需要自己单独装 CUDA，PyTorch 的 pip 包其实已经内置了它需要的 CUDA runtime。你只需要保证显卡驱动够新就行。很多人自己装了个 CUDA 10.0，然后跑 PyTorch 2.x 报错，其实根本不用装。
第三个坑是下载速度慢。pip 和 conda 在国内访问官方源都慢，建议配置国内镜像：
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/提示：环境配置这个环节，遇到问题优先看报错原文，把报错信息复制到搜索引擎里搜，八成能找到答案。不要瞎试命令，那样只会把环境越搞越乱。
3. 神经网络的"零件"拆解：从单个神经元到多层感知机
环境搭好之后，先别急着开跑，我带你拆一下神经网络到底是由什么组成的。零基础的人看网络结构图容易晕，其实神经网络的零件是很有限的，你把这几个零件理解透了，绝大多数主流网络你都能看懂个大概。
3.1 神经元：一个"先加权求和，再决定是否激活"的小机器
一个神经元做的事，用一句话就能概括：把输入加权求和，加上一个偏置，然后过一个激活函数。
数学表达式就是 y = f(Wx + b)。W 就是权重，表示每个输入特征有多重要；b 是偏置，相当于阈值；f 是激活函数，决定这个神经元"要不要被点亮"。
用生活化的比喻来说：你决定去不去吃火锅，考虑的因素有"天气冷（特征1）""朋友邀约（特征2）""钱包余额（特征3）"，每个因素的权重不同，比如天气冷权重高、钱包余额权重更高，加权求和后如果超过某个阈值，你就去。这个"加权求和+阈值判断"的过程，就是神经元在做的事。
3.2 激活函数：给网络"非线性能力"的关键
如果没有激活函数，神经网络不管堆多少层，本质上都等价于一个线性变换，那再深的网络也拟合不了复杂的非线性关系。激活函数的作用，就是引入非线性。
零基础阶段，你只需要先认识三个激活函数：
Sigmoid 把任意实数压缩到 (0,1) 区间，公式 σ(x) = 1 / (1 + e⁻ˣ)。它在二分类输出层很常用，但隐藏层已经很少用了，因为它在输入绝对值较大时梯度趋近于 0，容易造成梯度消失。
ReLU 是目前隐藏层默认选择，公式 ReLU(x) = max(0, x)。它的计算极简单，正区间梯度恒定是 1，极大缓解了梯度消失问题。但要小心"神经元死亡"问题——如果一个神经元的输入一直是负数，那它的梯度永远是 0，就再也不会更新了。
Softmax 是分类网络的标配，它把一组实数变成一组和为 1 的概率值，常用于多分类输出层。
提示：新手不需要记全部 10 种激活函数，先把这三个用熟。实际项目里选激活函数，默认 ReLU 家族，输出层根据任务选 Sigmoid（二分类）或 Softmax（多分类）。
3.3 损失函数：告诉你"现在模型有多差"
损失函数是训练的"裁判"，它计算模型预测值和真实标签之间的差距。预测越差，损失越大，梯度下降就越要用力调整参数。
回归问题用均方误差 MSE = mean((y - ŷ)²)。分类问题用交叉熵，PyTorch 里是nn.CrossEntropyLoss()。这个函数在 PyTorch 里做得非常贴心：你只需要传入模型原始输出（logits）和真实标签，它内部会先做 softmax 再算交叉熵，不需要你手动 softmax。
新手常见的错误是：已经在网络最后一层手动加了 softmax，又在损失函数里用nn.CrossEntropyLoss()，导致梯度算两遍。正确的做法是二选一：网络最后一层不用 softmax，直接用nn.CrossEntropyLoss()；或者网络最后一层用 softmax，然后损失函数换成nn.NLLLoss()。
3.4 动手搭一个 3 层感知机
有了上面的零件，你其实已经能搭出第一个神经网络了。下面这个例子是一个 3 层全连接网络，输入 784 维（对应 28x28 的图片展平），隐藏层 256 个神经元，输出 10 类（对应 0-9 十个数字）：
import torch.nn as nn class MLP(nn.Module): def __init__(self): super().__init__() self.net = nn.Sequential( nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 128), nn.ReLU(), nn.Linear(128, 10) ) def forward(self, x): return self.net(x)这段代码里nn.Linear(784, 256)就是"784 个输入连到 256 个输出"的线性层（内部就是 y = Wx + b），nn.ReLU()是激活函数。写到这里你会发现，神经网络入门真的没你想象的那么玄，它就是一串层的堆叠。
4. 训练循环与反向传播：亲手写下梯度下降的执行过程
模型搭好了，接下来就是在数据上不停地训练。训练循环是深度学习里最重要的"套路"，你必须亲手写一遍，而不是只用model.fit()这种高层接口。
4.1 训练四件套：数据加载、损失函数、优化器、迭代循环
PyTorch 里一个标准的训练循环由四部分组成。数据加载器负责把数据一批一批喂给模型；损失函数计算误差；优化器根据梯度更新参数；迭代循环让这个过程反复进行。
这里直接给一个 mnist 手写数字识别的完整训练代码，这是深度学习的 Hello World，也是理解训练循环的最佳载体：
import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms from torch.utils.data import DataLoader # 1. 数据预处理和加载 transform = transforms.Compose([ transforms.ToTensor(), # 转为张量 transforms.Normalize((0.1307,), (0.3081,)) # 标准化：均值0.1307，标准差0.3081 ]) train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST('./data', train=False, download=True, transform=transform) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) # 2. 定义模型、损失函数、优化器 model = MLP() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 3. 训练循环 epochs = 5 for epoch in range(epochs): running_loss = 0.0 for images, labels in train_loader: # 前向传播 outputs = model(images.view(images.size(0), -1)) loss = criterion(outputs, labels) # 反向传播 + 参数更新 optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() # 每个 epoch 结束打印一次平均损失 avg_loss = running_loss / len(train_loader) print(f'Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}')这段代码里的每一行都有它的意义，但零基础阶段你只需要盯住三行核心：
optimizer.zero_grad()是把上一轮计算的梯度清零。如果不做这一步，PyTorch 默认会累加梯度，导致梯度越来越大，模型就废了。这是新手最容易忘的一行。
loss.backward()是反向传播，PyTorch 的 autograd 机制自动计算出每个参数关于 loss 的梯度。你不需要手动实现任何链式法则的数学推导，框架帮你做了。
optimizer.step()是根据梯度更新参数。它做的事情等价于 w = w - lr * w.grad，也就是朝梯度下降的方向迈一小步，步长就是学习率 lr。
4.2 手写数字识别全流程：从数据到评估
训练完的模型不能只看着 loss 变小就开心，你还得在测试集上评估它的泛化能力。下面这段代码计算模型在测试集上的准确率：
correct = 0 total = 0 with torch.no_grad(): # 推理时不需要计算梯度，省内存 for images, labels in test_loader: outputs = model(images.view(images.size(0), -1)) _, predicted = torch.max(outputs.data, 1) # 取最大概率对应的类别 total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Accuracy: {100 * correct / total:.2f}%')这段代码里有个细节值得注意：torch.no_grad()。推理阶段不需要反向传播，也就不需要保存计算图，用no_grad()包裹可以省下大量内存和计算时间。这在训练大模型时是必不可少的好习惯。
按我的经验，这个 3 层 MLP 在 MNIST 上训练 5 个 epoch，准确率能到 97% 左右。当然，在 2025 年看来，97% 并不算高——卷积神经网络可以轻松做到 99% 以上。但作为第一个神经网络，它的意义不在刷分，而在于让你完整走一遍训练的闭环。
4.3 学习率：整个训练过程里最重要的超参数
如果你只记住一个超参数，那一定是学习率。学习率决定了每一步参数更新的幅度。
学习率太低，loss 下降得像乌龟爬，训练几百个 epoch 也收敛不了。学习率太高，参数在最优解附近反复横跳，loss 曲线像心电图一样剧烈震荡，甚至直接发散变成 NaN。
一个实用的经验：loss 曲线稳步下降但不快，试试把学习率乘以 10；loss 曲线震荡或上升，试试把学习率除以 10。训练初期可以先用较大的学习率快速逼近，后期再逐步调小（这就是学习率衰减的朴素想法）。
5. 从第一个神经网络到实战：卷积神经网络与循环神经网络的进阶路径
第一个神经网络跑通之后，你的深度学习入门就算完成了一半。但要真正面对真实世界的任务——图片分类、目标检测、语音识别、文本分析——你需要在这条路上继续往上走两层阶梯。
5.1 卷积神经网络：让网络"看得懂"图像
MLP 处理图像有一个致命问题：把二维图像展平成向量，会丢失像素之间的空间关系。一张 28x28 的图片，像素 (0,0) 和像素 (0,5) 本来是相邻的，展平后它们之间隔了 4 个数字，网络很难发现它们的局部关联。
卷积神经网络（CNN）的核心就是用卷积核在图像上滑动，提取局部特征。一个卷积核就像一个小型放大镜，每次只看一个局部区域，比如 3x3 的窗口，然后扫描整张图。不同的卷积核可以提取不同的特征：有的关注边缘，有的关注纹理，有的关注形状。
CNN 的完整结构通常包含三个部分：卷积层（提取特征）、池化层（压缩特征图尺寸，保留主要信息）、全连接层（最后做分类）。PyTorch 里搭一个 CNN 的代码量比 MLP 多不了多少：
class CNN(nn.Module): def __init__(self): super().__init__() self.conv_layers = nn.Sequential( nn.Conv2d(1, 32, kernel_size=3, padding=1), # 输入1通道，输出32通道 nn.ReLU(), nn.MaxPool2d(2), # 尺寸减半 nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2) # 尺寸再减半 ) self.classifier = nn.Sequential( nn.Linear(64 * 7 * 7, 128), nn.ReLU(), nn.Linear(128, 10) ) def forward(self, x): x = self.conv_layers(x) x = x.view(x.size(0), -1) # 展平 return self.classifier(x)同样的 MNIST 任务，这个简单的 CNN 准确率就能到 99% 以上，压过 MLP 一头。这直观地告诉你：模型结构的选择，比调参重要得多。
在实际视觉项目里，主流做法是使用预训练模型（比如 ResNet、YOLO），然后在自己的数据集上做微调。这就是所谓"站在巨人肩膀上"。你不需要从零训练一个大模型，用 PyTorch 加载预训练权重几行代码就能搞定：
import torchvision.models as models resnet = models.resnet18(pretrained=True)5.2 循环神经网络与 Transformer：处理序列数据的起点
图像是空间数据，文本、语音、时间序列则是序列数据。循环神经网络（RNN）的设计思路是"挨个读，边读边记"。就像一个人逐字阅读一句话，每读一个字就更新一次自己的记忆（隐藏状态），最后一个字的记忆就包含了整句话的信息。
标准循环神经网络（Vanilla RNN）的核心公式其实很简单：
h_t = tanh(W_ih · x_t + b_ih + W_hh · h_{t-1} + b_hh)
其中 h_t 是当前时间步的隐藏状态，x_t 是当前输入，h_{t-1} 是上一个时间步的隐藏状态。这个公式你想理解到什么程度？至少要知道：隐藏状态既依赖当前输入，也依赖上一时刻的状态，这是 RNN"记忆能力"的来源。
但 RNN 有两个天然短板：一是长序列上梯度消失明显，导致"记不住太久以前的事"；二是串行计算，训练速度慢。所以现在的 NLP 领域，Transformer 架构几乎完全取代了 RNN。Transformer 里的自注意力机制（Self-Attention）让每个词都能直接"看到"句子里的所有词，并且可以并行计算，训练速度大幅提升。
你可能会问：零基础入门要学到 Transformer 吗？我的建议是：知道它的存在和大致原理就可以了，真要深入，等你的 CNN 和 RNN 基本功扎实了再说。 Transformer 内部的多头注意力、位置编码、LayerNorm 等概念，各自都够写几篇文章，一口吃不成胖子。
6. 你不可避免要踩的 5 个深坑和对应排查链路
最后这部分，我把我这些年在深度学习入门阶段见过的、自己踩过的坑集中写出来。这几个坑不致命，但每一个都能浪费你几小时到一整天的时间。关键是你要学会一套排查思路，而不是遇到问题就到处问人。
6.1 Loss 不下降：先看数据，再看模型，最后看超参数
loss 一直不动，是新手最崩溃的时刻。我以前见过有个学员训练一个分类模型，loss 稳如老狗，几个 epoch 过去纹丝不动。最后排查发现，数据标准化时用了错误的均值和标准差，输入数据的数值范围完全不对。
排查链路应该是这样的：先打印数据看一眼，确认输入的数值范围是合理的（图片应该在 -1 到 1 或 0 到 1 之间）；再看模型输出，是不是全是一个值（如果是，可能是初始化出了问题）；然后检查损失函数有没有写对，标签和输出维度是不是匹配；最后才调学习率。
提示：一个非常有效的调试技巧——用极小的数据集（比如 10 个样本）跑训练。如果 loss 还不降，说明模型或数据加载有 bug；如果降了，那问题出在大数据的处理上。
6.2 Loss 变成 NaN：几乎都是梯度爆炸或数值不稳定
loss 突然变成 NaN，最常见的两个原因是梯度爆炸和学习率过大。我在实际调试中看到，新手用 Adam 优化器默认学习率 0.001 时一般不会出这个问题，但一旦手动调大学习率到 0.1，loss 直接飞掉。
排查链路：先把学习率降到 1e-4 试试，还 NaN 的话检查数据里有没有 NaN（比如原始数据有空值没处理）；再检查损失函数是不是用了 log 或除法，有没有除零风险。
6.3 训练集上表现好、测试集上表现差：过拟合了
模型在训练集上准确率 99%，测试集上只有 70%，这是过拟合的典型症状。解决方案按优先级排序：增加数据量（数据增强）、减小模型容量、加 Dropout 层、加正则化。
PyTorch 里加 Dropout 非常方便，在模型里插入一行nn.Dropout(0.5)就行。它会在训练时随机"关闭"一半神经元，迫使网络学习更鲁棒的特征。
6.4 显存不足：不是你的代码有问题，是资源规划问题
第一次用 GPU 训练，很多人会碰到CUDA out of memory。这个报错不代表代码有 bug，而是显存不够用了。最简单的解法是调小 batch_size，比如从 64 调到 32 甚至 16。其次是确认训练结束时把不用的张量释放掉，del配合torch.cuda.empty_cache()可以手动清理缓存。
6.5 训练速度奇慢：别急着换电脑，先排查瓶颈
训练一个 epoch 要半小时，很多人第一反应是"我得换显卡"。其实更常见的原因是数据加载成了瓶颈——每次读取图片都要从磁盘 IO，GPU 在等数据。解决方案是增加 DataLoader 的num_workers参数，让多个子进程同时加载数据；或者先用torch.no_grad()模式跑推理，排查是不是反向传播太慢。
我在实际使用中发现，DataLoader 的num_workers从默认 0 改到 4 或 8，训练速度常常能快两三倍，而且不用花一分钱。
7. 从现在开始的行动计划：8 周可以走到哪里
路线图讲完了，我给一份可以照着执行的时间计划。这条路我让很多人走过，按部就班的话，8 周足以让你从一个完全没接触过深度学习的人，变成能自己搭建、训练、评估一个神经网络的人。
第一周，补数学直觉。不求全，只把导数、链式法则、矩阵乘法、均值方差这些核心概念弄熟。配合 3Blue1Brown 的"深度学习"系列视频，那个可视化讲反向传播的视频，是我见过最好的入门材料。
第二周，搭环境。按前面说的流程装 Anaconda、PyTorch、Jupyter，跑通torch.cuda.is_available()返回 True（没有 GPU 就返回 False 也没关系，CPU 照样能跑 mnist）。再随手写几个张量操作的练习，感受一下 PyTorch 的语法。
第三周到第四周，吃透 MLP 和训练循环。把上面的 mnist 例子自己从头敲一遍，不是复制粘贴，是一行一行敲。然后尝试修改：把隐藏层改成 3 层、把激活函数从 ReLU 换成 Sigmoid、把优化器从 Adam 换成 SGD，观察 train loss 和 test accuracy 的变化。这个"改参数看效果"的过程，比看一百篇教程都有用。
第五周到第六周，进入 CNN。在 mnist 上把模型换成 CNN，准确率提到 99% 以上。再找一个稍微复杂的公开数据集（比如 CIFAR-10），体会一下图像数据从"简单"到"复杂"后，你会遇到哪些新问题——数据增强、过拟合、训练时间变长，这些都会在这一步真实地找上你。
第七周，做一个自己的小项目。不需要宏大，比如做一个表情识别、手势识别、简单的目标检测 demo。PyTorch 官方仓库和 Hugging Face 上大量开源的代码模板，你可以站在前人的肩膀上改，关键是完整体验一遍"数据准备-模型搭建-训练-评估-部署"的全流程。
第八周，回头把深度学习里的核心概念串一遍：卷积、池化、Dropout、归一化、学习率调度。这时候你会发现，之前看不太懂的文章现在能看懂大半了——这说明你已经建立起自己的知识骨架了。
我在实际带人的过程中发现，零基础的人入门深度学习，最大的障碍其实不是数学，也不是代码能力，而是"什么都想学会"的焦虑。你看一眼深度学习的热搜词——卷积神经网络、图神经网络、Transformer、YOLO、Hopfield 网络——如果都想搞懂，三个月你都出不了门。但如果你先沿着"MLP → CNN → 一个小项目"这条路走一遍，把最核心的套路刻进肌肉记忆里，后面再扩展什么领域都是顺水推舟的事。
最后再分享一个小技巧：建一个自己的实验记录文档，每次跑实验，把模型结构、损失函数、学习率、batch size、训练结果都记下来。这个习惯在你入门阶段可能看不出多大价值，但等你开始做复杂项目、需要对比不同方案时，你会发现它比任何高级调试工具都管用。我自己早期踩过的那些坑，一半以上的解决方案都来自翻自己的实验记录。
现在，打开你的终端，开始装环境吧。第一个神经网络离你没有想象中那么远。
