AI 九、Python中，PyTorch基础与应用

十方来财

已于 2025-02-24 17:13:17 修改

阅读量112

点赞数 2

分类专栏： ai 文章标签：人工智能 python pytorch

于 2025-02-24 16:36:48 首次发布

本文链接：https://blog.youkuaiyun.com/WithCYwind/article/details/145832145

版权

ai 专栏收录该内容

16 篇文章

订阅专栏

PyTorch是一个开源的深度学习框架，广泛应用于学术研究和工业实践中，特别是在计算机视觉（CV）、自然语言处理（NLP）以及强化学习等领域。它以动态图计算（dynamic computation graph）为特点，支持自动求导（autograd），并且具有强大的GPU加速能力。PyTorch的灵活性和易用性使得它成为了许多机器学习工程师和研究者的首选框架。

1. PyTorch基础

1.1 Tensor（张量）

在PyTorch中，Tensor是核心数据结构，类似于NumPy的ndarray，但提供了更多的功能，如GPU加速和自动求导。

创建Tensor：

import torch

# 创建一个从0到9的Tensor
a = torch.arange(10)
print(a)

# 创建一个5x5的零矩阵
b = torch.zeros(5, 5)
print(b)

# 创建一个5x5的随机矩阵
c = torch.rand(5, 5)
print(c)

# 使用GPU（CUDA）创建Tensor
d = torch.ones(2, 2, device='cuda')
print(d)

1.2 Tensor运算

PyTorch提供了丰富的操作，可以在Tensor上进行加法、乘法等操作。

x = torch.tensor([1, 2, 3], dtype=torch.float32)
y = torch.tensor([4, 5, 6], dtype=torch.float32)

# 加法
z1 = x + y
print(z1)

# 矩阵乘法（点乘）
z2 = torch.dot(x, y)
print(z2)

# 逐元素相乘
z3 = x * y
print(z3)

1.3 自动求导（Autograd）

PyTorch的自动求导机制允许你自动计算梯度，特别适用于训练深度学习模型。

# 创建一个张量，启用梯度计算
x = torch.ones(2, 2, requires_grad=True)

# 对张量进行计算
y = x + 2
z = y * y * 3

# 计算梯度
z.mean().backward()

# 打印梯度
print(x.grad)

1.4 神经网络（nn模块）

PyTorch的torch.nn模块是用于构建神经网络的核心模块。它提供了各种层、激活函数以及优化器等功能。

import torch.nn as nn

# 定义一个简单的神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(3, 3)  # 输入3，输出3
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        return x

# 创建一个网络实例
model = SimpleNN()

# 创建输入数据
input_data = torch.tensor([1.0, 2.0, 3.0])

# 前向传播
output = model(input_data)
print(output)

2. PyTorch应用

2.1 线性回归

线性回归是一个简单的回归任务，可以帮助我们了解PyTorch的基础使用。

import torch
import torch.nn as nn
import torch.optim as optim

# 创建数据集
x_train = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
y_train = torch.tensor([[2.0], [4.0], [6.0], [8.0]])

# 创建线性回归模型
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 = optim.SGD(model.parameters(), lr=0.01)  # 使用随机梯度下降优化

# 训练模型
for epoch in range(1000):
    # 前向传播
    y_pred = model(x_train)

    # 计算损失
    loss = criterion(y_pred, y_train)

    # 反向传播和优化
    optimizer.zero_grad()  # 清除之前的梯度
    loss.backward()  # 计算梯度
    optimizer.step()  # 更新参数

    if (epoch+1) % 100 == 0:
        print(f"Epoch [{epoch+1}/1000], Loss: {loss.item():.4f}")

# 查看训练后的模型参数
print(f"Trained model parameters: {model.linear.weight.item()}, {model.linear.bias.item()}")

2.2 图像分类

PyTorch特别适合处理图像数据，通过与torchvision结合，可以轻松实现图像分类任务。

pip install torchvision

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 定义数据转换
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 下载和加载MNIST数据集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True)

# 定义神经网络结构
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)  # 输入1通道，输出6通道，卷积核大小为5
        self.pool = nn.MaxPool2d(2, 2)  # 最大池化，大小为2
        self.fc1 = nn.Linear(6 * 12 * 12, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 6 * 12 * 12)  # 扁平化
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 创建模型实例
model = SimpleCNN()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 训练模型
for epoch in range(2):  # 遍历数据集2次
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        # 零梯度
        optimizer.zero_grad()

        # 前向传播 + 反向传播 + 优化
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 打印损失
        running_loss += loss.item()
        if i % 2000 == 1999:  # 每2000个mini-batches打印一次
            print(f"[{epoch + 1}, {i + 1}] loss: {running_loss / 2000:.3f}")
            running_loss = 0.0

print("Finished Training")