如何用一堆数据进行曲线的拟合，利用pytorch深度学习实现，（模型训练+模型保存+模型加载+曲线拟合运行源码）一看就懂系列

如何用一堆数据进行曲线的拟合，利用pytorch深度学习实现，（模型训练+模型保存+模型加载+曲线拟合运行源码）一看就懂系列

数据进行曲线的拟合，模型训练+模型保存+模型加载+曲线拟合运行源码

• A.模型的定义，（举例:定义线性回归模型）
• B.指定迭代参数，学习率和损失函数
• C.进行模型的训练
• D.模型保存
• E.模型加载和使用
• F.完整代码

首先我们要清楚在开发pytorch深度学习的时候，要进行的以下几步，
重要的是要清楚其背后的数学原理，至少要了解
主要分为以下几个步骤：

A.模型的定义，（举例:定义线性回归模型）

首先继承nn.Module()，其次我们要声明神经网络用到的层，然后定义层与层之间的关系
关于模型定义，其实主要是进行层的声明，以及层与层关系之间的定义，距离是一个简单的线性回归的全链接模型，距离理解可以看注释

	  '''
	**注释部分：**
    因为这个层实现的功能是：y=weights*sqrt(x2+bias),所以有两个参数：
    权值矩阵weights
    偏置矩阵bias
    输入 x 的维度是（in_features,)
    输出 y 的维度是（out_features,) 故而
    bias 的维度是（in_fearures,)，注意这里为什么是in_features,而不是out_features，注意体会这里和Linear层的区别所在
    weights 的维度是（in_features, out_features）注意这里为什么是（in_features, out_features）,而不是（out_features, in_features），注意体会这里和Linear层的区别所在
    '''
  class LinearRegression(nn.Module):#通过继承nn.Module，来获取父类的一些特性，同时实现父类的方法，其中两个重要的方法是__init__()和forward()，当然还有其他方法功能，可以看我另外一篇文章
def __init__(self):
    super(LinearRegression, self).__init__()
    self.linear = nn.Linear(in_features=1, out_features=1)

def forward(self, x):
    out = self.linear(x)
    return out

B.指定迭代参数，学习率和损失函数

	epochs=1000#训练次数
	learning_rate=0.01 #学习率
	optimizer=torch.optim.SGD(model,parameters(),lr=learning_rate)#采用SGD优化器，优化谁呢把参数传递进去
	criterion = nn.MSELoss()#指定损失函数，分类任务用交叉熵，回归任务用MSE损失函数

C.进行模型的训练

for epoch in range(epochs):
    epoch += 1
    #每一次梯度要进行清零
    optimizer.zero_grad()
    #向前传播，传播后的值不一定准确
    outputs = model(x_train)
    #计算损失值
    loss = criterion(outputs, y_train)
    #反向传播
    loss.backward()
    #权重更新
    optimizer.step()
    if epoch % 50 == 0:
        print(epoch)
        print(loss.item())
plt.scatter(x_trainData, y_trainData, c="r")
plt.plot(x_train.data.numpy(), outputs.data.numpy())
plt.show()

D.模型保存

直接将训练好的模型类进行保存

torch.save(model.state_dict(), "./Liner.pth")#模型保存
model.load_state_dict(torch.load("./Liner.pth"))#模型加载

E.模型加载和使用

首先我们要考虑，是将模型加载到哪个神经网络里，所以我们要建立一个和模型一样的神经网络

class LinearRegression(nn.Module):#实际这里通过import导入在模型训练时候搭建的神经网络模型也是可以的，也可以不用重新写这个类
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(in_features=1, out_features=1)

    def forward(self, x):
        out = self.linear(x)
        return out

然后我们进行神经网络实例的生成，然后进行模型加载

pre_model= LinearRegression()#实例生成
pre_model.load_state_dict(torch.load("./Liner.pth"))#模型加载
y = pre_model.forward(torch.from_numpy(x_trainData))#前向传播，预测值
plt.scatter(x_trainData, y.data.numpy(), color="r")#绘制数据点
plt.show()#现实数据

F.完整代码

1.神经网络的搭建和模型训练以及模型保存

import torch
from torch import nn,optim
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt
x_trainData = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                    [9.779], [6.182], [7.59], [2.167], [7.042],
                    [10.791], [5.313], [7.997], [3.1]],dtype=np.float32)
y_trainData = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
                    [3.366], [2.596], [2.53], [1.221], [2.827],
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
x_train = torch.from_numpy(x_trainData)
y_train = torch.from_numpy(y_trainData)


class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(in_features=1, out_features=1)

    def forward(self, x):
        out = self.linear(x)
        return out


model = LinearRegression()

epochs = 10000
leaning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=leaning_rate)
criterion = nn.MSELoss()

for epoch in range(epochs):
    epoch += 1
    optimizer.zero_grad()
    outputs = model(x_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()
    if epoch % 50 == 0:
        print(epoch)
        print(loss.item())
plt.scatter(x_trainData, y_trainData, c="r")
plt.plot(x_train.data.numpy(), outputs.data.numpy())
plt.show()

# predicted = model(x_train.requires_grad()).data.numpy()

torch.save(model.state_dict(), "./Liner.pth")
#model.load_state_dict(torch.load("./Liner.pth"))

2.神经网络的搭建和模型加载，前向传播数据的预测

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

x_trainData = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                    [9.779], [6.182], [7.59], [2.167], [7.042],
                    [10.791], [5.313], [7.997], [3.1]],dtype=np.float32)

class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(in_features=1, out_features=1)

    def forward(self, x):
        out = self.linear(x)
        return out

pre_model= LinearRegression()
pre_model.load_state_dict(torch.load("./Liner.pth"))
y = pre_model.forward(torch.from_numpy(x_trainData))
plt.scatter(x_trainData, y.data.numpy(), color="r")
plt.show()