PyTorch深度学习框架安装指南与实战应用全解析

PyTorch安装深度学习框架动态计算图

于 2026-07-08 05:04:04 修改

·本内容遵循CC 4.0 BY-SA版权协议

深度学习框架选择一直是AI开发者面临的重要决策，而PyTorch凭借其直观的编程接口和强大的动态图机制，已成为学术界和工业界的主流选择。无论是计算机视觉、自然语言处理还是强化学习项目，PyTorch都能提供灵活高效的开发体验。本文将系统讲解PyTorch从环境搭建到实战应用的全流程，特别针对安装过程中的常见问题提供详细解决方案，帮助开发者快速上手这一强大的深度学习框架。

1. PyTorch核心概念与特性解析

1.1 什么是PyTorch

PyTorch是一个基于Python的科学计算库，专门针对深度学习应用而设计。它提供了两个核心功能：强大的GPU加速张量计算和构建深度神经网络的自动微分系统。与静态图框架不同，PyTorch采用动态计算图（Dynamic Computational Graph），这意味着图的结构在运行时可以改变，为模型调试和研究提供了极大的灵活性。

PyTorch的设计哲学强调简洁性和直观性，其API设计深受NumPy影响，使得有Python基础的开发者能够快速上手。同时，PyTorch与Python生态的深度集成，使其能够无缝与流行的数据科学库（如Pandas、Matplotlib）协同工作。

1.2 PyTorch的核心优势

动态计算图是PyTorch最显著的特点之一。在模型开发过程中，开发者可以像编写普通Python代码一样构建神经网络，每一行代码都会立即执行并返回结果。这种即时反馈机制大大加快了模型调试和实验迭代的速度。对于研究型项目和教育场景，这种即时性尤为重要。

另一个关键优势是PyTorch的调试友好性。由于计算图是动态构建的，开发者可以使用标准的Python调试工具（如pdb）直接检查张量值和梯度，无需特殊的调试器或复杂的图分析工具。这种透明性使得复杂模型的错误定位变得相对简单。

PyTorch还拥有活跃的社区和丰富的生态系统。从计算机视觉的torchvision到自然语言处理的torchtext，再到图神经网络的PyTorch Geometric，各种领域的专用库不断完善。此外，PyTorch与主流的云平台（AWS、GCP、Azure）都有深度集成，支持从研究到生产的无缝过渡。

2. 环境准备与版本选择策略

2.1 系统要求与前置条件

在安装PyTorch之前，需要确保系统满足基本要求。PyTorch支持Windows、Linux和macOS三大主流操作系统。对于Windows用户，建议使用Windows 10或更高版本；Linux用户推荐Ubuntu 16.04以上或CentOS 7以上；macOS则需要10.13及以上版本。

Python版本是另一个关键因素。PyTorch 2.7.0及以上版本要求Python 3.10或更高版本。如果使用较早的PyTorch版本，可能兼容Python 3.8或3.9，但新项目建议直接使用最新的稳定版本以获得最佳性能和功能支持。

包管理工具的选择也很重要。pip是Python的标准包管理器，适合大多数场景。对于需要更严格环境隔离的项目，推荐使用conda（特别是Anaconda或Miniconda）。conda能够更好地处理复杂的依赖关系，特别是在涉及CUDA等系统级库时。

2.2 CUDA与计算平台选择

GPU加速是深度学习训练的关键，而CUDA是NVIDIA GPU的并行计算平台。PyTorch支持多个CUDA版本，包括CUDA 11.8、12.6和12.8。选择哪个版本取决于你的GPU驱动和硬件能力。

要确定适合的CUDA版本，首先检查GPU型号和驱动版本。运行nvidia-smi命令可以查看当前驱动支持的最高CUDA版本。例如，如果驱动支持CUDA 12.0，那么可以选择CUDA 11.8或12.6，但建议选择与驱动兼容的最新CUDA版本以获得最佳性能。

对于没有NVIDIA GPU的用户，PyTorch也提供CPU版本。虽然训练速度较慢，但对于学习和小型项目已经足够。AMD GPU用户可以通过ROCm 6.3平台获得PyTorch支持，这在最新的PyTorch版本中得到了显著改善。

3. PyTorch安装全攻略：多种方法详解

3.1 使用pip安装PyTorch

pip是最简单的安装方式，适用于大多数用户。访问PyTorch官网的"Get Started"页面，根据你的配置生成相应的安装命令。例如，对于Linux系统、Python语言、CUDA 12.6的用户，安装命令为：

BASH

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

这个命令会安装PyTorch核心库（torch）、计算机视觉扩展（torchvision）和音频处理扩展（torchaudio）。--index-url参数指定了PyTorch官方包的下载源，确保获取到正版且兼容的版本。

对于国内用户，如果下载速度较慢，可以考虑使用镜像源。清华镜像源提供了PyTorch的镜像，使用方法如下：

BASH

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

但需要注意，镜像源可能有同步延迟，建议优先使用官方源，如果遇到网络问题再切换至镜像源。

3.2 使用conda安装PyTorch

conda安装方式在依赖管理方面更加稳健，特别适合复杂的数据科学环境。通过conda安装PyTorch的命令格式为：

BASH

conda install pytorch torchvision torchaudio pytorch-cuda=12.6 -c pytorch -c nvidia

这里的-c pytorch -c nvidia指定了包所在的channel。conda会自动解决依赖关系，包括CUDA工具包等系统级依赖，这大大简化了安装过程。

对于纯CPU版本，可以使用以下命令：

BASH

conda install pytorch torchvision torchaudio cpuonly -c pytorch

conda环境管理是其另一大优势。你可以为不同项目创建独立的环境，避免包版本冲突：

BASH

# 创建新环境

conda create -n pytorch-env python=3.10

# 激活环境

conda activate pytorch-env

# 安装PyTorch

conda install pytorch torchvision torchaudio pytorch-cuda=12.6 -c pytorch -c nvidia

3.3 特殊环境安装指南

Docker安装：对于追求环境一致性和可复现性的用户，Docker是最佳选择。PyTorch官方提供了多个Docker镜像：

BASH

# 拉取官方镜像

docker pull pytorch/pytorch:2.7.0-cuda12.6-cudnn8-devel

# 运行容器

docker run -it --gpus all pytorch/pytorch:2.7.0-cuda12.6-cudnn8-devel

Jetson平台安装：NVIDIA Jetson系列嵌入式设备需要专门的PyTorch版本。官方为Jetson提供了预编译的wheel包，安装命令为：

BASH

pip3 install torch-2.7.0-cp310-cp310-linux_aarch64.whl

源码编译：对于需要自定义修改或优化特定硬件的高级用户，可以从源码编译PyTorch。这个过程较为复杂，需要安装依赖并配置编译选项：

BASH

git clone --recursive https://github.com/pytorch/pytorch

cd pytorch

pip install -r requirements.txt

python setup.py install

4. 环境验证与基础使用

4.1 安装验证步骤

安装完成后，必须验证PyTorch是否正确安装且能够正常使用。创建一个简单的Python脚本进行测试：

PYTHON

import torch

# 检查PyTorch版本

print(f"PyTorch版本: {torch.__version__}")

# 检查CUDA是否可用

print(f"CUDA可用: {torch.cuda.is_available()}")

# 如果CUDA可用，显示GPU信息

if torch.cuda.is_available():

print(f"GPU数量: {torch.cuda.device_count()}")

print(f"当前GPU: {torch.cuda.current_device()}")

print(f"GPU名称: {torch.cuda.get_device_name(0)}")

# 测试基本张量操作

x = torch.rand(3, 3)

print(f"随机张量:\n{x}")

print(f"张量形状: {x.shape}")

print(f"张量设备: {x.device}")

# 测试GPU张量（如果可用）

if torch.cuda.is_available():

x_gpu = x.cuda()

print(f"GPU张量设备: {x_gpu.device}")

运行这个脚本应该能正常输出PyTorch版本信息、CUDA状态和张量数据。如果出现任何错误，说明安装可能有问题。

4.2 基础张量操作

张量是PyTorch的核心数据结构，类似于NumPy的数组，但可以在GPU上运行。以下是一些基本操作示例：

PYTHON

import torch

# 创建张量

x = torch.tensor([1, 2, 3]) # 从列表创建

y = torch.zeros(2, 3) # 全零张量

z = torch.ones(2, 3) # 全一张量

r = torch.rand(2, 3) # 随机张量

print("基本张量创建:")

print(f"x: {x}")

print(f"y:\n{y}")

print(f"z:\n{z}")

print(f"r:\n{r}")

# 张量运算

a = torch.tensor([1, 2, 3])

b = torch.tensor([4, 5, 6])

print("\n张量运算:")

print(f"a + b = {a + b}") # 逐元素加法

print(f"a * b = {a * b}") # 逐元素乘法

print(f"点积: {torch.dot(a, b)}") # 点积

# 矩阵运算

matrix1 = torch.rand(2, 3)

matrix2 = torch.rand(3, 2)

print(f"\n矩阵乘法:\n{torch.matmul(matrix1, matrix2)}")

4.3 自动微分示例

PyTorch的自动微分系统（autograd）是神经网络训练的核心。以下示例展示如何计算梯度：

PYTHON

import torch

# 需要梯度的张量

x = torch.tensor(2.0, requires_grad=True)

y = torch.tensor(3.0, requires_grad=True)

# 计算函数

z = x**2 + y**3 + x*y

# 反向传播计算梯度

z.backward()

print(f"x的梯度: {x.grad}") # dz/dx = 2x + y

print(f"y的梯度: {y.grad}") # dz/dy = 3y² + x

这个简单的例子展示了PyTorch自动微分的强大能力，复杂的神经网络梯度计算也是基于同样的原理。

5. 常见安装问题与解决方案

5.1 网络连接与下载问题

PyTorch安装包较大，特别是在包含CUDA支持时，国内用户可能会遇到下载速度慢或超时的问题。除了使用镜像源外，还可以尝试以下解决方案：

设置超时时间：增加pip的超时时间限制

BASH

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

分步安装：如果整体安装失败，可以尝试分别安装各个组件

BASH

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

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

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

使用离线安装：在有网络的环境下载whl文件，然后在目标机器安装

BASH

# 下载包

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

# 离线安装

pip install torch-2.7.0+cu118-cp310-cp310-linux_x86_64.whl

5.2 CUDA相关错误

CUDA配置是PyTorch安装中最常见的错误源。以下是一些典型问题及解决方法：

CUDA版本不匹配：PyTorch版本与系统CUDA版本不兼容

TEXT

解决方案：检查nvidia-smi输出的CUDA版本，选择对应的PyTorch版本

GPU驱动过旧：系统GPU驱动不支持所需的CUDA版本

TEXT

解决方案：更新NVIDIA驱动到最新版本

CUDA不可用：安装后torch.cuda.is_available()返回False

PYTHON

# 诊断脚本

import torch

print(f"CUDA设备数量: {torch.cuda.device_count()}")

if torch.cuda.device_count() > 0:

print(f"设备0名称: {torch.cuda.get_device_name(0)}")

# 测试GPU计算

x = torch.tensor([1.0, 2.0, 3.0]).cuda()

print(f"GPU张量: {x}")

5.3 环境冲突与版本问题

Python环境管理不当会导致各种依赖冲突：

虚拟环境解决方案：使用venv或conda创建隔离环境

BASH

# 使用venv

python -m venv pytorch-env

source pytorch-env/bin/activate # Linux/Mac

# pytorch-env\Scripts\activate # Windows

# 使用conda

conda create -n pytorch-env python=3.10

conda activate pytorch-env

依赖冲突解决：当出现依赖包版本冲突时

BASH

# 查看冲突信息

pip check

# 尝试升级或降级冲突包

pip install --upgrade 包名

# 或使用conda解决依赖

conda install 包名

6. 第一个PyTorch神经网络实战

6.1 线性回归模型

让我们从最简单的线性回归开始，了解PyTorch神经网络的基本构建流程：

PYTHON

import torch

import torch.nn as nn

import numpy as np

import matplotlib.pyplot as plt

# 设置随机种子确保可重复性

torch.manual_seed(42)

# 生成模拟数据

x = torch.linspace(0, 10, 100).reshape(-1, 1)

y = 2 * x + 1 + torch.randn(x.size()) * 2 # y = 2x + 1 + 噪声

# 定义线性回归模型

class LinearRegression(nn.Module):

def __init__(self):

super(LinearRegression, self).__init__()

self.linear = nn.Linear(1, 1) # 输入维度1，输出维度1

def forward(self, x):

return self.linear(x)

# 创建模型、损失函数和优化器

model = LinearRegression()

criterion = nn.MSELoss() # 均方误差损失

optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 随机梯度下降

# 训练模型

losses = []

epochs = 1000

for epoch in range(epochs):

# 前向传播

predictions = model(x)

loss = criterion(predictions, y)

# 反向传播

optimizer.zero_grad() # 清零梯度

loss.backward() # 计算梯度

optimizer.step() # 更新参数

losses.append(loss.item())

if epoch % 100 == 0:

print(f'Epoch [{epoch}/{epochs}], Loss: {loss.item():.4f}')

# 可视化结果

plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)

plt.scatter(x.numpy(), y.numpy(), alpha=0.6, label='原始数据')

plt.plot(x.numpy(), model(x).detach().numpy(), 'r-', label='拟合直线')

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.title('线性回归拟合结果')

plt.subplot(1, 2, 2)

plt.plot(losses)

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.title('训练损失曲线')

plt.tight_layout()

plt.show()

# 打印训练得到的参数

print(f'训练得到的权重: {model.linear.weight.item():.2f}')

print(f'训练得到的偏置: {model.linear.bias.item():.2f}')

6.2 使用预训练模型

PyTorch提供了丰富的预训练模型，特别是在计算机视觉领域：

PYTHON

import torch

import torchvision.models as models

import torchvision.transforms as transforms

from PIL import Image

# 加载预训练的ResNet模型

model = models.resnet50(pretrained=True)

model.eval() # 设置为评估模式

# 图像预处理

transform = transforms.Compose([

transforms.Resize(256),

transforms.CenterCrop(224),

transforms.ToTensor(),

transforms.Normalize(mean=[0.485, 0.456, 0.406],

std=[0.229, 0.224, 0.225]),

])

# 加载并预处理图像

image = Image.open('example.jpg') # 替换为你的图像路径

input_tensor = transform(image)

input_batch = input_tensor.unsqueeze(0) # 添加batch维度

# 使用GPU（如果可用）

if torch.cuda.is_available():

input_batch = input_batch.to('cuda')

model.to('cuda')

# 推理

with torch.no_grad():

output = model(input_batch)

# 获取预测结果

probabilities = torch.nn.functional.softmax(output[0], dim=0)

# 加载ImageNet标签（实际使用时需要下载完整的标签文件）

# 这里简化为示例

print(f"推理完成，最高概率: {probabilities.max().item():.4f}")

7. PyTorch高级特性与最佳实践

7.1 数据加载与处理

高效的数据管道是深度学习项目的关键。PyTorch提供了Dataset和DataLoader类来简化这一过程：

PYTHON

import torch

from torch.utils.data import Dataset, DataLoader

import pandas as pd

from sklearn.preprocessing import StandardScaler

# 自定义数据集类

class CustomDataset(Dataset):

def __init__(self, csv_file, transform=None):

self.data = pd.read_csv(csv_file)

self.transform = transform

# 假设数据包含特征和标签

self.features = self.data.iloc[:, :-1].values

self.labels = self.data.iloc[:, -1].values

# 标准化特征

self.scaler = StandardScaler()

self.features = self.scaler.fit_transform(self.features)

def __len__(self):

return len(self.data)

def __getitem__(self, idx):

feature = torch.FloatTensor(self.features[idx])

label = torch.LongTensor([self.labels[idx]])[0]

if self.transform:

feature = self.transform(feature)

return feature, label

# 使用DataLoader

dataset = CustomDataset('data.csv')

dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)

# 训练循环中的数据使用

for epoch in range(10):

for batch_idx, (data, target) in enumerate(dataloader):

# 将数据移动到GPU（如果可用）

if torch.cuda.is_available():

data, target = data.cuda(), target.cuda()

# 训练步骤...

print(f'Batch {batch_idx}, Data shape: {data.shape}, Target shape: {target.shape}')

7.2 模型保存与加载

正确的模型持久化策略对项目至关重要：

PYTHON

import torch

import torch.nn as nn

# 简单的神经网络模型

class SimpleNN(nn.Module):

def __init__(self):

super(SimpleNN, self).__init__()

self.fc1 = nn.Linear(10, 50)

self.fc2 = nn.Linear(50, 1)

self.relu = nn.ReLU()

def forward(self, x):

x = self.relu(self.fc1(x))

x = self.fc2(x)

return x

model = SimpleNN()

# 方法1：保存整个模型（不推荐用于生产）

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

loaded_model = torch.load('model_complete.pth')

# 方法2：只保存状态字典（推荐）

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

# 加载时需要先创建模型结构

new_model = SimpleNN()

new_model.load_state_dict(torch.load('model_state_dict.pth'))

# 方法3：保存检查点（包含额外信息）

checkpoint = {

'epoch': 10,

'model_state_dict': model.state_dict(),

'optimizer_state_dict': torch.optim.Adam(model.parameters()).state_dict(),

'loss': 0.05,

}

torch.save(checkpoint, 'checkpoint.pth')

# 加载检查点

checkpoint = torch.load('checkpoint.pth')

model.load_state_dict(checkpoint['model_state_dict'])

optimizer = torch.optim.Adam(model.parameters())

optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

epoch = checkpoint['epoch']

loss = checkpoint['loss']

7.3 分布式训练基础

对于大规模数据集和模型，分布式训练可以显著加速训练过程：

PYTHON

import torch

import torch.distributed as dist

import torch.nn as nn

from torch.nn.parallel import DistributedDataParallel as DDP

def setup(rank, world_size):

"""初始化分布式环境"""

dist.init_process_group("gloo", rank=rank, world_size=world_size)

def cleanup():

"""清理分布式环境"""

dist.destroy_process_group()

class ToyModel(nn.Module):

def __init__(self):

super(ToyModel, self).__init__()

self.net1 = nn.Linear(10, 10)

self.relu = nn.ReLU()

self.net2 = nn.Linear(10, 5)

def forward(self, x):

return self.net2(self.relu(self.net1(x)))

def demo_basic(rank, world_size):

"""基本的DDP示例"""

setup(rank, world_size)

# 创建模型并移动到GPU

model = ToyModel().to(rank)

ddp_model = DDP(model, device_ids=[rank])

# 模拟训练步骤

loss_fn = nn.MSELoss()

optimizer = torch.optim.SGD(ddp_model.parameters(), lr=0.001)

# 训练循环

for _ in range(10):

optimizer.zero_grad()

outputs = ddp_model(torch.randn(20, 10).to(rank))

labels = torch.randn(20, 5).to(rank)

loss_fn(outputs, labels).backward()

optimizer.step()

cleanup()

# 注意：分布式训练通常需要命令行启动

# 例如：python -m torch.distributed.launch --nproc_per_node=2 ddp_example.py

8. PyTorch生态系统与扩展库

8.1 主要扩展库介绍

PyTorch的强大不仅在于核心框架，还在于其丰富的生态系统：

TorchVision：计算机视觉库，提供数据集、模型架构和图像变换

PYTHON

import torchvision

from torchvision import datasets, transforms, models

# 加载CIFAR-10数据集

transform = transforms.Compose([

transforms.ToTensor(),

transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

])

trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True)

TorchText：自然语言处理库，提供文本数据处理工具

PYTHON

import torchtext

from torchtext.data import Field, BucketIterator

# 定义文本处理字段

TEXT = Field(tokenize='spacy', lower=True, include_lengths=True)

LABEL = Field(sequential=False, use_vocab=False)

# 加载IMDb电影评论数据集

from torchtext.datasets import IMDB

PyTorch Geometric：图神经网络库，支持图数据结构的学习算法

PYTHON

import torch_geometric

from torch_geometric.datasets import Planetoid

# 加载Cora引文网络数据集

dataset = Planetoid(root='/tmp/Cora', name='Cora')

8.2 模型解释性与可解释性

Captum库提供了模型解释工具，帮助理解模型决策过程：

PYTHON

import torch

import torch.nn as nn

from captum.attr import IntegratedGradients

class SimpleModel(nn.Module):

def __init__(self):

super(SimpleModel, self).__init__()

self.linear = nn.Linear(5, 1)

def forward(self, x):

return self.linear(x)

model = SimpleModel()

ig = IntegratedGradients(model)

# 创建输入

input_tensor = torch.randn(1, 5, requires_grad=True)

# 计算特征归因

attributions, delta = ig.attribute(input_tensor, target=0, return_convergence_delta=True)

print(f"特征归因: {attributions}")

print(f"收敛差值: {delta}")

9. 性能优化与调试技巧

9.1 内存优化策略

深度学习模型常常受限于GPU内存，以下技巧可以帮助优化内存使用：

梯度检查点： trade计算时间换内存空间

PYTHON

import torch

from torch.utils.checkpoint import checkpoint

class MemoryEfficientModel(nn.Module):

def __init__(self):

super().__init__()

self.blocks = nn.ModuleList([nn.Linear(1000, 1000) for _ in range(10)])

def forward(self, x):

for block in self.blocks:

# 使用梯度检查点减少内存使用

x = checkpoint(block, x)

return x

混合精度训练：使用FP16精度减少内存占用并加速训练

PYTHON

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for input, target in dataloader:

optimizer.zero_grad()

with autocast():

output = model(input)

loss = criterion(output, target)

scaler.scale(loss).backward()

scaler.step(optimizer)

scaler.update()

9.2 调试与性能分析

PyTorch提供了强大的性能分析工具：

PYTHON

import torch

import torch.autograd.profiler as profiler

# 性能分析

model = nn.Linear(1000, 1000)

input = torch.randn(1000, 1000)

with profiler.profile(use_cuda=True) as prof:

for _ in range(10):

output = model(input)

output.sum().backward()

print(prof.key_averages().table(sort_by="cuda_time_total"))

10. 生产环境部署考虑

10.1 模型导出与优化

将PyTorch模型部署到生产环境需要考虑格式转换和优化：

TorchScript导出：创建可序列化的模型版本

PYTHON

import torch

class MyModel(torch.nn.Module):

def __init__(self):

super().__init__()

self.linear = torch.nn.Linear(10, 1)

def forward(self, x):

return self.linear(x)

model = MyModel()

model.eval()

# 导出为TorchScript

example_input = torch.randn(1, 10)

traced_script_module = torch.jit.trace(model, example_input)

traced_script_module.save("model_scripted.pt")

# 加载导出的模型

loaded_model = torch.jit.load("model_scripted.pt")

ONNX格式导出：实现框架间互操作性

PYTHON

import torch.onnx

# 导出为ONNX格式

torch.onnx.export(model, example_input, "model.onnx",

input_names=['input'], output_names=['output'],

dynamic_axes={'input': {0: 'batch_size'},

'output': {0: 'batch_size'}})

10.2 使用TorchServe部署

TorchServe是PyTorch官方模型服务框架：

BASH

# 安装TorchServe

pip install torchserve torch-model-archiver

# 打包模型

torch-model-archiver --model-name my_model --version 1.0 --model-file model.py --serialized-file model.pth --handler image_classifier

# 启动服务

torchserve --start --model-store model_store --models my_model=my_model.mar

通过系统学习PyTorch的安装、基础使用和高级特性，开发者可以充分利用这一强大框架进行深度学习项目开发。从环境配置到模型部署，每个环节都有相应的最佳实践和工具支持，使得PyTorch成为当今最受欢迎的深度学习框架之一。