基于 PyTorch 2.x 的大模型开发与微调专题【左扬精讲】—— Windows 深度学习环境搭建：从 Python 到 PyTorch 2.0 GPU 版本

基于 PyTorch 2.x 的大模型开发与微调专题【左扬精讲】—— Windows 深度学习环境搭建：从 Python 到 PyTorch 2.x GPU 版本

工欲善其事，必先利其器。在正式开始大模型开发与微调之前，搭建一个稳定、高效的深度学习开发环境是每一位 AI 开发者的必经之路。

本文将手把手教你在 Windows 系统上从零搭建 PyTorch 2.x 深度学习环境，涵盖 Python 安装、CUDA 驱动配置、PyTorch GPU 版本安装，以及针对不同 NVIDIA 显卡系列的版本选择建议。

PyTorch 2.x Python CUDA cuDNN Windows GPU NVIDIA 深度学习环境

学习重点提示

  • 必须掌握：Python 3.10+ 环境安装与 pip 包管理
  • 必须掌握：CUDA/cuDNN 的概念与安装原理
  • 必须掌握：根据显卡型号选择正确的 CUDA 版本
  • 必须掌握：PyTorch 2.x GPU 版本的 pip 安装与验证
  • 建议掌握：torch.compile 编译加速的开启方式

目 录

  1. 第一章：前置知识储备
  2. 第二章：Python 环境安装（Windows）
  3. 第三章：选择你的学习路径（CPU vs GPU）
  4. 3.1 方案A：PyTorch CPU 版本（入门学习）
  5. 3.2 方案B：PyTorch GPU 版本（深度学习研究）
  6. 第四章：安装 CUDA Toolkit 与 cuDNN（GPU 方案）
  7. 第五章：安装 PyTorch
  8. 5.1 安装 CPU 版本
  9. 5.2 安装 GPU 版本
  10. 第六章：环境验证
  11. FAQ 常见问题

第一章 前置知识储备

1.1 为什么 Windows 也可以做深度学习？

很多初学者认为深度学习必须在 Linux 系统上运行，这是一个常见的误解。实际上，Windows 完全可以胜任日常的深度学习开发和实验。Windows 10/11 系统配合 WSL2（Windows Subsystem for Linux）可以提供接近原生 Linux 的体验，即使不使用 WSL2，直接在 Windows 上通过 pip 安装 PyTorch 也能正常运行。

Windows 进行深度学习开发的优势包括：

  • 日常开发更便捷：Windows 文件系统操作、终端使用更符合普通用户习惯
  • 游戏显卡可用：GeForce 系列游戏显卡同样支持 CUDA，在 Windows 上驱动安装更简单
  • 开发工具丰富：VS Code、Pycharm 等 IDE 在 Windows 上体验更好
  • 办公娱乐不耽误：一台机器兼顾开发与日常使用

1.2 深度学习软件栈全景图

深度学习环境的核心组件

从底层到顶层，深度学习环境包含以下关键组件：

  • 物理层：NVIDIA GPU 显卡 → 提供并行计算算力
  • 驱动层：NVIDIA Driver → 操作系统与 GPU 通信的桥梁
  • 计算层：CUDA Toolkit → NVIDIA 提供的 GPU 并行计算开发工具
  • 加速层：cuDNN → 深度神经网络的高性能 CUDA 加速库
  • 框架层：PyTorch/TensorFlow → 深度学习框架 API
  • 应用层：你的模型代码 → 实际训练的神经网络

Why — 为什么需要这一整套软件栈？

你可以把深度学习环境想象成一家餐厅的运作流程：GPU 显卡就像厨房的炉灶，NVIDIA Driver 就像厨房的电路系统，CUDA 就像是烹饪配方库，cuDNN 就像是预制好的高汤底料，而 PyTorch 就像是厨师手中的菜谱。没有这一套体系，你的"深度学习菜肴"无法被"烹饪"出来。

1.3 PyTorch 2.x 最新版本信息（2026 年）

根据 PyTorch 官方文档 pytorch.org 的最新信息，当前稳定版本为 PyTorch 2.13.0，主要版本要求如下：

  • Python 版本：需要 Python 3.10 或更高版本（支持 Python 3.10-3.14）
  • CUDA 版本：支持 CUDA 12.6、CUDA 13.0、CUDA 13.3
  • 操作系统：支持 Windows 10/11，推荐 Windows 11

重要提示

当前 PyTorch 稳定版需要 Python 3.10 或更高版本。如果你的 Python 版本低于 3.10，请升级 Python 后再安装 PyTorch 2.0+。

第二章 Python 环境安装（Windows）

2.1 Python 安装方式选择

在 Windows 上安装 Python 有多种方式，这里推荐两种最常用的方法：

安装方式适用场景优点缺点
官网下载安装包 初学者、日常使用 官方纯净、一键安装 多版本管理不便
Chocolatey 包管理器 开发者、系统管理 命令行操作、可批量管理 需要先安装 Chocolatey
conda/miniconda 数据科学、隔离环境 环境隔离、包管理强 体积较大、与 pip 混用易出问题

本教程推荐使用官网下载安装包的方式，这是最简单、最直接的方式。

2.2 官方安装步骤

Step 1：下载 Python 安装包

访问 Python 官方网站下载页面：https://www.python.org/downloads/

点击 Download Python 3.14.x 按钮下载最新稳定版安装包（当前稳定版为 Python 3.14）。

版本选择建议

PyTorch 2.x 支持 Python 3.10-3.14，强烈建议选择 Python 3.13 或 3.14。这两个版本是当前主流稳定版本，生态成熟。

Step 2：运行安装程序

双击下载的 python-3.14.x-amd64.exe 文件，启动安装程序。

关键步骤：勾选 "Add Python to PATH"

这是最重要的一步！必须勾选 Add Python to PATH 选项，否则后续在命令行中无法直接使用 python 和 pip 命令。

☑ Add Python to PATH    ← 必须勾选！
      ☐ Install launcher for all users (recommended)
      ☐ Precompile standard library

Step 3：验证安装

打开 Windows Terminal 或 CMD，输入以下命令验证 Python 是否安装成功：

# 检查 Python 版本
python --version
# 输出应该是：Python 3.14.x

# 检查 pip 版本
pip --version
# 输出应该是：pip xx.x.x from ...

2.3 pip 换源（可选但强烈推荐）

由于 Python 官方源服务器在国外，国内用户下载包速度较慢。建议配置国内镜像源加速下载。

# 临时使用国内镜像安装
pip install torch torchvision torchaudio -i https://pypi.tuna.tsinghua.edu.cn/simple

# 或者永久配置清华镜像源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

国内常用镜像源

  • 清华镜像：https://pypi.tuna.tsinghua.edu.cn/simple
  • 阿里镜像：https://mirrors.aliyun.com/pypi/simple
  • 腾讯镜像：https://mirrors.cloud.tencent.com/pypi/simple

第三章 选择你的学习路径

在开始安装之前，你需要先确定自己的学习目标，选择合适的方案：

两种学习路径对比

对比项方案A：CPU 版本方案B：GPU 版本
适用场景 入门学习、语法练习、小数据集 大模型微调、深度学习研究、生产部署
硬件要求 任意电脑 需要 NVIDIA 显卡（RTX 系列）
安装复杂度 ⭐ 简单（3 步完成） ⭐⭐⭐ 中等（5-6 步）
安装耗时 约 5 分钟 约 30-60 分钟
训练速度 慢（CPU 计算） 快 10-100 倍（GPU 加速）
推荐指数 适合初学者快速上手 适合正式项目开发

3.1 方案A：PyTorch CPU 版本（入门学习）

如果你是以下情况，选择 CPU 版本：

  • 刚开始学习 Python 和机器学习
  • 只是想跑通 PyTorch 官方教程
  • 没有 NVIDIA 显卡（Mac、AMD 显卡、Intel 显卡）
  • 公司/学校电脑没有管理员权限

CPU 版本的优势

  • 安装简单，pip 直接安装，无需配置环境
  • 下载快（约 200 MB），国内镜像 30 秒安装完成
  • 任何电脑都能运行，不挑硬件
  • 适合学习 PyTorch 语法和 API

方案A 安装步骤（3 步）：

Step 1: 安装 Python
Step 2: 配置 pip 国内镜像源
Step 3: pip install torch torchvision（CPU版本）

✅ 完成！

直接跳转到 第五章 5.1 节 开始安装。

3.2 方案B：PyTorch GPU 版本（深度学习研究）

如果你是以下情况，选择 GPU 版本：

  • 有 NVIDIA 显卡（RTX 2060 及以上）
  • 需要训练大模型（如 LLaMA、ChatGLM、BERT）
  • 有大量数据需要处理
  • 追求训练速度，不想等太久

GPU 版本的优势

  • GPU 并行计算，训练速度提升 10-100 倍
  • 支持大模型训练（7B、13B、70B 参数）
  • 可以使用混合精度训练（FP16/BF16）
  • 支持多卡并行训练

方案B 安装步骤（6 步）：

Step 1: 安装 Python
Step 2: 确认 NVIDIA 显卡型号和驱动版本
Step 3: 根据显卡型号确定 CUDA 版本（参考 3.2 节）
Step 4: 安装 CUDA Toolkit（第四章）
Step 5: 安装 cuDNN（第四章）
Step 6: pip install torch torchvision（GPU版本）

✅ 完成！

继续阅读下面的 3.3 和 3.4 节，确定你的显卡对应的 CUDA 版本。

2026 年 7 月更新：推荐驱动版本 Game Ready 610.74

如果你的驱动版本低于 535，需要升级驱动。NVIDIA 官网提供两种驱动类型：

驱动类型版本适用场景推荐指数
Game Ready ⭐ 610.74 游戏玩家、深度学习/AI 训练 ✅ 推荐
Studio 610.62 视频剪辑、3D 渲染、创意工作 ⚪ 不推荐

为什么选 Game Ready？

  • Game Ready 驱动针对游戏和应用程序优化，对 PyTorch、TensorFlow 等深度学习框架兼容性更好
  • Studio 驱动主要优化创意软件（如 Premiere Pro、Blender）的性能，对深度学习无额外优势
  • 两者在 CUDA 支持上完全相同，深度学习性能无差异

下载步骤：

  1. 访问 NVIDIA 驱动下载页面
  2. 选择显卡型号：GeForce RTX 2070
  3. 选择操作系统：Windows 10/11 64-bit
  4. 下载类型选择 Game Ready 610.74
  5. 运行安装，重启电脑

3.3 NVIDIA 显卡与 CUDA 版本对应关系

什么是 Compute Capability（计算能力）？

在选择 CUDA 版本之前，我们需要理解一个核心概念：Compute Capability（计算能力）。这是 NVIDIA 为每一代 GPU 架构设定的技术指标，表示 GPU 硬件支持的功能特性。

Compute Capability 由主版本号和次版本号组成，格式为 X.Y：

  • 主版本号（X）：表示 GPU 架构的重大变革
  • 次版本号（Y）：表示同一架构下的具体实现变体

What — Compute Capability 对开发者意味着什么？

Compute Capability 决定了你的 GPU 能够运行哪些 CUDA 功能。较新的架构支持更多硬件特性（如 Tensor Core、RT Core），但也需要更新版本的 CUDA 工具链来调用这些特性。选择合适的 CUDA 版本，实际上就是让你的软件栈能够充分发挥 GPU 硬件的能力。

显卡系列与 Compute Capability 对照表

显卡系列架构代号Compute Capability代表型号推荐 CUDA 版本
GeForce GTX 10 系列 Pascal 6.0 / 6.1 GTX 1060, 1070, 1080, 1080 Ti CUDA 11.x
GeForce RTX 20 系列 Turing 7.0 / 7.5 RTX 2060, 2070, 2080, 2080 Ti CUDA 11.x
GeForce RTX 40 系列 Ada Lovelace 8.9 / 9.0 RTX 4060, 4070, 4080, 4090 CUDA 12.x / 13.x
GeForce RTX 50 系列 Blackwell 10.0 RTX 5060, 5070, 5080, 5090 CUDA 13.x

关于 RTX 4090

NVIDIA GeForce RTX 4090 采用 Ada Lovelace 架构，Compute Capability 为 8.9/9.0。这是上一代消费级旗舰显卡，拥有 16384 个 CUDA 核心和 24GB GDDR6X 显存，大模型微调的高性价比选择。随着 RTX 50 系列（Blackwell 架构）的发布，RTX 4090 的地位已被 RTX 5090 取代。

关于 RTX 5090

NVIDIA GeForce RTX 5090 采用 Blackwell 架构，Compute Capability 为 10.0。这是当前消费级最强显卡，拥有约 21760 个 CUDA 核心和 32GB GDDR7 显存，深度学习性能大幅提升，是大模型训练和微调的首选消费级显卡。

3.4 CUDA 版本选择建议

显卡选型与 CUDA 版本实战建议

根据多年的深度学习环境配置经验，以下是针对不同场景的版本选择建议：

  • RTX 20 系列（Turing）：选择 CUDA 12.x，推荐 cu126
  • RTX 30 系列（Ampere）：选择 CUDA 12.x，推荐 cu126
  • RTX 40 系列（Ada Lovelace）：必须选择 CUDA 12.x 及以上，推荐 cu132
  • RTX 50 系列（Blackwell）：必须选择 CUDA 13.x，推荐 cu132

通用原则：新卡用新 CUDA（RTX 40 系列用 CUDA 13.x），旧卡用稳定 CUDA（RTX 30 系列用 CUDA 12.6）。

注意

CUDA 13.x 需要较新的 NVIDIA 驱动支持。如果你的显卡驱动版本较旧，可能需要先升级驱动才能使用 CUDA 13.x。

3.5 如何查看自己显卡的型号和 Compute Capability？

有多种方式可以查看显卡信息：

方法一：设备管理器查看型号

右键点击"此电脑" → "管理" → "设备管理器" → "显示适配器"，即可看到显卡型号。

方法二：NVIDIA 控制面板查看驱动版本

桌面空白处右键 → "NVIDIA 控制面板" → "帮助" → "系统信息"，可以看到驱动版本和 CUDA 版本支持情况。

方法三：命令行查看

# 使用 nvidia-smi 命令查看（需先安装 NVIDIA 驱动）
nvidia-smi

# 输出示例：
# +-----------------------------------------------------------------------------------------+
# | NVIDIA-SMI 610.74                 KMD Version: 610.74        CUDA UMD Version: 13.3     |
# +-----------------------------------------+------------------------+----------------------+
# | GPU  Name                  Driver-Model | Bus-Id          Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
# |                                         |                        |               MIG M. |
# |=========================================+========================+======================|
# |   0  NVIDIA GeForce RTX 2070      WDDM  |   00000000:01:00.0 Off |                  N/A |
# | N/A   40C    P8              9W /  115W |      94MiB /   8192MiB |     36%      Default |
# +-----------------------------------------------------------------------------------------+

注意

nvidia-smi 输出的"CUDA Version"是驱动支持的最大 CUDA 版本，而不是已安装的 CUDA Toolkit 版本。实际安装的 CUDA Toolkit 版本可能更低。

第四章 CUDA Toolkit 与 cuDNN 安装详解

4.1 CUDA Toolkit 详解

What — CUDA Toolkit 是什么？

CUDA Toolkit（CUDA 开发工具包）是 NVIDIA 提供的一套完整的 GPU 并行计算开发工具，包括：

  • nvcc 编译器：NVIDIA C 编译器，用于编译 CUDA C/C++ 代码
  • CUDA 运行时库：提供 GPU 程序运行所需的动态链接库
  • CUDA 工具：nvprof、nsys、nvvp 等性能分析和调试工具
  • 示例代码和文档：丰富的学习和参考资料

Why — 为什么 PyTorch 需要 CUDA Toolkit？

当你在 PyTorch 中执行 tensor.cuda() 或 tensor.to('cuda') 时，PyTorch 底层会调用 CUDA 运行时库来与 GPU 通信。没有 CUDA Toolkit，PyTorch 的 GPU 功能就是空中楼阁。

CUDA 版本号解读

CUDA 版本号采用"主版本.次版本"的格式，如 CUDA 11.8、CUDA 12.6：

  • 主版本号：表示 CUDA 架构的重大变化，不同主版本间可能存在不兼容
  • 次版本号：表示小的功能更新和 bug 修复，向前兼容

版本兼容性规律

CUDA 是向前兼容的，但向后兼容有限制。用 CUDA 12.x 编译的程序通常无法在只安装了 CUDA 11.x 的机器上运行。因此，CUDA 版本的升级需要谨慎规划。

4.2 cuDNN 详解

What — cuDNN 是什么？

cuDNN（CUDA Deep Neural Network library）是 NVIDIA 提供的高度优化的深度神经网络加速库。它提供了标准深度学习算子的高性能 GPU 实现，包括：

  • 卷积前向/反向传播（Convolution）：卷积是 CNN 的核心算子，cuDNN 通过 implicit GEMM、Winograd、FFT 等算法加速
  • 池化前向/反向传播（Pooling）：池化用于下采样，cuDNN 支持 Max Pooling、Average Pooling 等多种方式的高效实现
  • Softmax 前向/反向传播：Softmax 将 logits 转换为概率分布，cuDNN 提供了数值稳定的优化实现，常用于分类任务的输出层
  • 激活函数（ReLU、Sigmoid、Tanh）：激活函数为神经网络引入非线性，cuDNN 通过向量化指令和内存优化加速这些逐元素运算
  • 注意力机制（Scaled Dot Product Attention）：Transformer 的核心，cuDNN 9.0+ 引入了 Flash Attention 实现，显著降低显存占用并加速计算
  • 矩阵运算（MatMul）：通用矩阵乘法是深度学习的基础运算，cuDNN 通过调用 cuBLAS 实现 Tensor Core 加速

cuDNN 的核心价值

cuDNN vs 手写 CUDA：为什么 cuDNN 更快？

cuDNN 是 NVIDIA 官方针对自家 GPU 架构深度优化的库，相当于 NVIDIA 的工程师们已经为你写好了最高效的 CUDA 代码。这些实现经过大量测试和 benchmark 验证，比普通开发者手写的 CUDA 代码快得多。PyTorch、TensorFlow 等框架底层都依赖 cuDNN 来加速深度学习运算。

cuDNN 版本与 CUDA 的兼容性

cuDNN 的版本需要与 CUDA 版本匹配。NVIDIA 官方建议：

cuDNN 版本支持的 CUDA 版本适用场景
cuDNN 8.x CUDA 11.x, 12.x 通用深度学习
cuDNN 9.x CUDA 12.x 最新特性、Transformer 优化

4.3 Windows 上安装 CUDA Toolkit

Step 1：确认驱动兼容性

在安装 CUDA Toolkit 之前，先确认 NVIDIA 驱动支持你要安装的 CUDA 版本。打开命令行执行：

nvidia-smi

输出的"CUDA Version"表示驱动支持的最大 CUDA 版本。你的 CUDA Toolkit 版本必须小于或等于这个数字。

Step 2：下载 CUDA Toolkit

访问 NVIDIA CUDA 下载页面：https://developer.nvidia.com/cuda-downloads

选择：

  • Operating System：Windows
  • Architecture：x86_64
  • Version：10 或 11（根据你的系统）
  • Installer Type：exe(local)

下载页面有两个安装包，应该下载哪个？

安装包大小作用是否需要下载
CUDA Toolkit Installer 约 2.4 GB CUDA 运行时库、nvcc 编译器、工具链 ✅ 必须下载
Driver Installer 约 600 MB NVIDIA 显卡驱动 ⚠️ 通常不需要

为什么 Driver Installer 通常不需要？

  • CUDA Toolkit 安装程序内置了最新版本的 NVIDIA 驱动
  • 安装 CUDA Toolkit 时会自动检测并更新驱动
  • 如果你的 nvidia-smi 显示驱动版本已经较新（如 ≥ 535 for CUDA 12.x），完全不需要单独下载驱动

Step 2.1：验证当前驱动版本

在下载之前，可以先用命令行查看当前显卡驱动版本：

nvidia-smi

关注输出的右上角"Driver Version"和"CUDA Version"：

+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 610.74                 KMD Version: 610.74        CUDA UMD Version: 13.3     |
+-----------------------------------------+------------------------+----------------------+
| GPU  Name                  Driver-Model | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 2070      WDDM  |   00000000:01:00.0 Off |                  N/A |
| N/A   40C    P8              9W /  115W |      94MiB /   8192MiB |     36%      Default |
+-----------------------------------------------------------------------------------------+

驱动版本与 CUDA 版本对应关系

  • Driver Version ≥ 535 → 支持 CUDA 12.x
  • Driver Version ≥ 525 → 支持 CUDA 11.8
  • Driver Version ≥ 450 → 支持 CUDA 11.0

结论：如果你的 Driver Version 是 535+，无需下载 Driver Installer。直接下载 CUDA Toolkit Installer 即可，安装程序会检测到驱动已满足要求。

Step 3：安装 CUDA Toolkit

运行下载的 cuda_xx.x_x_windows_10.exe 文件，建议选择"自定义安装"，只安装必要的组件：

☑ CUDA Development     ← 必须
      ☑ CUDA Runtime        ← 必须
      ☑ CUDA Documentation  ← 可选
      ☑ Samples            ← 可选
      ☑ ShaderLog         ← 可选
      ☑ NSIGHT for Visual Studio ← 如果用 VS 开发 CUDA 可选

Step 4：验证安装

# 检查 nvcc 编译器版本
      nvcc --version
      
      # 输出示例：
      # nvcc: NVIDIA (R) Cuda compiler driver
      # Copyright (c) 2005-2024 NVIDIA Corporation
      # Built (release version)
      # Cuda compilation tools, release 12.6, V12.6.60

4.4 安装 cuDNN

重要：PyTorch 用户通常不需要单独安装 cuDNN！

当你通过 pip install torch 安装 PyTorch GPU 版本时，cuDNN 已经被包含在 PyTorch 安装包中了。PyTorch 的 pip 包自带了编译好的 cuDNN 库（cudnn64_*.dll），可以直接使用。

因此，对于仅使用 PyTorch 的用户：

  • ✅ 不需要下载页面上的 "Download cuDNN Library" 按钮
  • ✅ 不需要下载页面上的 "Download cuDNN Frontend" 按钮
  • ✅ 直接 pip install torch 即可自动获得 cuDNN 加速

什么时候才需要单独安装 cuDNN？

只有以下情况才需要手动安装 cuDNN：

场景说明
使用 TensorRT NVIDIA 推理加速引擎，需要链接 cuDNN
自己写 CUDA C/C++ 代码 需要 cuDNN 头文件和库文件来编译
使用其他框架 如 MXNet、PaddlePaddle 等需要系统级 cuDNN

方法一：通过 pip 安装（推荐）

如果确实需要安装（TensorRT 用户等），可以通过 pip 安装：

pip install nvidia-cudnn nvidia-cudnn-frontend

方法二：手动下载安装

如果 pip 安装不满足需求，可以手动下载：

  1. 访问 cuDNN 下载页面
  2. 登录 NVIDIA 开发者账号
  3. 下载与 CUDA 版本匹配的 cuDNN 包（cudnn-windows-x86_64-x.x.x_cuda12-archive.zip）
  4. 解压后将 bin、include、lib 三个文件夹复制到 CUDA Toolkit 安装目录

关于下载页面的两个按钮

  • Download cuDNN Library：cuDNN 核心库（.dll/.so），用于运行时
  • Download cuDNN Frontend (GitHub)：C++/Python 前端 API 源码，用于开发自定义算子

普通 PyTorch 用户两个都不用下载，pip 安装的 torch 已经包含了。

第五章 安装 PyTorch

5.1 安装 CPU 版本（方案A）

选择 CPU 版本的安装非常简单，只需 3 步：

Step 1：配置 pip 国内镜像源（可选，推荐）

由于 Python 官方源服务器在国外，国内用户下载包速度较慢。建议配置国内镜像源加速下载。

# 永久配置清华镜像源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

Step 2：安装 PyTorch CPU 版本

# 使用清华镜像安装（30 秒完成）
pip3 install torch torchvision torchaudio -i https://pypi.tuna.tsinghua.edu.cn/simple

# 或使用阿里云镜像
pip3 install torch torchvision torchaudio -i https://mirrors.aliyun.com/pypi/simple

Step 3：验证安装

import torch
print(torch.__version__)
# 输出示例：2.13.0+cpu

print(torch.cuda.is_available())
# 输出：False（这是正常的，CPU 版本没有 CUDA 支持）

方案A 总结

  • 安装时间：约 5 分钟
  • 安装大小：约 200 MB
  • 适用场景：入门学习、语法练习、小数据集处理

5.2 安装 GPU 版本（方案B）

在安装 PyTorch GPU 版本之前，请确保已完成：

  • ✅ 安装 Python（第二章）
  • ✅ 确认 NVIDIA 显卡型号（第三章 3.5 节）
  • ✅ 安装 CUDA Toolkit（第四章）
  • ✅ 安装 cuDNN（第四章）

Step 1：确定 CUDA 版本

根据你的显卡型号，选择对应的 PyTorch 安装命令：

显卡型号CUDA 版本PyTorch 安装命令
RTX 20/30 系列 CUDA 12.6 --index-url https://download.pytorch.org/whl/cu126
RTX 40 系列 CUDA 12.x / 13.x --index-url https://download.pytorch.org/whl/cu132
RTX 50 系列 CUDA 13.x --index-url https://download.pytorch.org/whl/cu132

Step 2：安装 PyTorch GPU 版本

# CUDA 12.6 版本（适用于 RTX 20/30 系列）
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

# CUDA 13.3 版本（适用于 RTX 40/50 系列，推荐）
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu133

国内下载加速

如果下载速度慢，可以使用国内镜像源，但需要注意镜像源可能更新较慢：

# 阿里云镜像（可能不是最新版本）
pip3 install torch torchvision torchaudio -i https://mirrors.aliyun.com/pypi/simple

Step 3：验证安装

import torch

# 检查 PyTorch 版本
print(f"PyTorch 版本: {torch.__version__}")
# 输出示例：2.13.0+cu126

# 检查 CUDA 是否可用
print(f"CUDA 可用: {torch.cuda.is_available()}")
# 输出：True（表示安装成功）

# 检查 CUDA 版本
print(f"CUDA 版本: {torch.version.cuda}")
# 输出示例：12.6

# 检查 GPU 信息
if torch.cuda.is_available():
    print(f"GPU 数量: {torch.cuda.device_count()}")
    print(f"GPU 0 名称: {torch.cuda.get_device_name(0)}")
    # 输出示例：NVIDIA GeForce RTX 2070

✅ 安装成功示例（2026 年 7 月实测）

PyTorch 版本: 2.13.0+cu126
CUDA 可用: True
CUDA 版本: 12.6
GPU 数量: 1
GPU 0 名称: NVIDIA GeForce RTX 2070

如果看到以上输出，说明 PyTorch GPU 版本安装成功！现在可以开始使用 GPU 加速深度学习了。

方案B 总结

  • 安装时间：约 30-60 分钟（含 CUDA 安装）
  • 安装大小：约 2.4 GB
  • 适用场景：大模型微调、深度学习研究、生产部署

5.3 CPU vs GPU 安装对比

核心区别速览

对比项CPU 版本GPU 版本
安装大小 约 200 MB 约 2.4 GB
安装时间 约 30 秒（国内镜像） 约 30-60 分钟
硬件要求 任意电脑 需要 NVIDIA 显卡
训练速度 慢 快 10-100 倍
适用场景 入门学习、调试代码 正式训练、大模型

关于 --index-url 参数

PyTorch 官方 wheel 包托管在独立的服务器上，需要通过 --index-url 参数指定下载地址。如果不指定，默认会从 PyPI 安装 CPU 版本。

CPU 与 GPU 性能对比实测

以简单的矩阵乘法（4096×4096）为例：

import torch
import time

size = 4096

# CPU 计算
a = torch.randn(size, size)
b = torch.randn(size, size)
start = time.time()
c = torch.matmul(a, b)
cpu_time = time.time() - start
print(f"CPU 用时: {cpu_time:.3f}s")

# GPU 计算（如果有 NVIDIA 显卡）
if torch.cuda.is_available():
    a = a.cuda()
    b = b.cuda()
    torch.cuda.synchronize()
    start = time.time()
    c = torch.matmul(a, b)
    torch.cuda.synchronize()
    gpu_time = time.time() - start
    print(f"GPU 用时: {gpu_time:.3f}s")
    print(f"GPU 加速比: {cpu_time/gpu_time:.1f}x")

选择建议总结

  • 初学者、学习阶段：先用 CPU 版本快速上手，不纠结环境问题
  • 论文复现、项目开发：必须用 GPU 版本，CPU 训练大模型几乎不可行
  • 没有 NVIDIA 显卡：使用 CPU 版本，或考虑 Apple M 系列芯片的 MPS 后端
  • 混合策略：代码调试用 CPU，正式训练用 GPU

5.4 安装验证

安装完成后，运行以下命令验证：

基础验证

import torch

# 检查 PyTorch 版本
print(f"PyTorch 版本: {torch.__version__}")
# CPU 版本输出：2.13.0+cpu
# GPU 版本输出：2.13.0+cu126 或 2.13.0+cu133

# 检查 CUDA 是否可用
print(f"CUDA 可用: {torch.cuda.is_available()}")
# CPU 版本输出：False
# GPU 版本输出：True

GPU 进阶验证

import torch

# 检查 GPU 信息
if torch.cuda.is_available():
    print(f"GPU 数量: {torch.cuda.device_count()}")
    print(f"GPU 0 名称: {torch.cuda.get_device_name(0)}")
    print(f"GPU 0 显存: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
    print(f"CUDA 版本: {torch.version.cuda}")

    # 测试 GPU 计算
    x = torch.rand(3, 3).cuda()
    y = torch.rand(3, 3).cuda()
    z = torch.matmul(x, y)
    print(f"GPU 计算成功！结果设备: {z.device}")

第六章 环境验证与小练习

6.1 环境健康检查脚本

以下是一个完整的健康检查脚本，保存为 check_env.py 并运行：

"""
      PyTorch 环境健康检查脚本
      使用方法：python check_env.py
      """
      
      import sys
      
      def check_python():
          """检查 Python 版本"""
          version = sys.version_info
          print(f"[✓] Python 版本: {version.major}.{version.minor}.{version.micro}")
          if version.major < 3 or (version.major == 3 and version.minor < 10):
              print("[✗] PyTorch 2.x 需要 Python 3.10+")
              return False
          return True
      
      def check_pytorch():
          """检查 PyTorch 安装"""
          try:
              import torch
              print(f"[✓] PyTorch 版本: {torch.__version__}")
              return torch
          except ImportError:
              print("[✗] PyTorch 未安装，请运行: pip install torch")
              return None
      
      def check_cuda(pytorch):
          """检查 CUDA 支持"""
          if not pytorch:
              return False
          cuda_available = pytorch.cuda.is_available()
          if cuda_available:
              print(f"[✓] CUDA 可用: {pytorch.version.cuda}")
              print(f"[✓] GPU 数量: {pytorch.cuda.device_count()}")
              if pytorch.cuda.device_count() > 0:
                  print(f"[✓] GPU 0: {pytorch.cuda.get_device_name(0)}")
                  props = pytorch.cuda.get_device_properties(0)
                  print(f"[✓] GPU 0 显存: {props.total_memory / 1024**3:.2f} GB")
          else:
              print("[!] CUDA 不可用，将使用 CPU 训练（速度较慢）")
          return cuda_available
      
      def check_packages():
          """检查常用深度学习包"""
          packages = {
              'transformers': 'Hugging Face Transformers',
              'datasets': 'Hugging Face Datasets',
              'accelerate': 'Accelerate',
              'peft': 'PEFT (LoRA/Adapter)',
              'bitsandbytes': 'BitsAndBytes 量化'
          }
          all_ok = True
          for pkg, name in packages.items():
              try:
                  __import__(pkg)
                  print(f"[✓] {name} 已安装")
              except ImportError:
                  print(f"[i] {name} 未安装（可选）")
          return all_ok
      
      def gpu_computation_test(pytorch):
          """GPU 计算测试"""
          if not pytorch or not pytorch.cuda.is_available():
              print("[i] 跳过 GPU 计算测试（CUDA 不可用）")
              return
          
          try:
              import time
              
              # 创建两个大矩阵
              size = 4096
              a = pytorch.randn(size, size).cuda()
              b = pytorch.randn(size, size).cuda()
              
              # GPU 计算
              torch.cuda.synchronize()
              start = time.time()
              c = torch.matmul(a, b)
              torch.cuda.synchronize()
              gpu_time = time.time() - start
              
              # CPU 计算（对比）
              a_cpu = a.cpu()
              b_cpu = b.cpu()
              start = time.time()
              c_cpu = torch.matmul(a_cpu, b_cpu)
              cpu_time = time.time() - start
              
              speedup = cpu_time / gpu_time
              print(f"[✓] GPU 矩阵乘法 ({size}x{size}): {gpu_time:.3f}s")
              print(f"[✓] CPU 矩阵乘法 ({size}x{size}): {cpu_time:.3f}s")
              print(f"[✓] GPU 加速比: {speedup:.1f}x")
              
              # 清理
              del a, b, c, a_cpu, b_cpu, c_cpu
              torch.cuda.empty_cache()
              
          except Exception as e:
              print(f"[!] GPU 计算测试失败: {e}")
      
      def main():
          print("=" * 50)
          print("PyTorch 深度学习环境健康检查")
          print("=" * 50)
          
          checks = [
              ("Python 版本检查", check_python),
              ("PyTorch 安装检查", lambda: check_pytorch(main) if (main := check_pytorch()) else None),
          ]
          
          pytorch_ok = check_pytorch()
          if pytorch_ok:
              check_cuda(pytorch_ok)
          
          check_packages()
          
          if pytorch_ok and pytorch_ok.cuda.is_available():
              gpu_computation_test(pytorch_ok)
          
          print("=" * 50)
          print("检查完成！如果所有 [✓] 都通过，环境配置正确。")
          print("=" * 50)
      
      if __name__ == "__main__":
          main()

6.2 PyTorch 2.x 小练习：GPU 加速神经网络训练

以下是一个完整的神经网络训练示例，展示了如何在 GPU 上训练一个图像分类模型：

"""
      PyTorch 2.x 小练习：使用 GPU 加速 CIFAR-10 图像分类
      """
      
      import torch
      import torch.nn as nn
      import torch.optim as optim
      import torchvision
      import torchvision.transforms as transforms
      
      # ============================================
      # 1. 检查并配置 GPU 设备
      # ============================================
      device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
      print(f"使用设备: {device}")
      
      if torch.cuda.is_available():
          print(f"GPU 名称: {torch.cuda.get_device_name(0)}")
          print(f"GPU 显存: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
      
      # ============================================
      # 2. 加载并预处理 CIFAR-10 数据集
      # ============================================
      transform = transforms.Compose([
          transforms.RandomCrop(32, padding=4),
          transforms.RandomHorizontalFlip(),
          transforms.ToTensor(),
          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
      ])
      
      train_set = torchvision.datasets.CIFAR10(
          root='./data', train=True, download=True, transform=transform
      )
      test_set = torchvision.datasets.CIFAR10(
          root='./data', train=False, download=True, transform=transform
      )
      
      train_loader = torch.utils.data.DataLoader(
          train_set, batch_size=128, shuffle=True, num_workers=4, pin_memory=True
      )
      test_loader = torch.utils.data.DataLoader(
          test_set, batch_size=128, shuffle=False, num_workers=4, pin_memory=True
      )
      
      # ============================================
      # 3. 定义一个简单的卷积神经网络
      # ============================================
      class SimpleCNN(nn.Module):
          def __init__(self):
              super(SimpleCNN, self).__init__()
              self.features = nn.Sequential(
                  nn.Conv2d(3, 32, kernel_size=3, padding=1),
                  nn.ReLU(),
                  nn.MaxPool2d(2, 2),
                  nn.Conv2d(32, 64, kernel_size=3, padding=1),
                  nn.ReLU(),
                  nn.MaxPool2d(2, 2),
                  nn.Conv2d(64, 128, kernel_size=3, padding=1),
                  nn.ReLU(),
                  nn.MaxPool2d(2, 2),
              )
              self.classifier = nn.Sequential(
                  nn.Flatten(),
                  nn.Linear(128 * 4 * 4, 256),
                  nn.ReLU(),
                  nn.Dropout(0.5),
                  nn.Linear(256, 10)
              )
          
          def forward(self, x):
              x = self.features(x)
              x = self.classifier(x)
              return x
      
      model = SimpleCNN().to(device)
      print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}")
      
      # ============================================
      # 4. 定义损失函数和优化器
      # ============================================
      criterion = nn.CrossEntropyLoss()
      optimizer = optim.Adam(model.parameters(), lr=0.001)
      
      # ============================================
      # 5. 训练函数（使用 torch.compile 加速）
      # ============================================
      def train_one_epoch(model, train_loader, criterion, optimizer, device, compile_model=False):
          model.train()
          running_loss = 0.0
          correct = 0
          total = 0
          
          for inputs, targets in train_loader:
              inputs, targets = inputs.to(device), targets.to(device)
              
              optimizer.zero_grad()
              outputs = model(inputs)
              loss = criterion(outputs, targets)
              loss.backward()
              optimizer.step()
              
              running_loss += loss.item()
              _, predicted = outputs.max(1)
              total += targets.size(0)
              correct += predicted.eq(targets).sum().item()
          
          return running_loss / len(train_loader), 100. * correct / total
      
      # ============================================
      # 6. 可选：启用 torch.compile 编译加速
      # ============================================
      print("\n是否启用 torch.compile 编译加速？（首次编译需要几分钟）")
      print("跳过编译，直接使用动态图训练...")
      
      # 如果需要启用编译，取消下面这行注释：
      # model = torch.compile(model)  # ← 一行代码，训练速度提升 1.5-2x
      
      # ============================================
      # 7. 训练循环
      # ============================================
      num_epochs = 5
      print(f"\n开始训练 {num_epochs} 个 epoch...")
      
      for epoch in range(num_epochs):
          train_loss, train_acc = train_one_epoch(
              model, train_loader, criterion, optimizer, device
          )
          print(f"Epoch {epoch+1}/{num_epochs} | "
                f"Loss: {train_loss:.4f} | "
                f"Acc: {train_acc:.2f}%")
      
      print("\n训练完成！")
      print(f"最终测试准确率: {100. * correct / total:.2f}%")

torch.compile 加速提示

在训练循环之前添加 model = torch.compile(model)，可以让 PyTorch 2.x 自动编译优化模型，首次编译需要 1-3 分钟，但后续训练速度可提升 1.5-2 倍。

6.3 常见错误排查

错误信息可能原因解决方案
CUDA not available 未安装 CUDA 或驱动不匹配 安装对应版本的 CUDA Toolkit
RuntimeError: CUDA out of memory 显存不足 减小 batch_size 或使用梯度累积
ImportError: DLL load failed cuDNN 库未正确配置 重新安装 nvidia-cudnn
NVIDIA driver version is insufficient 驱动版本过低 升级 NVIDIA 驱动

FAQ 常见问题（20 组）

关于 Python 环境

Q1. Python 3.9 可以使用 PyTorch 2.x 吗？

一句话结论：理论上可以，但建议升级到 Python 3.10+。PyTorch 2.x 官方支持 Python 3.10-3.14，使用旧版本可能遇到兼容性问题，且无法享受最新特性。

Q2. Anaconda 和 pip 安装的 Python 哪个更好？

一句话结论：日常开发用 pip，数据科学环境隔离用 conda。pip 更轻量、与 PyTorch 官方兼容更好；conda 环境隔离强但体积大，两者混用可能产生冲突。

Q3. 如何卸载 Python 并重装？

一句话结论：通过 Windows 设置 → 应用 → Python → 卸载，然后清理环境变量。残留的环境变量可能导致重装后命令冲突。

Q4. pip install 速度很慢怎么办？

一句话结论：配置国内镜像源。执行 pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple 配置清华镜像。

Q5. 如何创建多个 Python 环境？

一句话结论：用 venv 或 pyenv 创建隔离环境。python -m venv myenv 创建虚拟环境，myenv\Scripts\activate 激活。

关于 CUDA 与 cuDNN

Q6. CUDA 和 cuDNN 的区别是什么？

一句话结论：CUDA 是通用的 GPU 并行计算平台，cuDNN 是专用于深度学习的加速库。CUDA 包含编译器、运行时、各种工具；cuDNN 是 NVIDIA 官方优化的高性能 DNN 算子库。

Q7. 必须手动安装 CUDA Toolkit 吗？

一句话结论：不一定，pip 安装 PyTorch 会自带 CUDA 运行时。对于仅使用 PyTorch 的用户，pip 安装 PyTorch 时会自动配置 CUDA，无需单独安装 CUDA Toolkit。

Q8. CUDA 驱动版本和 CUDA Toolkit 版本有什么关系？

一句话结论：驱动版本 >= CUDA Toolkit 版本。驱动决定了系统能支持的最大 CUDA 版本，但你可以安装比驱动版本低的 CUDA Toolkit。

Q9. cuDNN 是必需的吗？

一句话结论：pip 安装 PyTorch 时会自带 cuDNN，不需要单独安装。PyTorch 的 wheel 包已经包含了编译好的 cuDNN 库。

Q10. 多个 CUDA 版本可以共存吗？

一句话结论：可以，但需要通过环境变量切换默认版本。通过 CUDA_HOME 环境变量指定使用的 CUDA 版本。

关于 PyTorch 安装

Q11. pip 安装的 PyTorch 和 conda 安装的有什么区别？

一句话结论：pip 版本与官方同步更好，推荐使用 pip。pip 安装的 PyTorch 直接来自 PyTorch 官方，版本更新更及时。

Q11-1. 国内镜像源安装的 PyTorch 为什么没有 CUDA 支持？

重要发现：国内镜像源只提供 CPU 版本！

经过实际测试，以下国内镜像源均只提供 +cpu 版本的 PyTorch：

镜像源CUDA 版本测试结果
清华镜像（pypi.tuna.tsinghua.edu.cn） 无 ❌ 只有 CPU 版本（2.13.0+cpu）
阿里云镜像（mirrors.aliyun.com） 无 ❌ 只有 CPU 版本
华为云镜像（repo.huaweicloud.com） 无 ❌ 只有 CPU 版本
PyTorch 官方源（download.pytorch.org） ✅ 有 ✅ 包含完整 CUDA 版本

原因分析：CUDA 版本的 PyTorch wheel 文件体积较大（约 2.4 GB），国内镜像站出于存储和带宽成本考虑，默认不同步 CUDA 版本。

解决方案：

  • 学习用途：先用 CPU 版本（清华镜像 30 秒安装完成）
  • 生产用途：从 PyTorch 官方源安装（国内下载约 5 小时）

Q12. 如何安装 PyTorch CPU 版本？

一句话结论：pip install torch torchvision torchaudio。不指定 CUDA 版本时，默认安装 CPU 版本。

Q13. 如何验证 PyTorch 能识别我的 GPU？

一句话结论：运行 python -c "import torch; print(torch.cuda.is_available())"。返回 True 表示 GPU 可用。

Q14. 显存不足怎么办？

一句话结论：减小 batch_size、使用梯度累积、开启混合精度训练。大模型训练可使用 bitsandbytes 做 4/8bit 量化。

Q15. torch.compile 有什么副作用？

一句话结论：首次编译慢，但不影响模型精度。编译后的模型行为与原模型完全一致，首次编译需要 1-5 分钟。

关于显卡与硬件

Q16. GTX 系列显卡支持深度学习吗？

一句话结论：支持，但 RTX 系列更推荐。GTX 10 系列及更新版本支持 CUDA，但 RTX 系列的 Tensor Core 可加速深度学习运算。

Q17. Mac 电脑可以用 PyTorch GPU 加速吗？

一句话结论：可以使用 Apple M 系列芯片的 MPS 后端，但不能使用 NVIDIA CUDA。torch.device('mps')。

Q18. 笔记本显卡可以做深度学习吗？

一句话结论：可以，但需要笔记本有 NVIDIA RTX 独立显卡。轻薄本的集成显卡不支持 CUDA，游戏本/工作站的 RTX 显卡可以使用。

Q19. 多张显卡如何配置？

一句话结论：安装多张 NVIDIA 显卡，使用 DataParallel 或 DistributedDataParallel。PyTorch 支持单机多卡和多机多卡训练。

Q20. 深度学习电脑需要多大电源？

一句话结论：RTX 4090 建议 850W 及以上，RTX 5090 建议 1000W 及以上电源。RTX 4090 满载功耗约 450W，RTX 5090 约 575W，加上 CPU、主板等，整机电源建议相应提高。

全篇总结：环境搭建的关键要点

  • Python 版本：选择 3.10-3.14，勾选"Add to PATH"
  • CUDA 版本：RTX 40/50 系列用 CUDA 13.x，RTX 30 系列用 CUDA 12.6
  • PyTorch 安装：通过 pip 从官方源安装 GPU 版本，指定 CUDA 版本
  • 验证三步：检查 torch.cuda.is_available()、检查 GPU 数量、运行 GPU 张量运算
  • 性能优化：使用 torch.compile() 加速训练，合理设置 batch_size

参考与学习资源：

基于 PyTorch 2.x 的大模型开发与微调专题【左扬精讲】· Windows 环境搭建

posted @ 2026-07-08 17:16  左扬  阅读(1)  评论(0)    收藏  举报