Python机器学习PyTorch 张量基础教程

本教程是关于使用Python和PyTorch进行机器学习的入门，其中重点关注了PyTorch中的张量操作。本教程适用于初学者和对机器学习感兴趣的人。

安装PyTorch

在开始之前，您需要安装PyTorch。在Linux或macOS系统上，您可以使用以下命令进行安装：

pip install torch torchvision

如果您使用Windows系统，可以尝试使用以下命令安装：

pip3 install https://download.pytorch.org/whl/cu102/torch-1.7.0-cp38-cp38-win_amd64.whl torchvision

张量基础

在PyTorch中，张量是代表多维数组的核心数据类型。类似于NumPy数组，它可以包含数字、布尔值和字符串等类型。

创建张量

在PyTorch中，您可以使用torch.Tensor类来创建张量。

import torch

# 创建一个3x3的浮点型全0张量
x = torch.zeros(3, 3)

# 输出x
print(x)

这将生成一个3x3的全0张量。

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

您还可以使用其他方法来创建不同类型和形状的张量。

import torch

# 创建一个3x3的长整型全1张量
x = torch.ones(3, 3, dtype=torch.long)

# 输出x
print(x)

这将生成一个3x3的全1张量。

tensor([[1, 1, 1],
        [1, 1, 1],
        [1, 1, 1]])

张量运算

PyTorch提供了各种张量运算，包括加法、减法、乘法和除法等。

import torch

# 创建两个张量
x = torch.ones(2, 2)
y = torch.zeros(2, 2)

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

# 减法
z = x - y
print(z)

# 乘法
z = x * y
print(z)

# 除法
z = x / y
print(z)

# 矩阵乘法
z = x.mm(y)
print(z)

这将分别输出加法、减法、乘法、除法和矩阵乘法的结果。

tensor([[1., 1.],
        [1., 1.]])
tensor([[1., 1.],
        [1., 1.]])
tensor([[0., 0.],
        [0., 0.]])
tensor([[inf, inf],
        [inf, inf]])
tensor([[0., 0.],
        [0., 0.]])

将张量转换为NumPy数组

您可以使用torch.Tensor.numpy()方法将张量转换为NumPy数组。

import torch
import numpy as np

# 创建一个3x3的浮点型全0张量
x = torch.zeros(3, 3)

# 将张量转换为NumPy数组
y = x.numpy()

# 输出数组
print(y)

# 检查类型
print(type(y))

这将生成一个3x3的全0数组，并将其转换为NumPy数组。

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]], dtype=float32)
<class 'numpy.ndarray'>

将NumPy数组转换为张量

同样，您也可以使用torch.from_numpy()方法将NumPy数组转换为张量。

import torch
import numpy as np

# 创建一个3x3的数组
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 将数组转换为张量
y = torch.from_numpy(x)

# 输出张量
print(y)

# 检查类型
print(type(y))

这将生成一个3x3的数组，并将其转换为张量。

tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]], dtype=torch.int32)
<class 'torch.Tensor'>

示例一：线性回归

下面的示例演示了如何使用PyTorch实现简单的线性回归模型。

import torch

# 训练数据
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 LinearRegressionModel(torch.nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred

# 实例化模型
model = LinearRegressionModel()

# 定义损失函数和优化器
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

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

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

    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # 每100次迭代输出一次结果
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, 500, loss.item()))

# 测试模型
x_test = torch.tensor([[5.0]])
y_test = model(x_test).item()
print('Prediction of x = 5: {:.2f}'.format(y_test))

该模型使用梯度下降算法来学习线性方程y=2x。在训练过程中，我们使用平均方差误差损失函数，并在每个epoch之后输出损失。在500个epoch之后，我们对该模型进行测试并计算出预测的值。

输出：

Epoch [100/500], Loss: 0.0283
Epoch [200/500], Loss: 0.0113
Epoch [300/500], Loss: 0.0045
Epoch [400/500], Loss: 0.0019
Epoch [500/500], Loss: 0.0008
Prediction of x = 5: 10.00

示例二：卷积神经网络

下面的示例演示了如何使用PyTorch实现一个简单的卷积神经网络模型，用于对MNIST数字图像进行分类。

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

# 定义超参数
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# 加载MNIST数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor())

# 加载数据集到数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 定义卷积神经网络模型
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.fc = nn.Linear(7*7*32, num_classes)

    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        return out

# 实例化模型
model = ConvNet()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播并优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # 每100个batch输出一次结果
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, total_step, loss.item()))

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Test Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))

该模型包含两个卷积层和一个全连接层，使用Adam优化器和交叉熵损失函数进行训练。在每个epoch之后，它都将验证集上的准确度进行评估。

输出:

Epoch [1/5], Step [100/600], Loss: 0.3563
Epoch [1/5], Step [200/600], Loss: 0.1136
Epoch [1/5], Step [300/600], Loss: 0.0692
Epoch [1/5], Step [400/600], Loss: 0.0443
Epoch [1/5], Step [500/600], Loss: 0.1076
Epoch [1/5], Step [600/600], Loss: 0.0281
Epoch [2/5], Step [100/600], Loss: 0.0318
Epoch [2/5], Step [200/600], Loss: 0.0369
Epoch [2/5], Step [300/600], Loss: 0.0616
Epoch [2/5], Step [400/600], Loss: 0.0201
Epoch [2/5], Step [500/600], Loss: 0.0647
Epoch [2/5], Step [600/600], Loss: 0.0193
Epoch [3/5], Step [100/600], Loss: 0.0532
Epoch [3/5], Step [200/600], Loss: 0.0304
Epoch [3/5], Step [300/600], Loss: 0.0297
Epoch [3/5], Step [400/600], Loss: 0.0148
Epoch [3/5], Step [500/600], Loss: 0.0796
Epoch [3/5], Step [600/600], Loss: 0.0234
Epoch [4/5], Step [100/600], Loss: 0.0263
Epoch [4/5], Step [200/600], Loss: 0.0269
Epoch [4/5], Step [300/600], Loss: 0.0217
Epoch [4/5], Step [400/600], Loss: 0.0453
Epoch [4/5], Step [500/600], Loss: 0.0930
Epoch [4/5], Step [600/600], Loss: 0.1004
Epoch [5/5], Step [100/600], Loss: 0.0448
Epoch [5/5], Step [200/600], Loss: 0.0425
Epoch [5/5], Step [300/600], Loss: 0.0579
Epoch [5/5], Step [400/600], Loss: 0.0356
Epoch [5/5], Step [500/600], Loss: 0.0068
Epoch [5/5], Step [600/600], Loss: 0.0214
Test Accuracy of the model on the 10000 test images: 98.85 %

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：python机器学习pytorch 张量基础教程 - Python技术站