本教程是关于使用Python和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.]])
您可以使用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'>
同样,您也可以使用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 %
本文链接:http://task.lmcjl.com/news/5201.html