神经网络学习小记录10——利用PyTorch进行回归运算

左手的ㄟ右手 2023-08-17 17:16 167阅读 0赞

神经网络学习小记录10——利用PyTorch进行回归运算

  • 学习前言
  • PyTorch中的重要基础函数
    • 1、class Net(torch.nn.Module)神经网络的构建:
    • 2、optimizer优化器
    • 3、loss损失函数定义
    • 4、训练过程
  • 全部代码

学习前言

我发现不仅有很多的Keras模型，还有很多的PyTorch模型，还是学学Pytorch吧，我也想了解以下tensor到底是个啥。
在这里插入图片描述

PyTorch中的重要基础函数

1、class Net(torch.nn.Module)神经网络的构建:

PyTorch中神经网络的构建和Tensorflow的不一样，它需要用一个类来进行构建(后面还可以用与Keras类似的Sequential模型构建)，当然基础还是用类构建，这个类需要继承PyTorch中的神经网络模型，torch.nn.Module，具体构建方式如下：

  1. # 继承torch.nn.Module模型
  2. class Net(torch.nn.Module):
  3.     # 重载初始化函数（我忘了这个是不是叫重载）
  4.     def __init__(self, n_feature, n_hidden, n_output):
  5.         super(Net, self).__init__()
  6.         # Applies a linear transformation to the incoming data: :math:y = xA^T + b
  7.         # 全连接层，公式为y = xA^T + b
  8.         # 在初始化的同时构建两个全连接层（也就是一个隐含层）
  9.         self.hidden = torch.nn.Linear(n_feature, n_hidden)
  10.         self.predict = torch.nn.Linear(n_hidden, n_output)
  12.     # forward函数用于构建前向传递的过程
  13.     def forward(self, x):
  14.         # 隐含层的输出
  15.         hidden_layer = functional.relu(self.hidden(x))
  16.         # 实际的输出
  17.         output_layer = self.predict(hidden_layer)
  18.         return output_layer

该部分构建了一个含有一层隐含层的神经网络，隐含层神经元个数为n_hidden。
在建立了上述的类后，就可以通过如下函数建立神经网络：

  1. net = Net(n_feature=1, n_hidden=10, n_output=1)

2、optimizer优化器

optimizer用于构建模型的优化器，与tensorflow中优化器的意义相同，PyTorch的优化器在前缀为torch.optim的库中。
优化器需要传入net网络的参数。
具体使用方式如下：

  1. # torch.optim是优化器模块
  2. # Adam可以改成其它优化器，如SGD、RMSprop等
  3. optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)

3、loss损失函数定义

loss用于定义神经网络训练的损失函数，常用的损失函数是均方差损失函数（回归）和交叉熵损失函数（分类）。
具体使用方式如下：

  1. # 均方差loss
  2. loss_func = torch.nn.MSELoss()

4、训练过程

训练过程分为三个步骤：
1、利用网络预测结果。

  1. prediction = net(x)

2、利用预测的结果与真实值对比生成loss。

  1. loss = loss_func(prediction, y)

3、进行反向传递（该部分有三步）。

  1. # 均方差loss
  2. # 反向传递步骤
  3. # 1、初始化梯度
  4. optimizer.zero_grad()
  5. # 2、计算梯度
  6. loss.backward()
  7. # 3、进行optimizer优化
  8. optimizer.step()

全部代码

这是一个简单的回归预测模型。

  1. import torch
  2. from torch.autograd import Variable
  3. import torch.nn.functional as functional
  5. import matplotlib.pyplot as plt
  6. import numpy as np
  8. # x的shape为(100,1)
  9. x = torch.from_numpy(np.linspace(-1,1,100).reshape([100,1])).type(torch.FloatTensor)
  10. # y的shape为(100,1)
  11. y = torch.sin(x) + 0.2*torch.rand(x.size())
  13. class Net(torch.nn.Module):
  14.     def __init__(self, n_feature, n_hidden, n_output):
  15.         super(Net, self).__init__()
  16.         # Applies a linear transformation to the incoming data: :math:y = xA^T + b
  17.         # 全连接层，公式为y = xA^T + b
  18.         self.hidden = torch.nn.Linear(n_feature, n_hidden)
  19.         self.predict = torch.nn.Linear(n_hidden, n_output)
  21.     def forward(self, x):
  22.         # 隐含层的输出
  23.         hidden_layer = functional.relu(self.hidden(x))
  24.         output_layer = self.predict(hidden_layer)
  25.         return output_layer
  27. # 类的建立
  28. net = Net(n_feature=1, n_hidden=10, n_output=1)
  30. # torch.optim是优化器模块
  31. optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)
  33. # 均方差loss
  34. loss_func = torch.nn.MSELoss() 
  36. for t in range(1000):
  37.     prediction = net(x)
  38.     loss = loss_func(prediction, y)
  40.     # 反向传递步骤
  41.     # 1、初始化梯度
  42.     optimizer.zero_grad()
  43.     # 2、计算梯度
  44.     loss.backward()
  45.     # 3、进行optimizer优化
  46.     optimizer.step()
  48.     if t & 50 == 0:
  49.         print("The loss is",loss.data.numpy())

运行结果为：

  1. The loss is 0.27913737
  2. The loss is 0.2773982
  3. The loss is 0.27224126
  4. …………
  5. The loss is 0.0035993527
  6. The loss is 0.0035974088
  7. The loss is 0.0035967692

有不懂的朋友可以评论询问噢。

发表评论

表情：
评论列表 （有 0 条评论，167人围观）

还没有评论，来说两句吧...

相关阅读