企业官网建设流程全解析

1. PyTorch到底是个什么：给新手的项目定位与选型分析

我接触深度学习框架这些年，PyTorch是我见过口碑发酵最快、新手入门门槛最低的一个。先说清楚它是什么：PyTorch是一个基于Python的开源机器学习库，由某大型研究机构的人工智能团队在2017年正式推出，底层用C++实现核心计算，对外用Python提供API。它的看家本领是自动求导和动态计算图，这两个特性直接决定了为什么过去几年里越来越多论文代码、开源项目、企业生产环境都在往它身上迁移。

很多人第一次接触PyTorch是因为跑别人的模型，或者学校课程布置了相关作业，再或者想复现某个顶会论文的实验结果。无论哪种场景，你都需要先完成一件事：把PyTorch装好，然后把手伸到它的核心数据结构"张量"（Tensor）里摸一圈，再学会用它的神经网络模块搭一个简单的模型。这套流程走通了，后面学什么卷积、Transformer、分布式训练，都是在这个地基上盖楼。

那为什么博主要把标题定成"安装与基本使用"？因为从我带的经验来看，新手80%的挫败感不是来自模型调参，而是来自环境装不上、版本对不齐、GPU用不起来这些基础设施问题。把这部分彻底打通，后面学习效率能翻几倍。这篇博文我会从框架选型讲起，然后拆解安装的全过程，再带你走一遍张量操作、自动求导、模型搭建、训练循环这四个核心环节，最后把我在实际安装和调试中踩过的坑、总结的排查经验一并整理给你。全程用大白话讲，同时也会把命令和代码给你贴出来，你照着抄就行。

适合看这篇内容的人，大概分三类。第一类是完全没有深度学习经验、刚拿到一台电脑准备入门的纯新手；第二类是已经会跑别人的代码，但自己从来没从零装过环境、不懂底层逻辑的群体；第三类是需要在多台机器上反复部署PyTorch环境，想找一份可靠避坑指南的工程同学。不管你现在处于哪个阶段，这篇文章的目标都是让你跟着操作完，机器上能跑起PyTorch，而且你能理解每一步到底在干什么，而不是机械复制命令。

2. 安装前的关键决策：版本、显卡与环境的权衡

2.1 先认清自己的硬件条件再动手

安装PyTorch之前，第一件事不是敲命令，而是搞清楚你的电脑具备什么条件。核心问题就一个：有没有独立显卡，以及这个显卡是不是NVIDIA的。

如果你用的是普通办公笔记本，或者核显机器，那基本就走CPU路线。CPU版本完全能用，尤其在处理小规模数据和经典模型（比如全连接网络、小型CNN）时，性能差距远没有你想象的那么大。我早期做实验用的就是一台没有独显的办公笔记本，跑MNIST手写数字识别，一个epoch大概几十秒，完全能接受。只不过一旦数据量变大、模型变深，训练时间会明显拉长，这是物理限制，没有太多绕路空间。

如果你有NVIDIA显卡，那强烈建议装CUDA版本，训练速度能提升十倍甚至几十倍，这个差距在稍微大一点的模型上会非常明显。当然，如果你用的是AMD显卡或者Apple Silicon芯片的Mac，也有对应的支持方案，但我个人建议新手阶段优先走CPU或NVIDIA CUDA路线，生态最成熟、教程最多、遇到的问题也最容易搜到答案。

怎么快速确认显卡型号？Windows下打开任务管理器，点到"性能"标签页，看左侧有没有"GPU"项，再确认GPU名称里有没有NVIDIA字样。Linux下直接执行lspci | grep -i nvidia，有输出就说明有NVIDIA设备，没输出就在网上搜一下自己的设备型号。

2.2 版本选型的内在逻辑：为什么不要无脑装最新版

很多新手喜欢一上来就装最新版，觉得最新就等于最好。这个习惯在PyTorch生态里要稍微克制一下。PyTorch的版本迭代非常频繁，基本每半年就出一个大版本，而它配套的CUDA版本、Python版本、显卡驱动版本之间有严格的兼容矩阵。你装一个最新版确实能用，但如果你的显卡驱动版本比较老，或者Python版本偏旧，很可能装完就报"CUDA driver version is insufficient"或者"No module named 'torch'"这类错误。

我的建议是：Python用3.9到3.11之间的稳定版本，PyTorch用官方当前还在维护的稳定版，比如2.x系列。不要追求最新，也不要停在1.x老版本上固步自封。具体选哪个，直接去PyTorch官网首页，它会根据你选择的操作系统、安装方式、CUDA版本，自动生成对应的安装命令，这是最权威的入口。

另外要特别提醒一个概念：CUDA工具包和PyTorch内置的CUDA运行时是两回事。PyTorch的pip安装包自带了一套CUDA运行库，所以你不需要提前在系统里装完整的CUDA Toolkit，只要显卡驱动够新就行。检查驱动是否满足要求，NVIDIA官方有命令行工具，Windows下在命令提示符执行nvidia-smi，看右上角的CUDA Version，这个数字只要大于等于PyTorch要求的最低版本，基本上就稳了。

2.3 虚拟环境：让你免于环境混乱的保命手段

安装Python包最怕的就是全局环境一团乱麻。今天为了项目A装了一个PyTorch 1.13，明天为了项目B又装了一个PyTorch 2.1，两个项目依赖的版本直接冲突，跑A的时候B用不了，跑B的时候A报错。解决这个问题的标准方案就是虚拟环境。

虚拟环境的本质是给每个项目创建一套独立的Python运行目录，互相之间不影响。常用的工具有venv、conda、virtualenv。我个人更推荐用conda来管理深度学习环境，尤其是新手，因为conda不仅管Python包，还能顺便帮你创建不同Python版本的独立环境，并且很多深度学习相关的依赖包在conda源里有预编译版本，装起来更省事。如果你之前装过Anaconda或者Miniconda，那直接用它就行。

创建一个新环境的命令非常简单：

conda create -n pytorch_env python=3.9

这个命令的意思是：创建一个名为pytorch_env的新环境，指定Python版本为3.9。创建完成后，用conda activate pytorch_env进入这个环境，之后再执行任何pip install或者conda install，都只影响这个环境，不会污染系统全局Python。等这个环境玩坏了，直接删掉重建，五分钟就能恢复原状，比手动收拾全局环境舒服得多。

3. PyTorch安装全流程实操：从零到跑通一条命令

3.1 CPU版本的快速安装方法

如果你确认自己走CPU路线，安装过程是最简单的。在确保已经激活虚拟环境的情况下，执行下面这条命令：

pip install torch torchvision torchaudio

这里解释一下这三个包分别是什么。torch是核心库，负责张量运算、自动求导、神经网络模块等一切核心逻辑。torchvision是计算机视觉的配套工具库，里面包含常用的数据集加载器、预训练模型、图像变换函数。torchaudio是音频处理配套库。新手一开始学基础语法，只用torch就够了，但后面只要你跑视觉模型，就一定会用到torchvision，索性一起装上，省得以后再折腾。

装完以后怎么验证是否成功？打开Python交互环境，输入两行代码：

import torch print(torch.__version__)

如果你能看到一个版本号输出，比如2.1.2，说明安装成功。如果你还关心CPU能不能跑，可以再看一眼print(torch.backends.mkl.is_available())，输出True说明底层优化库正常加载，计算性能会有保障。

3.2 GPU版本的精确安装：从官网复制命令

如果你有NVIDIA显卡，GPU版本的安装稍微多两个步骤。第一步是确认显卡驱动正常，执行nvidia-smi能看到类似下面的输出：

+-----------------------------------------------------------------------------+ | NVIDIA-SMI 525.85.07 Driver Version: 525.85.07 CUDA Version: 12.0 | +-----------------------------------------------------------------------------+

这一步只要能跑出来，右上角的CUDA Version不用太纠结，它只是表示这个驱动最高支持到CUDA 12.0，并不是说系统里已经装了CUDA 12.0。你只要把它和PyTorch官网要求的CUDA版本对照一下，确保驱动的支持上限不低于PyTorch要求的版本就行。

第二步是到PyTorch官网（pytorch.org）首页，选择你的配置。选好以后官网会生成这样一条命令：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

注意命令结尾的cu118，这个表示PyTorch内置的是CUDA 11.8版本的运行库。有些同学看到这个会忍不住手痒去下载一个11.8的CUDA Toolkit装到系统里，完全没必要。PyTorch安装包自带的运行库已经包含了它需要的所有CUDA组件，你只需要保证显卡驱动版本够新。

GPU版本安装完成后，验证方式比CPU版多一步：

import torch print(torch.__version__) print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

重点是第二行，如果输出True，说明PyTorch成功检测到了你的显卡。第三行会输出你的显卡型号名称，比如NVIDIA GeForce RTX 3060。如果第二行是False，哪怕你装了GPU版本，程序也会默默退化为CPU模式运行。这也是很多新手最常遇到的隐性问题——以为自己用了GPU，实际上在煎熬地等CPU跑模型。所以装完之后，这三行验证代码一定不能省。

3.3 为什么不建议用源码编译安装

有些进阶教程会告诉你从源码编译安装PyTorch，理由是能针对你的CPU指令集做专门优化，或者你想修改框架底层代码。这个想法本身没问题，但我非常不建议新手走这条路。原因很简单：PyTorch源码非常大，编译一次要下载大量依赖，耗时一两个小时起步，中间还经常因为网络问题或者编译器版本不匹配而失败。而官方预编译包已经做了通用优化，对绝大多数场景来说，性能已经足够好。

如果你确实有特殊需求，比如要在一个老旧的CPU上跑新版本，或者要改框架源码，那建议你等基础使用熟练以后再考虑源码编译。至少在入门阶段，先把最简单可靠的路线走通，自信心和成就感比那一点点的边际性能更宝贵。

3.4 换源安装的姿势与雷区

国内开发者安装PyTorch时经常遇到一个尴尬：默认的pip源在国外，下载速度极慢，甚至十几分钟卡在进度条一动不动。解决方案是换用国内镜像源。最常用的清华源命令长这样：

pip install torch torchvision torchaudio -i https://pypi.tuna.tsinghua.edu.cn/simple

但这里有一个非常重要的雷区：如果你的安装命令是从PyTorch官网复制的带--index-url的GPU版本命令，那千万不要再加-i参数去换源。因为带--index-url的意思是让pip从PyTorch官方Whl仓库下载，这个仓库里才有对应CUDA版本的torch包，你用清华源去装，大概率只会装到CPU版本，因为清华源并没有同步PyTorch官网的所有CUDA版本包。我见过好几个同学因为手贱加了镜像参数，结果GPU环境怎么都搞不定，最后把这个原因排查出来，自己都哭笑不得。

所以结论很简单：CPU版本可以用任何镜像源加速；GPU版本就用官网生成的原始命令，最多通过先下载Whl文件再本地安装的方式绕开网络延迟，但不要手动改源。

3.5 conda安装方式对比

前面讲的主要是pip安装，其实conda也能装PyTorch。执行conda install pytorch torchvision torchaudio -c pytorch就可以。conda安装的好处是它的依赖管理更严格，会自动解析并装上匹配的依赖库；坏处是conda默认源在国外，速度也不快，而且如果你之前用pip装过其他包，混用conda和pip偶尔会引出依赖冲突。

我的个人建议是：如果你在用Anaconda环境管理Python，那用conda装也行；如果你用的是原生Python加venv虚拟环境，就直接pip装。不管哪种方式，保持"一个环境内尽量只用一种包管理器"的原则，能减少很多杂七杂八的兼容问题。

4. 核心基础操作：张量、自动求导与设备切换

4.1 张量的本质与创建方式

安装只是热身，真正入门PyTorch要从张量开始。张量英文叫Tensor，说白了就是一个多维数组。你可以把它理解成比NumPy数组多了几个特性的"超级数组"——它自带自动求导能力，能无缝接入GPU运算，还能自动记录计算历史。这些特性是深度学习模型训练的底层基石。

创建一个张量，最简的方式：

import torch a = torch.tensor([1, 2, 3]) b = torch.zeros(2, 3) c = torch.ones(2, 3) d = torch.randn(2, 3) e = torch.arange(0, 10, step=2)

这几行分别创建了什么？a是一个一维张量，内容就是1、2、3；b是全零矩阵，形状是2行3列；c是全一矩阵；d是从标准正态分布中随机采样的2×3矩阵；e是从0开始到9，步长为2的一维序列，结果是[0, 2, 4, 6, 8]。

新手最容易犯的错是混淆torch.Tensor()和torch.tensor()。torch.Tensor()是一个类构造器，它会根据你传入的形状创建一个未初始化数据的张量，里面的值完全是内存里的垃圾数；而torch.tensor()则会根据你传入的实际数据创建张量，值就是你给的。日常使用请优先用torch.tensor，或者用torch.zeros、torch.randn这些明确初始化的函数，避免张量里莫名其妙出现不知道哪来的数字。

张量之间的基本运算和NumPy几乎一样，直接做加减乘除、矩阵乘法：

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) y = torch.tensor([[5.0, 6.0], [7.0, 8.0]]) add = x + y mul = x * y matmul = torch.matmul(x, y)

这里要注意区分*和torch.matmul。*是逐元素相乘，两个张量的形状需要能广播到一致；torch.matmul是真正的矩阵乘法，要求第一个张量的最后一维等于第二个张量的倒数第二维。这个区别在代码里非常容易写错，一旦形状对不上，PyTorch会报错提示维度不匹配，这时候不要慌，第一反应应该都是检查用对了运算方式没有。

4.2 自动求导机制：为什么它是深度学习的引擎

张量最特别的地方在于，你可以把它设置为需要计算梯度：

x = torch.tensor([2.0], requires_grad=True) y = x ** 2 + 3 * x y.backward() print(x.grad)

这段代码做了什么？我们定义了一个张量x，初始值是2.0，设置requires_grad=True表示要追踪对它的所有运算。然后计算y = x² + 3x，调用y.backward()触发反向传播，PyTorch就会自动计算y对x的梯度。根据求导公式，dy/dx = 2x + 3，代入x=2.0，结果是7.0。x.grad里面保存的就是这个梯度值。

这个机制是深度学习训练的核心。训练神经网络本质上就是反复做这样一件事：算出一个损失值（衡量模型预测和真实值差距的数值），求损失对每个参数的梯度，然后沿着梯度的反方向更新参数，让损失越来越小。如果手写这些梯度公式，那简直是一场灾难，尤其当模型有成百上千万个参数时，根本不可能人工推导。PyTorch的自动求导把这个过程全部自动化了，你只需要把前向计算写好，损失算出来，调一个backward()，梯度就自动算好了放在每个参数的.grad属性里，直接拿去用就行。

那依赖梯度有什么需要注意的？两个点。第一，只有浮点型张量才能设置requires_grad=True，整数型会直接报错。第二，每次调用backward()后，梯度会被累加到原来的值上，如果模型训练中你在多个batch上循环，不清零的话梯度会一直叠加，导致参数更新混乱。所以PyTorch在优化器里提供了optimizer.zero_grad()这个方法，作用就是把历史的梯度清零，训练循环里每轮更新前必须调用它。这个坑新手几乎必踩，很多同学训练时损失曲线乱跳，检查半天，最后发现就是忘了清零梯度。

4.3 CPU与GPU之间的数据流转

张量在CPU和GPU之间的切换，就是一行代码的事：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") x_cpu = torch.randn(3, 3) x_gpu = x_cpu.to(device)

这里定义了一个device变量，如果检测到CUDA可用就使用GPU，否则退回CPU。然后将CPU上的张量x_cpu通过.to(device)搬到设备上。这个写法在深度学习项目中几乎是标准模板，你会在几乎每一个开源代码里看到它。cuda:0表示第0块显卡，如果你有多张显卡，可以根据显存大小和负载情况选具体的卡号，比如cuda:1。

有一个非常经典的新手报错：在GPU上计算的张量，直接拿去和CPU上的张量做运算，PyTorch会抛出一个"Expected all tensors to be on the same device"的异常。解决方案就是统一所有张量的设备。我写代码的习惯是在程序开头就定义好device变量，所有需要参与模型运算的张量，创建后立刻.to(device)，这样能最大程度避免这类错误。

还有一个性能上的注意点：GPU和CPU之间的数据传输开销很大。训练循环里，每一轮都要把数据搬到GPU、把结果搬回CPU，这些操作如果太频繁，反而会让训练变慢。正确做法是尽量让数据在GPU上多待几家步，减少来回搬运的次数。比如验证模型时，把整个验证集先搬到GPU上，一次性跑完再搬回结果，而不是每条样本单独搬一次。

5. 模型构建与训练循环：动手搭建第一个神经网络

5.1 认识神经网络模块接口

PyTorch用模块化的方式组织模型，核心类是torch.nn.Module。你定义一个模型，最常见的方式是继承这个类，然后在__init__方法里声明需要用到的层，在forward方法里定义前向计算逻辑。

我们写一个最简单的两层全连接网络，用来做手写数字分类：

import torch.nn as nn class SimpleNet(nn.Module): def __init__(self): super().__init__() self.fc1 = nn.Linear(784, 256) self.relu = nn.ReLU() self.fc2 = nn.Linear(256, 10) def forward(self, x): x = x.view(-1, 784) x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x

这个模型干什么？输入是一张28×28像素的灰度图，我们把它展平为784个特征（x.view(-1, 784)就是把多维数据压平成二维矩阵，-1表示这一维自动推断）。第一层全连接层把这784维映射到256维，中间经过一个ReLU激活函数给模型引入非线性能力，第二层全连接层把256维映射到10维，对应数字0到9的分类得分。

有一些细节你可能会忘记但很重要。super().__init__()这行必须写上，它是在初始化父类的能力，不写的话模型内部的一些注册机制不会正常工作。定义层的时候，有参数的层（Linear、Conv2d等）统一放在__init__里，但没有参数的激活函数层（ReLU、Dropout等）也可以放在forward里直接用函数形式调用，两种写法都对，不影响功能。模型一旦定义好，你可以打印一下print(model)，它会整齐地列出每一层结构、参数个数，这个输出对检查模型搭建是否正确非常直观。

5.2 数据加载管线：从原始数据到批次张量

训练模型不能一次性把所有数据都塞进去，因为内存和显存都受不了。标准做法是把数据分成若干小批次（batch），一批一批送进去训练。PyTorch的数据加载核心是两个类：torch.utils.data.Dataset和torch.utils.data.DataLoader。

Dataset负责定义"怎么从原始数据里取一条样本"，DataLoader负责定义"怎么批量地、随机地、并行地把样本包装成张量"。用视觉数据集举例，可以这样构造：

from torch.utils.data import Dataset, DataLoader from torchvision import datasets, transforms transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset = datasets.MNIST( root='./data', train=True, download=True, transform=transform ) train_loader = DataLoader( dataset=train_dataset, batch_size=64, shuffle=True, num_workers=2 )

这个例子里的transforms.Compose把转换操作按顺序组合起来：先ToTensor()把PIL图像变成张量，顺便把像素值从0到255缩放到0到1区间；再Normalize做标准化，使用MNIST数据集的均值和标准差，让数据分布更接近标准正态分布，有助于模型收敛。DataLoader的batch_size=64表示每批取64张图，shuffle=True表示每个epoch开始时打乱数据顺序，防止模型学到样本排列顺序的虚假规律，num_workers=2表示用两个子进程负责读取数据，能加快数据装载速度。

新手最常忽略的是数据集下载这一环，代码里写了download=True，但如果网络不稳定或存储目录权限不对，下载会报错。建议提前手动把数据集文件下载好，放到root指定的目录下，然后把download设为False，后续运行就不会被网络问题绊住。

5.3 损失函数、优化器与完整训练循环

有了模型和数据，接下来就要定义训练的标准动力装置：损失函数和优化器。损失函数计算模型预测和真实标签之间的差距，优化器根据这个差距来调整模型参数。

import torch.optim as optim model = SimpleNet().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.01)

这里用的是交叉熵损失，特别适合多分类问题，它内部已经包含了Softmax处理，所以你模型输出层的原始得分可以直接喂给它，不用自己额外做Softmax。优化器选了随机梯度下降SGD，学习率设为0.01。学习率是控制每一步参数调整幅度的超参数，设太大模型会震荡甚至发散，设太小训练会极其缓慢。0.01对这个小模型来说是个比较中庸的起点。

训练循环是深度学习代码里最经典的模板，几乎所有的训练脚本都长这样：

for epoch in range(5): running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}')

这个循环里每一步对应什么含义？读取一批数据，搬到GPU上；把优化器内部的梯度清零（前面说过，不清零会累加）；把图片送进模型得到输出；用损失函数计算输出和真实标签的差距；反向传播自动算出所有参数的梯度；优化器用梯度更新参数，完成一步训练。一个epoch表示完整遍历一次整个训练集，循环里跑了5个epoch，训练结束后模型的损失应该会逐步下降。

很多新手跑完训练后，不知道怎么确认模型训练效果如何，这时候需要加一个评估环节。设置模型为评估模式：

model.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in test_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Accuracy: {100 * correct / total:.2f}%')

这段代码里有两个关键点。第一，model.eval()通知模型切换到评估模式，这会关闭Dropout等只在训练时生效的层。第二，用with torch.no_grad():包裹推理过程，告诉PyTorch不需要记录梯度，从而节省大量显存和计算资源。如果不写这个上下文管理器，推理时框架仍然会为每个操作建立计算图，白白浪费资源，甚至在小显存显卡上直接OOM。

5.4 模型保存与加载：把训练成果沉淀下来

模型跑完训练步后，成果要保存下来，方便下次直接加载使用，不用重新训练。PyTorch提供两种常见的保存方式，对应不同使用场景。

第一种是只保存参数：

torch.save(model.state_dict(), 'model_weights.pth')

state_dict()把模型里的每个参数张量打包成一个有序字典。加载的时候，你需要先构建一个和原来结构完全一样的模型实例，然后把保存的参数灌进去：

model = SimpleNet() model.load_state_dict(torch.load('model_weights.pth')) model.eval()

第二种是保存整个模型：

torch.save(model, 'model_full.pth')

这种方式的优点是加载时不用重新定义模型结构，直接model = torch.load('model_full.pth')就行。缺点是比较吃存储空间，而且在跨环境迁移时更容易出问题（因为保存的是整个对象，包括它的类引用关系）。我个人的习惯是日常实验用方式一保存参数就够了，这样最清晰，也是开源社区的主流做法。

这里提醒一个藏得很深的坑：如果你在GPU上训练并保存模型，然后用CPU加载，直接torch.load会报设备不匹配的错误。解决方法是加载时指定map_location='cpu'：

model.load_state_dict(torch.load('model_weights.pth', map_location='cpu'))

反过来，模型在CPU训练，后来想在GPU上跑，就先加载模型，再调用model.to('cuda')。每次切换设备都要注意这种迁移问题，代码写多了自然就有这个肌肉记忆了。

6. 安装与使用全流程高频问题排查实录

6.1 安装阶段最常见的四类报错

安装阶段报错五花八门，但我观察下来，大约八成的报错都可以归入下面这四类。

第一类：No module named 'torch'。这个报错通俗说就是Python找不到PyTorch模块。原因往往是虚拟环境没激活，或者pip装到了另一个Python解释器里。排查思路是检查你当前用的是哪个环境的Python，执行which python（Windows是where python），然后确认这个路径下的site-packages里有没有torch目录。

第二类：pip下载超时或速度极慢。这类问题国内用户最常遇到，解决方法是前面提到的换源，CPU版本换清华源或者阿里源都可以。GPU版本建议不要改源，可以退一步选择先下载Whl文件再本地安装，或者使用国内开发者搭建的PyTorch镜像站，但一定要注意镜像站是否同步了你需要的那个CUDA版本文件。

第三类：CUDA相关报错。常见的有CUDA driver version is insufficient和RuntimeError: Found no NVIDIA driver on your system。前者说明显卡驱动版本太老，去NVIDIA官网更新驱动就好；后者说明驱动根本没装上，或者你在没有NVIDIA显卡的机器上装了CUDA版本。这时候着重检查nvidia-smi能不能跑，不能跑就先装驱动。

第四类：内存或磁盘空间不足。PyTorch的安装包动辄好几个GB，加上其他依赖，安装过程对磁盘空间有一定要求。如果你安装时报Out of Memory或者"Disk full"，检查一下磁盘剩余空间，清理掉无用的缓存文件再重试。特别要注意的是pip缓存目录，有时候装了好几次失败，缓存里积压了大量无用的压缩包，能清掉好几个GB的空间。

6.2 运行阶段容易踩的逻辑坑

环境装好后，运行代码阶段的坑也不少。我挑三个高频问题重点讲。

第一个是"Expected all tensors to be on the same device"这类设备不一致报错。几乎是每个用GPU训练的开发者都遇到过的。产生原因是模型和数据迁移到GPU的时机不同步。排查方法很简单，在你报错前的那几个张量上打印一下.device属性，看看是谁在CPU上谁在GPU上，然后把不在统一设备上的转移过去就行。养成习惯：模型定义好以后立刻model.to(device)，数据从DataLoader取出来以后立刻.to(device)，这样这类报错基本能杜绝掉。

第二个是训练时损失不降甚至变成NaN。原因可能是学习率太大导致参数更新幅度过猛；也可能是数据预处理有问题，比如标准化参数填错；还可能是模型结构有数值不稳定因素。排查思路是先试着把学习率调小一个量级，再看数据标准化是否正确，最后逐个检查模型的激活函数是否选得不合适。损失一旦出现NaN，训练基本就只能重来了，所以防患于未然更重要。

第三个是DataLoader报num_workers相关错误，常见的是多进程相关问题。有些环境里num_workers设得过大或者系统资源受限，会导致子进程启动失败。新手阶段最稳妥的做法是先直接设num_workers=0，让数据在主进程里加载，虽然慢一点但绝对不会出多进程问题。后续需要提升训练速度再考虑调大这个参数，同时建议把数据加载相关代码放在if __name__ == "__main__":块里保护起来。

6.3 一条实用的排查路径

遇到报错不要慌，我总结了一套适合新手的三步排查法。第一步，看报错信息最后一行。Python的报错信息遵循就近原则，最后一行往往直接告诉你错误类型和出错代码，比如ZeroDivisionError: division by zero，一眼就能看出问题。第二步，把错误信息中的关键词复制到搜索引擎里搜，注意加上版本号信息，搜的时候优先看PyTorch论坛和官方文档。第三步，如果是环境问题，最省事的做法是直接重建虚拟环境，把之前的环境删掉，重新按照标准流程装一遍。很多诡异问题到最后都和某个依赖包版本错配有关，重建环境通常十分钟内搞定，比在乱糟糟的环境里翻找原因高效得多。

我在实际使用中还有一个习惯：把所有常用的验证代码整理成一个诊断脚本，每次新环境装完就跑一遍。这个脚本内容包括打印PyTorch版本、CUDA是否可用、显卡名称、能否在GPU上执行一个简单的矩阵乘法、数据加载器的随机打乱是否正常、一段快速的前向推理是否通过。整个过程不到一分钟，一旦通过了，我心里就有底，后面写代码基本不会在环境问题上耗时间。这个习惯建议你也试着建立起来。

就聊到这里，剩下的路就是需要你自己多动手把上面的代码敲一遍，踩过坑之后收获才是真属于你的。如果在某个报错上卡住了，记住先看最后一行错误信息，再带着关键词去向搜索引擎要答案，绝大部分问题都能在十分钟内解决。