深度学习 之 Pytorch基础（一）——基本概念和语句使用

Pytorch基础（一）——基本概念和语句使用

PyTorch是一个基于Python的科学计算库，它支持动态图和静态图两种计算方式，并且具有可扩展性和高效性。在PyTorch中，以下是一些基本概念和语句的使用。

(1) 基本概念

• Tensor：PyTorch中的数据结构，类似于Numpy的ndarray，但是支持GPU加速和自动求导。
• Module：PyTorch中的一个抽象概念，表示一个可学习的模型组件，可以是一个神经网络层、一个损失函数、一个优化器等。PyTorch中的模型由层（Layers）组成，每个层包含一些可训练的参数，如权重和偏置。用户可以使用PyTorch的内置层（如全连接层、卷积层、循环神经网络层等）构建自己的模型。
• Automatic Differentiation：PyTorch中的自动微分功能使得神经网络的反向传播变得十分容易。用户只需要定义前向传播函数，PyTorch会自动计算梯度，并将梯度传递回去进行反向传播。
• Autograd：PyTorch中的自动求导机制，可以自动计算Tensor的梯度，方便进行反向传播算法。
• Loss Function：用于衡量模型预测结果与真实结果之间的误差。
• DataLoader：PyTorch中的数据加载器，可以自动将数据集分批次加载，方便训练模型。
• Optimizers：PyTorch中的优化器用于更新模型的参数，以最小化损失函数。PyTorch提供了多种优化器，如随机梯度下降（SGD）、Adam、Adagrad等。

(2) 语句使用

• 创建Tensor：可以使用torch.Tensor()创建一个Tensor对象，也可以使用torch.randn()创建一个随机数的Tensor对象。
• 自动求导：可以通过设置Tensor的requires_grad属性为True，启用自动求导功能。
• 定义模型：可以通过继承nn.Module类来定义模型，模型中需要实现forward()函数进行前向计算。
• 模型训练：可以使用torch.optim中的优化器来更新模型参数，使用loss.backward()进行反向传播计算梯度，使用optimizer.step()进行参数更新。
• 数据加载：可以使用torch.utils.data中的Dataset和DataLoader类来加载数据集，其中Dataset表示数据集，DataLoader表示数据加载器，可以设置batch_size、shuffle等参数。
• GPU加速：PyTorch支持在GPU上进行计算，可以使用.to()方法将Tensor对象移动到GPU上，使用torch.cuda.is_available()判断是否支持GPU加速。
• 模型保存和加载：可以使用torch.save()将模型保存到文件中，使用torch.load()加载保存的模型。
• 模型评估：可以使用torch.no_grad()关闭自动求导功能，然后对模型进行评估，比如计算准确率、F1值等指标。

(3) 代码使用

• 创建一个Tensor对象：

import torch

# 创建一个5x3的float类型的零张量
x = torch.zeros(5, 3)

# 创建一个3x3的float类型的随机张量
y = torch.rand(3, 3)

# 张量加法
z = x + y

# 张量转置
z = x.transpose(0, 1)

# 张量重塑
z = x.view(-1, 5)

• 使用自动求导功能：

import torch

# 创建一个需要求导的张量
x = torch.tensor([2.0, 3.0], requires_grad=True)

# 计算张量的函数
y = x**2 + 2*x + 1

# 求导
y.backward()

# 查看导数
print(x.grad)

• 定义一个模型：

import torch.nn as nn

# 定义一个全连接层
layer = nn.Linear(5, 10)

# 定义一个网络
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(5, 10)
        self.layer2 = nn.Linear(10, 1)

    def forward(self, x):
        x = self.layer1(x)
        x = torch.relu(x)
        x = self.layer2(x)
        return x

# 实例化网络
net = Net()

• 损失函数和优化器

import torch.optim as optim

# 定义一个均方误差损失函数
loss_fn = nn.MSELoss()

# 定义一个Adam优化器
optimizer = optim.Adam(net.parameters(), lr=0.001)

• 使用优化器更新模型参数：

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

net = Net()
criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

for inputs, labels in dataloader:
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

• 使用DataLoader加载数据集：

import torch.utils.data as data

class MyDataset(data.Dataset):
    def __init__(self, data):
        self.data = data
        
    def __getitem__(self, index): 
        return self.data[index]
    
    def __len__(self):
        return len(self.data)
    
dataset = MyDataset(data)
dataloader = data.DataLoader(dataset, batch_size=32, shuffle=True)

• 使用GPU加速：

import torch

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x = torch.Tensor([1, 2, 3]).to(device)

• 保存和加载模型：

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

net = Net()
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 训练模型
...

# 保存模型
torch.save(net.state_dict(), 'model.pth')

# 加载模型
net.load_state_dict(torch.load('model.pth'))

• 训练模型

# 将模型设置为训练模式
net.train()

# 迭代训练数据集
for inputs, labels in dataloader:

    # 将数据放入设备中
    inputs, labels = inputs.to(device), labels.to(device)

    # 清空梯度
    optimizer.zero_grad()

    # 前向传播
    outputs = net(inputs)

    # 计算损失
    loss = loss_fn(outputs, labels)

    # 反向传播
    loss.backward()

    # 更新参数
    optimizer.step()

• 模型评估：

# 将模型设置为评估模式
net.eval()

# 禁用梯度计算
with torch.no_grad():

    # 迭代测试数据集
    for inputs, labels in test_dataloader:

        # 将数据放入设备中
        inputs, labels = inputs.to(device), labels.to(device)

        # 前向传播
        outputs = net(inputs)

        # 计算损失
        loss = loss_fn(outputs, labels)

        # 计算精度
        acc = accuracy(outputs, labels)

        # 更新指标
        test_loss += loss.item()
        test_acc += acc.item()

# 计算平均损失和精度
test_loss /= len(test_dataloader)
test_acc /= len(test_dataloader)