1. 从零到一：为什么大多数人学完Python基础后依然碰不了深度学习

我带过不少刚入门的朋友，发现一个特别普遍的现象：Python语法学得挺溜，列表推导式、装饰器、生成器都能写，但一打开深度学习框架的官方文档就懵了。满屏的Tensor、autograd、nn.Module，每个字都认识，连在一起就不知道在干什么。这不是你笨，而是从“会写Python”到“能做深度学习”之间，缺了一层关键的认知桥梁。

这个桥梁的核心，是理解深度学习框架到底帮你做了什么。很多人以为学深度学习就是学model.fit()，调包谁不会？但真正拉开差距的，是你知不知道fit背后发生了什么。比如一个简单的全连接网络，前向传播时数据在层与层之间怎么流动，反向传播时梯度怎么一层层算回来，优化器拿到梯度后怎么更新参数——这些如果只是背API，遇到自定义层、自定义损失函数、梯度异常就彻底抓瞎。

我个人的经验是，用纯Python和基础数学库手写一遍最简版的神经网络，比看十篇教程都管用。你不需要写得多优雅，哪怕用循环硬算矩阵乘法都行。当你亲手实现过一次前向和反向，再回头看框架的autograd，就会有一种“哦，原来你是在帮我干这个”的顿悟感。这个系列的第一篇，我不打算直接甩代码，而是先把这条学习路径上的关键节点拆开讲清楚，让你知道每一步在解决什么问题，为什么非解决不可。

适合谁来读？如果你已经能写Python函数和类，但没碰过NumPy之外的任何科学计算库，那这篇就是为你准备的。如果你已经用过框架但总觉得心里没底，这篇也能帮你把地基夯实。我会尽量用生活化的类比来解释，但该严谨的地方绝不含糊，毕竟深度学习这东西，差一个维度就可能报错。

2. 环境搭建：别在第一步就给自己埋雷

2.1 为什么我劝你先别急着装CUDA

新手最容易犯的错，就是一上来就折腾GPU环境。看到别人说“没GPU跑不动深度学习”，立刻去装CUDA、cuDNN，结果版本不匹配、驱动冲突、环境变量乱成一锅粥，三天过去了连个import torch都跑不通。说实话，入门阶段CPU完全够用。你前期要跑的都是小规模实验，MNIST手写数字识别、简单的回归任务，CPU跑一次也就几十秒，GPU可能就快那么几倍，但环境配置的时间成本可能是几十倍。

我的建议很明确：先用CPU把整个流程跑通，把精力花在理解算法上。等你真的需要训练大模型了，再回头搞GPU环境，那时候你对整个工具链已经熟悉了，踩坑也踩得明白。而且现在很多云平台提供现成的GPU环境，按小时计费，比你本地折腾划算得多。

2.2 用conda还是venv？我的选择逻辑

Python环境管理工具一大堆，venv、conda、pipenv、poetry，选哪个都能用，但深度学习场景下我强烈推荐conda。原因很简单：深度学习依赖的不只是Python包，还有一堆底层C++库、数学加速库。conda能帮你把这些非Python依赖也管起来，而venv只管Python包。比如你装PyTorch，conda会自动帮你处理好MKL数学库的链接，pip有时候就得你自己折腾。

具体操作上，我习惯给每个项目建独立环境，命名带上前缀方便识别：

conda create -n dl-basic python=3.10 conda activate dl-basic

Python版本选3.9到3.11之间都行，太新了有些库还没适配，太老了又缺特性。3.10是个比较稳的选择。环境建好后，装包也有讲究。如果你用pip装PyTorch，一定要去官网复制对应的安装命令，别自己瞎猜版本号。官网有个选择器，选好系统、包管理器、Python版本、计算平台，它会给你一条完整的命令，直接粘贴执行就行。

注意：不要混用conda install和pip install装同一个包，容易导致依赖冲突。我的习惯是，能用conda装的优先conda，conda没有的再用pip。

2.3 验证环境是否真的可用

装完之后别急着写模型，先跑个最小验证脚本。很多人装完包，import不报错就以为万事大吉，结果一跑计算就出问题。我一般会做三件事：

第一，检查版本号，确认装的是你想要的版本：

import torch import numpy as np print(torch.__version__) print(np.__version__)

第二，做一次简单的张量运算，确认底层计算库正常工作：

x = torch.randn(3, 4) y = torch.randn(4, 5) z = torch.matmul(x, y) print(z.shape) # 应该是 torch.Size([3, 5])

第三，如果你装了GPU版本，检查CUDA是否可用：

print(torch.cuda.is_available())

如果输出False，别慌，大概率是版本不匹配或者驱动问题。这时候先退回去用CPU，别死磕。我见过太多人卡在这一步，热情直接被消磨干净。

3. 张量：深度学习里的“万能容器”到底怎么用

3.1 从NumPy数组到张量，到底变了什么

如果你用过NumPy，第一次看到张量会觉得“这不就是数组吗”。确实，张量和NumPy数组在数据结构上非常像，都是多维数组。但张量多了两个关键能力：自动求导和硬件加速。自动求导是深度学习框架的核心，没有它，你每次反向传播都得手算梯度，那基本没法干活。硬件加速则是让你能把计算扔到GPU上跑，虽然入门阶段用不太到，但这是张量设计的初衷之一。

你可以把张量理解成一个“会记仇的数组”。普通数组算完就完了，张量会记住自己是怎么算出来的，这样后面才能自动求导。举个例子：

import torch a = torch.tensor([1.0, 2.0, 3.0], requires_grad=True) b = a * 2 c = b.sum() c.backward() print(a.grad) # 输出 tensor([2., 2., 2.])

这里requires_grad=True就是告诉张量“你要记录操作历史”。c.backward()触发反向传播，a.grad就是c对a的梯度。整个过程不需要你手动推导，框架帮你算好了。这就是张量最核心的价值。

3.2 创建张量的几种方式，哪种更适合你

创建张量的方法很多，但不同场景下选择不同。我整理了一个对照表，方便你快速判断：

实际用的时候，最常见的是torch.tensor()和torch.randn()。前者用于加载数据，后者用于初始化权重。有个细节要注意：torch.tensor()默认会根据输入推断数据类型，整数会变成int64，小数会变成float32。但深度学习里权重通常需要float32，如果你用整数列表创建张量再拿去算梯度，会直接报错。所以创建时最好显式指定dtype=torch.float32。

3.3 形状操作：view、reshape、permute到底选哪个

形状操作是张量使用中最容易出错的地方。view、reshape、permute、transpose这几个函数功能有重叠，但行为有细微差别。我踩过的坑是：用view改变形状后，原始张量的内存布局没变，后续操作可能出问题。后来才搞明白，view要求张量在内存中是连续的，而reshape不要求，它会自动处理非连续的情况。

简单记：不确定的时候用reshape，确定内存连续且追求极致性能时用view。permute则是交换维度顺序，比如把(batch, channel, height, width)变成(batch, height, width, channel)，这在处理图像数据时经常用到。transpose只能交换两个维度，permute可以一次交换多个。

还有一个高频操作是unsqueeze和squeeze。unsqueeze(0)在维度0处增加一个维度，比如把形状(3,4)变成(1,3,4)，常用于给单个样本加batch维度。squeeze则相反，去掉大小为1的维度。这两个操作在数据预处理和模型输入输出对齐时特别常用，建议多练几遍形成肌肉记忆。

4. 自动求导机制：框架最核心的魔法拆解

4.1 计算图：动态图到底动态在哪里

自动求导的核心是计算图。你可以把计算图想象成一个流程图，每个节点是一个张量，每条边是一个运算。前向传播时，框架一边算结果一边建图；反向传播时，沿着图反向走一遍，用链式法则算梯度。早期框架用静态图，先定义好图再喂数据，调试很不方便。现在主流的框架都用动态图，边算边建，写起来跟普通Python代码一样，调试也直观。

动态图的好处是你可以用Python的if、for、print随便穿插在计算过程中，框架都能正确处理。比如：

def forward(x): if x.sum() > 0: return x * 2 else: return x * 3

这种逻辑在静态图里很麻烦，在动态图里就是自然写法。但动态图也有代价，每次迭代都要重新建图，速度上比静态图慢一些。不过现在框架优化得很好，这个差距在大多数场景下可以忽略。

4.2 梯度计算的实际流程与常见报错

当你调用backward()时，框架会从调用者开始，沿着计算图反向传播。这里有几个关键点容易出错：

第一，只有标量才能直接backward。如果你的输出是向量，需要先sum()或者mean()变成标量，或者给backward()传一个梯度参数。我见过太多人直接对向量调backward()然后报错，其实就是没理解这一点。

第二，梯度会累加。每次backward()之后，梯度会加到已有的.grad上，而不是替换。所以训练循环里必须手动清零梯度：

optimizer.zero_grad() loss.backward() optimizer.step()

这个顺序不能乱。如果忘了zero_grad()，梯度会越累越大，模型直接跑飞。

第三，不需要梯度的张量要设置requires_grad=False。比如输入数据和标签，它们不需要更新，设置成False可以节省内存和计算。框架默认对requires_grad=True的张量记录操作历史，如果你不小心把数据也设成True，显存会爆得很快。

4.3 禁用梯度追踪的两种场景

有两种情况你需要主动禁用梯度追踪：推理阶段和部分参数冻结。推理时不需要反向传播，禁用梯度可以省显存、加速计算：

with torch.no_grad(): output = model(input)

另一种是迁移学习时冻结底层参数：

for param in model.features.parameters(): param.requires_grad = False

这样训练时只更新你指定的层，底层参数保持不变。这两种操作在实际项目中非常常见，建议一开始就养成习惯。

5. 第一个神经网络：从手写公式到框架实现

5.1 为什么先手写一遍线性回归

我坚持让每个入门的人先用纯Python写一遍线性回归的梯度下降，哪怕你觉得自己已经懂了。因为手写的过程中，你会被迫面对几个核心问题：损失函数怎么定义、梯度怎么推导、参数怎么更新、学习率怎么选。这些问题在框架里都被封装好了，但如果你不知道里面发生了什么，调参就是瞎猜。

线性回归的模型很简单：y = wx + b。损失函数用均方误差：loss = (y_pred - y_true)^2。梯度推导也不复杂：对w的梯度是2 * (y_pred - y_true) * x，对b的梯度是2 * (y_pred - y_true)。更新规则就是w = w - lr * grad_w。手写一遍之后，你再去看框架的optimizer.step()，就知道它其实就是在干这件事。

5.2 用框架重写：对比中理解封装的价值

手写版跑通后，用框架重写一遍，对比两者的差异。框架版的核心代码大概长这样：

import torch import torch.nn as nn model = nn.Linear(1, 1) criterion = nn.MSELoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01) for epoch in range(100): optimizer.zero_grad() output = model(x) loss = criterion(output, y) loss.backward() optimizer.step()

对比手写版，框架帮你做了几件事：自动管理参数、自动计算梯度、自动更新参数。你只需要定义模型结构、损失函数、优化器，剩下的框架全包了。这就是封装的价值——让你专注于模型设计，而不是底层计算。

但封装也带来了黑盒问题。比如nn.Linear(1,1)到底初始化了什么？它默认用均匀分布初始化权重，范围是[-1/sqrt(in_features), 1/sqrt(in_features)]。这个细节如果你不知道，遇到梯度消失或爆炸时就找不到原因。所以我的建议是，每用一个封装好的模块，都去翻一下源码或者文档，搞清楚它默认做了什么。

5.3 训练循环里的三个关键决策

训练循环看起来简单，但里面有三个决策直接影响结果：

批量大小怎么选。批量太小，梯度噪声大，训练不稳定；批量太大，显存吃紧，泛化可能变差。入门阶段从32或64开始试，这两个值在大多数任务上表现均衡。

学习率怎么定。学习率太大，损失震荡不收敛；太小，收敛慢得让人抓狂。我习惯先用1e-3试，如果损失下降太慢就调大，如果震荡就调小。框架里有学习率调度器，可以动态调整，但入门阶段先手动调，感受一下学习率的影响。

训练轮数怎么判断。不要固定跑100轮就完事，要看验证集损失。如果验证集损失连续几轮不下降，就可以停了。这就是早停策略，能有效防止过拟合。

6. 踩坑实录：入门阶段最容易翻车的五个地方

6.1 数据类型不匹配：float32和float64的隐形陷阱

NumPy默认用float64，PyTorch默认用float32。如果你用NumPy生成数据再转成张量，数据类型可能是float64，而模型参数是float32，两者运算直接报错。这个错误信息有时候不明显，新手很容易懵。解决办法很简单：转换时显式指定类型，或者用torch.tensor(data, dtype=torch.float32)。我现在的习惯是，所有进入模型的张量都检查一遍dtype，确认是float32再往下走。

6.2 形状对不上：广播机制不是万能的

广播机制很强大，但也很容易让人产生依赖。两个形状不同的张量运算时，框架会尝试自动扩展维度。但广播有规则：从最后一个维度开始对齐，要么相等，要么其中一个为1。如果不符合规则，直接报错。我遇到最多的情况是，模型输出形状是(batch, 1)，标签形状是(batch,)，两者算损失时广播成(batch, batch)，结果完全错误。解决办法是统一形状，用squeeze()或unsqueeze()对齐。

6.3 忘记清零梯度：一个让模型跑飞的低级错误

前面提过梯度累加的问题，但这里再强调一次，因为实在太常见了。训练循环里optimizer.zero_grad()必须放在loss.backward()之前。如果你放在之后，梯度还没用就被清零了，参数根本不更新。如果你忘了写，梯度累加导致更新步长越来越大，损失直接爆炸。我建议把训练循环的模板背下来，形成条件反射。

6.4 设备不一致：CPU和GPU之间的数据搬运

如果你用GPU训练，模型和数据都必须在同一个设备上。常见错误是模型在GPU上，数据在CPU上，运算时直接报错。解决办法是定义好设备变量：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) data = data.to(device)

每次创建新张量时都注意放到正确设备上。这个坑在入门阶段可能遇不到，但一旦开始用GPU就必然碰到，提前知道能省不少时间。

6.5 内存泄漏：张量累积导致的显存爆炸

训练循环里如果不断把损失或输出存到列表里，而这些张量还带着计算图，显存会越用越多，最后爆掉。解决办法是存的时候用.item()取出标量值，或者用.detach()断开计算图。比如：

losses.append(loss.item()) # 正确 losses.append(loss) # 错误，会保留计算图

这个细节在跑长训练时特别重要，短训练可能看不出来，一旦跑几百轮就出问题。

7. 从这篇出发，下一步该往哪走

如果你跟着上面的内容把环境搭好了，张量操作练熟了，自动求导理解了，还手写并框架实现了一个线性回归，那你的深度学习入门地基已经打得比大多数人扎实了。接下来我建议你按这个顺序继续：先用手写+框架的方式实现逻辑回归，解决一个二分类问题；然后过渡到多层感知机，理解非线性激活函数的作用；再往后就是卷积神经网络和循环神经网络，分别处理图像和序列数据。

每走一步，都保持“先理解原理，再用框架实现，最后对比差异”的习惯。不要急着堆模型、刷准确率，那些都是水到渠成的事。我见过太多人一上来就调ResNet、Transformer，结果连反向传播都说不清楚，遇到问题只能到处问人。慢就是快，把基础打牢，后面学什么新模型都是半天的事。

最后分享一个我自己的小技巧：建一个自己的代码片段库。每次搞懂一个知识点，就把最简可运行代码存下来，加上注释说明关键点。比如“张量创建与形状操作”、“自动求导验证”、“训练循环模板”。积累几个月，你就有了一个完全属于自己的速查手册，比任何教程都贴合你的思维习惯。这个习惯我从入门保持到现在，受益无穷。