PyTorch环境搭建与实战：从CUDA配置到TCN+Transformer预测-代码聚汇网

PyTorch环境搭建与实战：从CUDA配置到TCN+Transformer预测

Amy青梅·2026-08-30·阅读 23 GEO检测（免费）

PyTorch环境搭建CUDA

|难度：普通|阅读约 42 分钟

PyTorch 口袋参考这个系列，原本想按第一篇的思路继续写 API 技巧，结果后台和评论区炸出来的问题，十有八九全集中在环境搭建、下载速度、版本匹配这类最不性感但最卡脖子的事情上。有人问 Win 下怎么用官方源装 CUDA 11.8，有人问 AMD 显卡能不能跑，有人问 TCN 加 Transformer 做股票预测怎么整，还有人连 import torch 都过不去。这篇就按“口袋参考（二）”的定位，把这些问题一次性梳理清楚，每一小节都能直接抄作业，不整虚的。

不管你是刚接触深度学习的新手，还是已经被环境问题折磨到想砸电脑的实践者，这篇的目标只有一个：让你照着做，就能把 PyTorch 环境跑起来，并且知道出问题时该往哪个方向找答案。

1. 环境搭建：从零跑通 PyTorch 的完整路径

1.1 为什么我坚持用 Anaconda 建独立环境

很多新手拿到 PyTorch 第一件事就是在全局 Python 里 pip install torch，装完发现要么和 TensorFlow 冲突，要么 numpy 版本被抬杠，要么过几天另一个项目又把环境搞坏了。Anaconda 的核心价值不是让你多装一个软件，而是给每个项目都划一个独立小房间，Python 版本、依赖库、CUDA 工具链各住各的，互不干扰。

具体操作是这样的。先安装 Anaconda 或者 Miniconda（我推荐 Miniconda，体积小很多，按需创建环境），打开命令行执行：

bash复制conda create -n torch python=3.10 -y
conda activate torch

这里我把 Python 版本固定在 3.10，原因是 PyTorch 官方对 Python 3.12、3.13 的支持虽然已经跟上，但很多第三方库（比如某些旧版 mmcv、dgl）还没完全适配。用 3.10 或者 3.9 是当前兼容性最稳的选择，没必要追新。

创建完环境后，建议看一眼当前环境里的 Python 路径，确认自己没装错地方：

bash复制which python
# Windows 下用
where python

路径里应该包含 envs\torch 之类的目录，而不是 Anaconda 的 base 目录。很多后面排查不清的问题，根源就是环境没激活，包全装到 base 里去了。这一点我在帮别人看问题时碰到过不下十次。

1.2 显卡与 CUDA：先看清你的硬件再动手

GPU 版 PyTorch 的安装，核心是搞清楚两个 CUDA：一个是显卡驱动自带的 CUDA 驱动版本，一个是 PyTorch 运行时要用的 CUDA runtime 库。

查看显卡驱动支持的 CUDA 版本，命令行执行：

bash复制nvidia-smi

右上角 CUDA Version: 12.4 表示驱动最多支持到 CUDA 12.4 的 runtime。很多人误以为这代表必须装 CUDA 12.4 的 PyTorch，其实驱动版本是一个上限，向下兼容。比如驱动显示支持 12.4，你完全可以用 PyTorch 对应 CUDA 11.8 的安装包，只要你需要的版本不高于驱动上限就行。

那 PyTorch 的 CUDA 版本怎么选？打开 PyTorch 官网，找到 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 这一行，后面 cu118 是 CUDA 11.8，cu121 是 CUDA 12.1，cu124 是 CUDA 12.4，cpu 是纯 CPU 版本。

我的建议是：

显卡驱动较新（能显示 12.x），优先选 cu121 或 cu118，这两个版本的 PyTorch 生态最成熟，编译产物稳定。
用的第三方库比较老（比如某些 torchvision 模型库），选 cu118，兼容面广。
新显卡（RTX 40 系以后）建议至少 cu121，个别算子在新架构上表现更好。

顺带提醒，torchvision 和 torchaudio 的版本必须跟 torch 严格对应，官网给定的一行命令已经配好，别分开装，否则经常出现 torchvision 里调不到对应算子的问题。

1.3 安装命令的选择：pip 与 conda 到底用哪个

这是个常年争论。我两种都试过很多次，结论很直接：环境用 conda 管，PyTorch 本体用 pip 装。

原因有三：conda 默认源里的 PyTorch 版本经常滞后，有时候官网已经发 2.3 了，conda 源还停在 2.1；conda 安装常常会连带解析一堆 CUDA 工具包，包体积大，解析依赖时容易卡死；pip 装的 PyTorch 是从 PyPI 或者 PyTorch 官方源直接拉的 wheel 包，本身就是官方编译好的，干净利落。

激活环境后，完整安装命令如下：

bash复制# GPU 版，CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

bash复制# CPU 版（Windows）
pip install torch torchvision torchaudio

如果已经装过 CPU 版想改 GPU 版，先卸载干净再装：

bash复制pip uninstall torch torchvision torchaudio -y

为什么强调卸载干净？因为 CPU 版和 GPU 版的 wheel 内部文件布局有差异，直接覆盖安装很容易留下旧文件，导致 import torch 报诡异的 DLL 错误。这类问题我在实际排查中见过太多次，卸载重装能解决掉其中大部分。

1.4 不装 Anaconda 的裸装路线

有些人不想装 Anaconda，嫌它重，或者有洁癖，这完全理解。PyTorch 官方其实支持平坦安装，用 Python 自带的虚拟环境工具即可：

bash复制python -m venv torch_env
# Windows 激活
torch_env\Scripts\activate
# Linux/macOS 激活
source torch_env/bin/activate

然后同样执行 pip install torch torchvision torchaudio，包会装进这个虚拟环境里，不会污染系统级 Python。

裸装路线的问题在于，如果你机器上有多个 Python 版本，python 指向哪里必须确认清楚。建议装 PyTorch 前，先确认 Python 版本符合要求：

bash复制python --version

PyTorch 2.x 对 Python 版本要求是 3.8 及以上，但社区实践下来 3.9~3.11 是最舒服的区间。如果系统 Python 是 3.7，或者某些发行版 Linux 自带的 Python 版本特别老，还是建议用 Anaconda 或 Miniconda 装一个新版本 Python，省去编译源码的麻烦。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 下载慢与装不上的终极解法

2.1 为什么官方源下载那么慢

PyTorch 这几个包有多大？以 torch 为例，GPU 版在 Windows 上经常一个 wheel 就 2.5 GB 左右，加上 torchvision 和 torchaudio，三个包加起来轻松超过 3 GB。这些文件托管在 PyTorch 官方 CDN 上，服务器位置主要在海外，国内直连下载速率经常只有几十 KB/s，卡到天荒地老。

还有一个容易忽略的细节：--index-url 指定的是 PyTorch 官方 wheel 仓库，这个仓库里只有 torch、torchvision、torchaudio 这几个包，当你执行 pip install torch 时，pip 会先访问这个仓库获取元数据，然后下载 wheel。如果这个仓库本身访问不通，就会卡在 “Collecting torch” 这一步，看着像死了。

2.2 国内镜像加速实操

解决下载慢，最直接的方案是换国内镜像源。建议用清华的 PyPI 镜像，稳定性和同步速度都很好。全局配置方式：

bash复制pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

配置完，直接执行：

bash复制pip install torch torchvision torchaudio

会从清华镜像拉取包，速度通常能跑到几 MB/s，甚至十几 MB/s。但注意一个坑：清华镜像同步的是 PyPI（Python 包索引），而 PyTorch 官方源 download.pytorch.org 是独立仓库。对于 CPU 版（不带 cu118/cu121 后缀），PyPI 上的 wheel 和设备本身的 wheel 是一致的，所以换清华源没有问题。

但如果你需要 GPU 版，pip install torch --index-url .../cu118 这种命令指定的是 PyTorch 专用仓库，它的地址没法直接用清华镜像替代。这时推荐把 wheel 包先下载到本地，再用镜像源或本地安装。下一节我会展开说。

另外，conda 用户也可以通过修改 .condarc 文件加速：

yaml复制channels:
  - defaults
show_channel_urls: true
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

写完保存到用户目录（Windows 是 C:\Users\用户名\.condarc），清理缓存后执行 conda clean -i -y，可以有效提升 conda 解析速度。

2.3 手机热点、弱网环境怎么装

有人问：“安装 PyTorch 时，手机开了热点，下载速度还是很慢，怎么办？”这个问题很现实，尤其是出差、宿舍网差、公司内网限制多的时候。

我的经验是三条路：

第一，用电脑浏览器直接到 https://download.pytorch.org/whl/cu118 目录下找到对应的 wheel 文件，用浏览器下载。浏览器下载走的是 HTTP 多线程，比 pip 的请求更稳定，而且支持断点续传，断了可以接着下，不会从头再来。

第二，找一台网络好的设备（比如手机），直接用浏览器下载 wheel 文件，再通过数据线、局域网共享、微信文件传输助手等方式传到目标电脑上。手机 5G 网络对海外的连通性经常比某些宽带走得还好，实测有用。

第三，拿到文件后，本地安装：

bash复制pip install ./torch-2.3.0+cu118-cp310-cp310-win_amd64.whl

后面可以接上 torchvision 和 torchaudio 的本地文件，一条命令全装上。注意文件名里的 cp310 表示 CPython 3.10，win_amd64 表示 Windows 64 位，选择时要对号入座。

2.4 安装后的三行验证命令

装完别急着写代码，先花 30 秒做三件事，把环境底细摸清楚：

python复制python -c "import torch; print(torch.__version__)"
python -c "import torch; print(torch.cuda.is_available())"
python -c "import torch; print(torch.cuda.get_device_name(0))"

第一行输出类似 2.3.0+cu118，说明装的是 CUDA 11.8 对应版本；如果只显示 2.3.0，那就是 CPU 版。第二行如果是 True，说明 CUDA 环境打通了。第三行如果输出显卡型号，说明 GPU 可以正常调用。

如果第二行是 False，大概率是这三类问题：装成了 CPU 版、显卡驱动版本过旧、或者系统里缺少 CUDA 相关 DLL。可以先跑 nvidia-smi 看驱动，再确认安装包名里带没带 cu 后缀，按顺序排查。

3. 框架选型：PyTorch、TensorFlow、LangChain 和 vLLM 到底什么关系

3.1 PyTorch 和 TensorFlow：2024/2025 的现实

先把票投了：如果你现在要从零学一个新框架，我无脑推荐 PyTorch。原因很务实：学术界的主流论文，代码几乎全是 PyTorch；GitHub 上的开源项目，PyTorch 的占比也在持续扩大；各大模型（LLaMA、Qwen、DeepSeek 等）的官方实现和社区复现，第一语言基本都是 PyTorch。

TensorFlow 并没有死，它的强项在工业部署链路：TF Serving、TensorFlow Lite、TFX 这些工具在传统企业里还有大量存量业务。如果你所在的团队已经有一套 TF 的训练和服务管线，迁移成本很高，继续用 TF 没问题。但如果你是个人学习、学术研究、或者做一个全新的项目，选 PyTorch 的路会顺很多。

现实一点说，2024 年后的趋势是：PyTorch 在研究和通用深度学习里占据主导地位，TensorFlow 主要守着老存量。新人没必要两边都深耕，先把 PyTorch 学透，等真遇到 TF 存量工程时再针对性补课就行。

3.2 LangChain、vLLM 是 PyTorch 的替代吗

这三个东西经常被放在一起问，但它们是不同层的东西，不是替代关系。

PyTorch 是深度学习框架，负责搭建神经网络、做训练和推理，相当于汽车的发动机。LangChain 是构建大模型应用的工具框架，它管的是 prompt 的拼接、工具的调用、Agent 的编排、记忆的存取，它本身不训练模型，底层调用模型时可以走 HuggingFace Transformers（那是基于 PyTorch 的），也可以调用 OpenAI API。类比一下，LangChain 像中控台，负责调度各种部件。

vLLM 是大模型推理引擎，专门做模型的部署和服务化，它用 PagedAttention 做显存管理，支持连续批处理，能让大模型在 GPU 上跑得更快、吞吐更高。它本身实现了很多自定义算子，依赖于 PyTorch 的底层能力，但不直接面向模型训练。类比 vLLM 更像一个高性能加油站，专门为大模型高速服务。

所以一个完整的大模型应用链路可能是：用 PyTorch 训练模型，用 vLLM 把模型部署成推理服务，用 LangChain 编排业务流程去调用 vLLM 的 API。三者各管一段，组成上下游关系。

3.3 AMD 显卡与 PyTorch 的适配问题

AMD 显卡装 PyTorch，是个老生常谈的痛点了。简单说：Linux 上通过 ROCm 体系可以跑，Windows 上受限比较大。

ROCm 是 AMD 的对标 CUDA 的异构计算平台，PyTorch 官方从 2.0 开始逐步支持 ROCm 版本，你可以从官网找到 rocm5.6、rocm6.0 对应的 wheel 包。如果你用的是 Linux 系统的 AMD 显卡，比如 RX 7900 系列，可以试试按官网指引安装：

bash复制pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0

装好之后验证 torch.cuda.is_available()，ROCm 版本的 PyTorch 会把 AMD GPU 伪装成 CUDA 设备返回，所以这个函数返回 True 不代表是 NVIDIA，只是接口兼容。

至于 Windows 下 AMD 显卡，官方 ROCm 支持到现在都还不完整，社区方案大多要折腾驱动和补丁，稳定性和使用体验都不太行。我的建议很直接：如果要做深度学习，优先 NVIDIA 显卡；实在只有 AMD 机器，先装 CPU 版把代码逻辑跑通，等有 GPU 机器再切过来，成本最低。

4. 实战项目：TCN+Transformer 股票预测的完整思路

4.1 股票预测为什么用 TCN+Transformer

最近“pytorch 的 TCN 时间卷积网络 + transformer 实战股票预测”这个组合被问得很多。先说清楚，股票预测本质是一个时间序列预测任务：输入过去一段时间的价格、成交量等数据，预测未来短时间内的走势。

TCN（Temporal Convolutional Network）是一种时序卷积网络，它的特点是：

用因果卷积保证信息只从过去流向未来，不会“偷看”未来数据；
用扩张卷积（dilated convolution）增大感受野，让网络能看到更长时间范围的信息；
配合残差连接，深层网络也比较好训练。

Transformer 则擅长捕捉序列中远距离的依赖关系，特别是自注意力机制能对时间步之间的内在关联进行建模。把 TCN 和 Transformer 串起来，比较常见的思路是：先用 TCN 从原始序列里提取局部时序特征，把多个时间步的信息压成一组更高层的特征序列，再送入 Transformer Encoder 捕获全局依赖，最后接几层全连接输出预测值。这样结合的好处是，TCN 帮 Transformer 减负，不需要序列里每个位置都直接做全局注意力，计算效率更高；Transformer 又补足了 TCN 在超长依赖上的不足。

4.2 模型结构设计与 PyTorch 代码骨架

我先给一个可以直接跑通的模型骨架。数据预处理环节，建议用滑窗把原始行情转成样本：每 60 个交易日的数据（比如开盘价、收盘价、最高价、最低价、成交量）作为输入，预测下一个交易日的收盘价涨跌。

TCN 部分的 PyTorch 实现核心是一个残差块：

python复制import torch
import torch.nn as nn
import torch.nn.functional as F

class TCNBlock(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, dilation=2, dropout=0.2):
        super().__init__()
        self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size,
                               padding=(kernel_size - 1) * dilation // 2, dilation=dilation)
        self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size,
                               padding=(kernel_size - 1) * dilation // 2, dilation=dilation)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(dropout)
        self.resample = nn.Conv1d(in_channels, out_channels, 1) if in_channels != out_channels else None

    def forward(self, x):
        res = x if self.resample is None else self.resample(x)
        out = self.dropout(self.relu(self.conv1(x)))
        out = self.dropout(self.relu(self.conv2(out)))
        return self.relu(out + res)

Transformer Encoder 部分直接用 PyTorch 自带的层：

python复制class HybridModel(nn.Module):
    def __init__(self, input_dim=5, hidden_dim=64, num_layers=2, nhead=4, seq_len=60):
        super().__init__()
        self.tcn_blocks = nn.Sequential(
            TCNBlock(input_dim, hidden_dim, dilation=1),
            TCNBlock(hidden_dim, hidden_dim, dilation=2),
            TCNBlock(hidden_dim, hidden_dim, dilation=4),
        )
        encoder_layer = nn.TransformerEncoderLayer(d_model=hidden_dim, nhead=nhead, batch_first=True)
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.pos_encoding = nn.Parameter(torch.randn(1, seq_len, hidden_dim) * 0.02)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        # x: (batch, seq_len, input_dim)
        x = x.transpose(1, 2)  # TCN 用 Conv1d (batch, channels, seq_len)
        x = self.tcn_blocks(x)  # (batch, hidden_dim, seq_len)
        x = x.transpose(1, 2)  # (batch, seq_len, hidden_dim)
        x = x + self.pos_encoding
        x = self.transformer(x)
        x = x[:, -1, :]  # 用最后一个时间步输出
        return self.fc(x)

几点说明：位置编码做成可学习的参数，是为了让 Transformer 感知时间顺序；最后的 x[:, -1, :] 是取最后一个时间步的隐状态作为整条序列的表征；TCN 的扩张率逐步增加，是为了在不加深网络的情况下覆盖更大的时间窗口。

4.3 训练与评估的注意事项

这类项目里最大的坑是“未来函数”。比如用当天的收盘价数据去预测当天的涨跌，数据泄露的痕迹会非常隐蔽，导致回测效果漂亮得吓人，实盘却完全失灵。正确的做法是，第 T 天的预测，只能使用 T 日以前（不包含 T 日）的信息。

数据切分上，时间序列不能随机打乱后划分训练集和测试集，这样会把未来信息混进训练。要按时间顺序切分，比如前 80% 做训练，后 20% 做验证，并且验证集的起点要晚于训练集的终点。

评估指标除了 MSE，也要看方向准确率，也就是预测涨跌方向和实际涨跌方向是否一致。股票预测的难点不只是预测准不准，更在于方向判得对不对。我在实际测试中发现，仅仅看 MSE 收敛，有时候模型的预测值和真实值整体偏移，方向准确率却一直徘徊在 50% 附近，说明模型其实没学到有效规律。

最后提醒一句：股票预测本质上是一个信号极其微弱、噪声极高的任务，论文和教程里展示的高准确率往往有很强的条件限制。把这一类项目当深度学习的练手题很有价值，但别指望用它直接炒股赚钱。

5. 进阶操作与日常工具技巧

5.1 冻结模型部分的三种姿势

“PyTorch 冻结部分模型”这个话题，做迁移学习和微调时绕不开。最核心的原理是，把某些参数的 requires_grad 设为 False，这样优化器就不会更新它们。

第一种，全模型冻结，只训练分类头：

python复制for param in model.parameters():
    param.requires_grad = False
for param in model.fc.parameters():
    param.requires_grad = True

第二种，只冻结主干网络的前几层。这时不能无脑遍历所有参数，应该按模块名字区分，比如：

python复制for name, param in model.named_parameters():
    if 'backbone.layer1' in name or 'backbone.layer2' in name:
        param.requires_grad = False

第三种，在构建优化器时直接过滤：

python复制optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)

这招配合 requires_grad 使用，能确保冻结的层不会出现在优化器里，省显存也省计算。注意一个细节：PyTorch 的 BatchNorm 层在冻结时表现很特殊，如果主干网络里含 BN 层，只设 requires_grad=False 不够，还要把 BN 层设成 eval() 模式，否则 running mean/var 仍会更新，影响微调效果。

5.2 bin 格式转 pt 的实操

网友问“pytorch bin 转换为 pt”，通常是指把 HuggingFace 模型仓库里的 pytorch_model.bin 权重文件，转成标准的 .pt 或 .pth 文件。

bin 和 pt 内部的本质都是 state_dict，即一个从参数名到张量的字典。差别只在于文件的后缀和可能的序列化方式。所以“转换”实际上只需要加载再保存：

python复制import torch

state_dict = torch.load("pytorch_model.bin", map_location="cpu")
torch.save(state_dict, "model.pt")

如果你的模型结构定义在代码里，可以直接把权重加载到模型实例上，再保存整个模型：

python复制model = MyModel()
model.load_state_dict(torch.load("pytorch_model.bin", map_location="cpu"))
torch.save(model.state_dict(), "model.pt")

注意一个细节：HuggingFace 的 bin 文件可能是 state_dict 直接存储，也可能被 key 包了一层，比如有些 old checkpoint 需要 state_dict = torch.load(...) 再 .get('model', ...)。建议先 print(state_dict.keys()) 观察下结构，再决定下一步。

5.3 STDP 网络在 PyTorch 中的实现要点

STDP（Spike-Timing-Dependent Plasticity，脉冲时序依赖可塑性）是神经科学里一种突触可塑性规则，核心思想是：如果前一个神经元先发放脉冲，后一个神经元跟着发放，两者之间的连接就增强；反过来，如果后一个先发放，连接就减弱。它是脉冲神经网络（SNN）领域一个重要方向。

在 PyTorch 里实现 STDP，难的不是规则本身，而是怎么把“事件驱动”塞进张量计算框架。常规思路有两种：

一是离线事件循环。把输入脉冲序列离散成时间步，在每个时间步更新突触权重。伪代码思路：

python复制for t in range(num_steps):
    pre_spike = pre_input[:, t]   # 输入脉冲
    post_spike = post_neuron(pre_spike)
    delta_w = pre_trace * post_spike - post_trace * pre_spike
    weight += lr * delta_w
    pre_trace = pre_trace * decay + pre_spike
    post_trace = post_trace * decay + post_spike

这里是利用“迹”变量来模拟突触前和突触后的历史活动，再用事件配对规则更新权重。第二种方式是自定义 autograd.Function，把 STDP 当成一种特殊的权重更新传播方式，实现更复杂，但能跟梯度计算整合。

实际实现中很容易踩坑的是训练不稳定：STDP 的权重更新对脉冲时序非常敏感，学习率稍大，权重就发散。建议把学习率设得很小，比如 1e-4 甚至 1e-5，并且给权重加上限幅。这种网络的调试难度比 BP 网络高不少，建议先在玩具数据集上跑通整个流程，再去做大规模实验。

6. 高频故障排查速查表

把我在实战中高频遇到的问题整理成速查表，方便按症状快速定位：

症状	大概率原因	解决方案
`import torch` 报错 `OSError: ... not a valid Win32 application`	Python 位数或架构与 wheel 不匹配	用 64 位的 Python，下载对应 `win_amd64` 的 wheel
`torch.cuda.is_available()` 返回 `False`	装了 CPU 版，或驱动太旧	`pip list` 看包名是否带 `+cu`；升级显卡驱动
CUDA 可用但 `get_device_name` 报错	显存被占满或 CUDA 初始化失败	关闭其他 GPU 程序，重启终端，检查驱动
pip 下载到一半断掉	网络不稳定	用浏览器下载 wheel 再本地安装
`torch` 和 `torchvision` 版本不匹配	手动分开安装导致版本漂移	用官方一行命令一起安装
`DataLoader` 加载数据慢	CPU 和 GPU 数据流水线不匹配	增大 `num_workers`，开启 `pin_memory=True`
显存不断增长直到 OOM	训练循环里有张量保留了计算图	检查 `.item()`、`.detach()`，关掉无关变量的梯度
`numpy` 版本冲突	环境里旧版 numpy 与新库冲突	卸载重装 numpy，或重建干净环境

这套速查表没法覆盖所有问题，但大多数人卡住的地方基本都是这些。遇到查不到的问题，先看控制台输出的最后几行报错，再顺着报错里的文件名和目录去找线索，比直接复制报错搜全网高效得多。

最后分享一个我实际养成的小习惯：每建一个新环境，第一件事不是装 PyTorch，而是先写一份 requirements.txt，把会用到的库全部列出来，之后每次安装都从这份文件走，能极大减少环境漂移的烦恼。还有，如果实验代码里反复出现 torch.cuda.is_available() 判断，我会把它抽成一个公共工具函数，统一处理 CPU/GPU 切换逻辑，避免每个脚本里各写一套，既容易出错又难维护。PyTorch 这东西，前期环境打通了，后面写代码能省一半的精力，祝大家都能顺利跑通自己的第一个模型。