1. Python技术站首页
  2. 人工智能
  3. PyTorch

python机器学习pytorch 张量基础教程

• PyTorch

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技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月16日
下一篇 2023年5月17日

相关文章

  • Pytorch模型保存和加载

    保存模型： torch.save(model, ‘model.pth’) 加载模型： model = torch.load(‘model.pth’)  

    PyTorch 2023年4月8日
    00

  • pytorch 实现查看网络中的参数

    在PyTorch中，我们可以使用state_dict()方法来查看网络中的参数。state_dict()方法返回一个字典对象，该字典对象包含了网络中所有的参数和对应的值。本文将详细讲解如何使用PyTorch实现查看网络中的参数，并提供两个示例说明。 1. 查看网络中的参数 在PyTorch中，我们可以使用state_dict()方法来查看网络中的参数。以下是…

    PyTorch 2023年5月15日
    00
  • pytorch 4 regression 回归 PyTorch

    pytorch 4 regression 回归

    import torch import torch.nn.functional as F import matplotlib.pyplot as plt # torch.manual_seed(1) # reproducible x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # 将1维数据转换成…

    2023年4月8日
    00
  • Pytorch tutorial 之Transfer Learning PyTorch

    Pytorch tutorial 之Transfer Learning

    引自官方：  Transfer Learning tutorial Ng在Deeplearning.ai中讲过迁移学习适用于任务A、B有相同输入、任务B比任务A有更少的数据、A任务的低级特征有助于任务B。对于迁移学习，经验规则是如果任务B的数据很小，那可能只需训练最后一层的权重。若有足够多的数据则可以重新训练网络中的所有层。如果重新训练网络中的所有参数，这个…

    2023年4月8日
    00

  • pytorch将cpu训练好的模型参数load到gpu上，或者gpu->cpu上

    假设我们只保存了模型的参数(model.state_dict())到文件名为modelparameters.pth, model = Net() 1. cpu -> cpu或者gpu -> gpu: checkpoint = torch.load(‘modelparameters.pth’) model.load_state_dict(check…

    PyTorch 2023年4月8日
    00
  • pytorch中tensor张量数据基础入门 PyTorch

    pytorch中tensor张量数据基础入门

    pytorch张量数据类型入门1、对于pytorch的深度学习框架，其基本的数据类型属于张量数据类型，即Tensor数据类型，对于python里面的int,float,int array,flaot array对应于pytorch里面即在前面加一个Tensor即可——intTensor ,Float tensor,IntTensor of size [d1,…

    2023年4月8日
    00
  • PyTorch实现TPU版本CNN模型 PyTorch

    PyTorch实现TPU版本CNN模型

    作者|DR. VAIBHAV KUMAR编译|VK来源|Analytics In Diamag 随着深度学习模型在各种应用中的成功实施，现在是时候获得不仅准确而且速度更快的结果。 为了得到更准确的结果，数据的大小是非常重要的，但是当这个大小影响到机器学习模型的训练时间时，这一直是一个值得关注的问题。 为了克服训练时间的问题，我们使用TPU运行时环境来加速训练…

    2023年4月8日
    00

  • pytorch点乘与叉乘示例讲解

    PyTorch点乘与叉乘示例讲解 在PyTorch中，点乘和叉乘是两种常用的向量运算。在本文中，我们将介绍PyTorch中的点乘和叉乘，并提供两个示例说明。 示例1：使用点乘计算两个向量的相似度 以下是一个使用点乘计算两个向量相似度的示例代码： import torch # Define two vectors a = torch.tensor([1, 2,…

    PyTorch 2023年5月16日
    00
合作推广
合作推广
分享本页
返回顶部