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

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

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

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

# 学习前言 #

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

# PyTorch中的重要基础函数 #

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

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

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

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

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

## 2、optimizer优化器 ##

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

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

## 3、loss损失函数定义 ##

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

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

## 4、训练过程 ##

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

prediction = net(x)

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

loss = loss_func(prediction, y)

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

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

# 全部代码 #

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

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

运行结果为：

The loss is 0.27913737
    The loss is 0.2773982
    The loss is 0.27224126
    …………
    The loss is 0.0035993527
    The loss is 0.0035974088
    The loss is 0.0035967692

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

[20190723165901974.jpg_pic_center]: /images/20230808/d2ac4f0877b9482dbf2bb736864b6e70.png