当前位置:首页> AI教程> PyTorch简明教程:四则运算和线性回归实践

PyTorch简明教程:四则运算和线性回归实践

释放双眼,带上耳机,听听看~!
这篇文章主要介绍PyTorch的四则运算和线性回归实践,适合初学者入门学习。

前面几篇文章介绍了特征归一化和张量,接下来开始写两篇PyTorch简明教程,主要介绍PyTorch简单实践。

1、四则运算

import torch

a = torch.tensor([234])
b = torch.tensor([345])
print("a + b: ", (a + b).numpy())
print("a - b: ", (a - b).numpy())
print("a * b: ", (a * b).numpy())
print("a / b: ", (a / b).numpy())

加减乘除就不用多解释了,输出为:

a + b:  [5 7 9]
a - b:  [-1 -1 -1]
a * b:  [ 6 12 20]
a / b:  [0.6666667 0.75      0.8      ]

2、线性回归

线性回归是找到一条直线尽可能接近已知点,如图:

PyTorch简明教程:四则运算和线性回归实践

图1

import torch
from torch import optim

def build_model1():
    return torch.nn.Sequential(
        torch.nn.Linear(11, bias=False)
    )

def build_model2():
    model = torch.nn.Sequential()
    model.add_module("linear", torch.nn.Linear(11, bias=False))
    return model

def train(model, loss, optimizer, x, y):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x.view(len(x), 1)).squeeze()
    output = loss.forward(fx, y)
    output.backward()
    optimizer.step()
    return output.item()

def main():
    torch.manual_seed(42)
    X = torch.linspace(-11101, requires_grad=False)
    Y = 2 * X + torch.randn(X.size()) * 0.33
    print("X: ", X.numpy(), ", Y: ", Y.numpy())
    model = build_model1()
    loss = torch.nn.MSELoss(reduction='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 10

    for i in range(100):
        cost = 0.
        num_batches = len(X) // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer, X[start:end], Y[start:end])
        print("Epoch = %d, cost = %s" % (i + 1, cost / num_batches))

    w = next(model.parameters()).data
    print("w = %.2f" % w.numpy())

if __name__ == "__main__":
    main()

(1)先从main函数开始,torch.manual_seed(42)用于设置随机数生成器的种子,以确保在每次运行时生成的随机数序列相同,该函数接受一个整数参数作为种子,可以在训练神经网络等需要随机数的场景中使用,以确保结果的可重复性;
(2)torch.linspace(-1, 1, 101, requires_grad=False)用于在指定的区间内生成一组等间隔的数值,该函数接受三个参数:起始值、终止值和元素个数,返回一个张量,其中包含了指定个数的等间隔数值;
(3)build_model1内部实现:

  • torch.nn.Sequential(torch.nn.Linear(1, 1, bias=False))中使用nn.Sequential类的构造函数,将线性层作为参数传递给它,然后返回一个包含该线性层的神经网络模型;
  • build_model2build_model1功能一样,使用add_module()方法向其中添加了一个名为linear的子模块;

(4)torch.nn.MSELoss(reduction='mean')定义损失函数;
(5)optim.SGD(model.parameters(), lr=0.01, momentum=0.9)实现随机梯度下降(Stochastic Gradient Descent,SGD)优化算法;
(6)通过batch_size将训练集拆分,循环100次;
(7)接下来是训练函数train,用于训练一个神经网络模型,具体来说,该函数接受以下参数:

  • model:神经网络模型,通常是一个继承自nn.Module的类的实例;
  • loss:损失函数,用于计算模型的预测值与真实值之间的差异;
  • optimizer:优化器,用于更新模型的参数;
  • x:输入数据,是一个torch.Tensor类型的张量;
  • y:目标数据,是一个torch.Tensor类型的张量;

(8)train是PyTorch训练步骤的通用方法,步骤如下:

  • 将模型设置为训练模式,即启用dropout和batch normalization等训练时使用的特殊操作;
  • 将优化器的梯度缓存清零,以便进行新一轮的梯度计算;
  • 将输入数据传递给模型,计算模型的预测值,并将预测值与目标数据传递给损失函数,计算损失值;
  • 对损失值进行反向传播,计算模型参数的梯度;
  • 使用优化器更新模型参数,以最小化损失值;
  • 返回损失值的标量值;

(9)print("Epoch = %d, cost = %s" % (i + 1, cost / num_batches))最后打印当前训练的轮次和损失值,上述的代码输入如下:

...
Epoch = 95, cost = 0.10514946877956391
Epoch = 96, cost = 0.10514946877956391
Epoch = 97, cost = 0.10514946877956391
Epoch = 98, cost = 0.10514946877956391
Epoch = 99, cost = 0.10514946877956391
Epoch = 100, cost = 0.10514946877956391
w = 1.98

3、逻辑回归

逻辑回归即用一根曲线近似表示一堆离散点的轨迹,如图:

PyTorch简明教程:四则运算和线性回归实践

图2

import numpy as np
import torch
from torch import optim
from data_util import load_mnist

def build_model(input_dim, output_dim):
    return torch.nn.Sequential(
        torch.nn.Linear(
            input_dim, output_dim, bias=False)
    )

def train(model, loss, optimizer, x_val, y_val):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x_val)
    output = loss.forward(fx, y_val)
    output.backward()
    optimizer.step()
    return output.item()

def predict(model, x_val):
    model.eval()
    output = model.forward(x_val)
    return output.data.numpy().argmax(axis=1)

def main():
    torch.manual_seed(42)
    trX, teX, trY, teY = load_mnist(onehot=False)
    trX = torch.from_numpy(trX).float()
    teX = torch.from_numpy(teX).float()
    trY = torch.tensor(trY)

    n_examples, n_features = trX.size()
    n_classes = 10
    model = build_model(n_features, n_classes)
    loss = torch.nn.CrossEntropyLoss(reduction='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 100

    for i in range(100):
        cost = 0.
        num_batches = n_examples // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer,
                          trX[start:end], trY[start:end])
        predY = predict(model, teX)
        print("Epoch %d, cost = %f, acc = %.2f%%"
              % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))


if __name__ == "__main__":
    main()

(1)先从main函数开始,torch.manual_seed(42)上面有介绍,在此略过;
(2)load_mnist是自己实现下载mnist数据集,返回trXteX是输入数据,trYteY是标签数据;
(3)build_model内部实现:torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, bias=False))用于构建一个包含一个线性层的神经网络模型,模型的输入特征数量为input_dim,输出特征数量为output_dim,且该线性层没有偏置项,其中n_classes=10表示输出10个分类;
(4)其他的步骤就是定义损失函数,梯度下降优化器,通过batch_size将训练集拆分,循环100次进行train
(5)optim.SGD(model.parameters(), lr=0.01, momentum=0.9)实现随机梯度下降(Stochastic Gradient Descent,SGD)优化算法;
(6)每一轮训练完成后,执行predict,该函数接受两个参数model(训练好的模型)和teX(需要预测的数据),步骤如下:

  • model.eval()模型设置为评估模式,这意味着模型将不会进行训练,而是仅用于推理;
  • 将output转换为NumPy数组,并使用argmax()方法获取每个样本的预测类别;

(7)print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印当前训练的轮次,损失值和acc,上述的代码输入如下(执行很快,但是准确率偏低):

...
Epoch 91, cost = 0.252863, acc = 92.52%
Epoch 92, cost = 0.252717, acc = 92.51%
Epoch 93, cost = 0.252573, acc = 92.50%
Epoch 94, cost = 0.252431, acc = 92.50%
Epoch 95, cost = 0.252291, acc = 92.52%
Epoch 96, cost = 0.252153, acc = 92.52%
Epoch 97, cost = 0.252016, acc = 92.51%
Epoch 98, cost = 0.251882, acc = 92.51%
Epoch 99, cost = 0.251749, acc = 92.51%
Epoch 100, cost = 0.251617, acc = 92.51%

4、神经网络

一个经典的LeNet网络,用于对字符进行分类,如图:

PyTorch简明教程:四则运算和线性回归实践

图3

  • 定义一个多层的神经网络
  • 对数据集的预处理并准备作为网络的输入
  • 将数据输入到网络
  • 计算网络的损失
  • 反向传播,计算梯度
import numpy as np
import torch
from torch import optim
from data_util import load_mnist

def build_model(input_dim, output_dim):
    return torch.nn.Sequential(
        torch.nn.Linear(input_dim, 512, bias=False),
        torch.nn.Sigmoid(),
        torch.nn.Linear(512, output_dim, bias=False)
    )

def train(model, loss, optimizer, x_val, y_val):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x_val)
    output = loss.forward(fx, y_val)
    output.backward()
    optimizer.step()
    return output.item()

def predict(model, x_val):
    model.eval()
    output = model.forward(x_val)
    return output.data.numpy().argmax(axis=1)

def main():
    torch.manual_seed(42)
    trX, teX, trY, teY = load_mnist(onehot=False)
    trX = torch.from_numpy(trX).float()
    teX = torch.from_numpy(teX).float()
    trY = torch.tensor(trY)

    n_examples, n_features = trX.size()
    n_classes = 10
    model = build_model(n_features, n_classes)
    loss = torch.nn.CrossEntropyLoss(reduction='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 100

    for i in range(100):
        cost = 0.
        num_batches = n_examples // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer,
                          trX[start:end], trY[start:end])
        predY = predict(model, teX)
        print("Epoch %d, cost = %f, acc = %.2f%%"
              % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))

if __name__ == "__main__":
    main()

(1)以上这段神经网络的代码与逻辑回归没有太多的差异,区别的地方是build_model,这里是构建一个包含两个线性层和一个Sigmoid激活函数的神经网络模型,该模型包含一个输入特征数量为input_dim,输出特征数量为output_dim的线性层,一个Sigmoid激活函数,以及一个输入特征数量为512,输出特征数量为output_dim的线性层;
(2)print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印当前训练的轮次,损失值和acc,上述的代码输入如下(执行时间比逻辑回归要长,但是准确率要高很多):

...
Epoch 91, cost = 0.054484, acc = 97.58%
Epoch 92, cost = 0.053753, acc = 97.56%
Epoch 93, cost = 0.053036, acc = 97.60%
Epoch 94, cost = 0.052332, acc = 97.61%
Epoch 95, cost = 0.051641, acc = 97.63%
Epoch 96, cost = 0.050964, acc = 97.66%
Epoch 97, cost = 0.050298, acc = 97.66%
Epoch 98, cost = 0.049645, acc = 97.67%
Epoch 99, cost = 0.049003, acc = 97.67%
Epoch 100, cost = 0.048373, acc = 97.68%

参考

(1)github.com/vinhkhuc/Py…
(2)zhuanlan.zhihu.com/p/25572330

本网站的内容主要来自互联网上的各种资源,仅供参考和信息分享之用,不代表本网站拥有相关版权或知识产权。如您认为内容侵犯您的权益,请联系我们,我们将尽快采取行动,包括删除或更正。
AI教程

Stable Diffusion实验室最新模型ControlNet的重新上色能力

2023-11-21 11:14:14

AI教程

使用Midjourney生成逼真图像的技巧

2023-11-21 11:24:14

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索