pytorch学习篇（一）：线性回归模型练习与解析

这边拿了两个大佬的课程作为学习

1. 莫烦老师课程线性回归

我对函数做了点修改生成了一个三次函数，代码如下：

import torch
import torch.nn
from torch.autograd import Variable
import matplotlib.pyplot as plt
import torch.nn.functional as Fun

def make_fake_data():
    pass

class Net(torch.nn.Module):
    def __init__(self,num_feature,num_hidden,num_output):
        super(Net,self).__init__()
        self.hidden = torch.nn.Linear(num_feature,num_hidden)       #初始化建立两个层次
        self.midhidTwoMul = torch.nn.Linear(num_hidden, num_hidden*2)   #一个输入由少到多的网络
        self.midhidTwoDiv = torch.nn.Linear(num_hidden*2, num_hidden)   #一个 有多到少的
        self.predict = torch.nn.Linear(num_hidden,num_output)
    def forward(self,x):                                            #每次前向传播所经过的网络
        x = self.hidden(x)
        x = Fun.relu(self.midhidTwoMul(x))
        x = Fun.relu(self.midhidTwoDiv(x))
        x = self.predict(x)
        return x

#构建数据 一个三次函数
ten_x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
ten_y = 1.5*ten_x.pow(3) + 0.7*ten_x.pow(2) + 0.15 * torch.rand(ten_x.size())

var_x, var_y = Variable(ten_x), Variable(ten_y)         #我使用的pytorch1.5 tensor 和 Variable已经是一个概念了，知道一下就好
plt.scatter(var_x.data.numpy(), var_y.data.numpy())
#plt.show()

print(var_x.shape)
plt.ion()           #使用中断模式显示才不会卡
#plt.show()

#初始化网络
net = Net(1,20,1)
optimizer = torch.optim.SGD(net.parameters(),lr=0.005)
loss_func = torch.nn.MSELoss()

for step in range(200):
    prediction = net(var_x)                 #首先使用网络预测
    loss = loss_func(prediction,var_y)      #
    loss.backward()
    optimizer.step()
    plt.cla()
    plt.ylim(-1, 2.5)
    #plt.scatter(var_x.data.numpy(),var_y.data.numpy())    #这个是散点式的
    plt.plot(var_x.data.numpy(),var_y.data.numpy(),'b-')    #这个是实线图
    plt.plot(var_x.data.numpy(),prediction.data.numpy(),'r-',lw=3)      #r表示红色 - 表示实线  lw = linewide
    plt.text(-1,0,'L=%0.4f'%loss.item(),fontdict={'size':'10','color':'red'})   #图片中的loss值的标语
    plt.pause(0.1)

plt.ioff()
plt.show()

我使用了一个加了噪声的三次函数，作为训练数据集输入得到的结果如下：

2. 咕泡学院的一次函数线性回归

这里demo，没有用plt作为打印没那么直观只是简单的检查了一下loss值

import torch.nn as nn
import torch

class MyLinnerClass(nn.Module):
    def __init__(self,inputDim,outputDim):
        super(MyLinnerClass,self).__init__()
        self.linearOne=nn.Linear(inputDim,outputDim)

    def forward(self,x):
        outVal = self.linearOne(x)
        return outVal

def dataSetCreate(PointNumer=500,div=0.2):
    x = torch.arange(0, PointNumer*div, div)
    print(x.shape)
    x = torch.unsqueeze(x,dim=1)
    print(x.shape)
    noise = (torch.randn(PointNumer)) % 15 / 10
    notCurY = 1.2 * x + noise         #在这里其实是不标准的y，故意产生一个有误差的标签
    lableY = 1.2 * x
    return x, notCurY, lableY


def main():
    x, notCurY, lableY = dataSetCreate(500,0.2)
    model=MyLinnerClass(1,1)
    epochs=10000
    learningRate = 0.002
    optimiser = torch.optim.Adam(model.parameters(),lr=learningRate)      #优化函数
    certerion = nn.MSELoss()            #loss值

    for oneEpoch in range(epochs):
        oneEpoch += 1
        optimiser.zero_grad()
        train_outY = model(x)
        #loss = certerion(train_outY,lableY)
        loss = certerion(train_outY,notCurY)    #当标签使用的第二个非准确的 loss会有波动
        loss.backward()
        optimiser.step()
        if(oneEpoch%50==0):
            print("loss is :",loss.item())

# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    main()

这里有一个unsqueeze是和课程不一样的。我没有用array来构造数据，用了tensor的random构造，但是因为model的linear的处理维度原因做了点修改。

这里的dataset都是用的数据集，没有使用上dataloader

步骤总结

.好了，来总结下pytorch模型训练的基本步骤

训练套路

1. 准备数据集，数据集得有输入量 和 标签量 （ 输入量是图片等等，标签是图片对应的名称或者其他）
2. 搭建model 这个一般是自己建一个class 里面调用torch.nn.module的子类模型
3. 确定 optimizer 和 loss的计算方法
4. for循环，不断的把数据集的给模型，然后方向传播，然后是optimizer优化

迭代中的意思

以第二个模型为例，这几个步骤是训练的主体。

optimiser.zero_grad()	       	#梯度归零，这个是因为torch的梯度是默认会累加，不归零的话grad会越来越大
train_outY = model(x)						#把数据放入，x也可以是图片，音视频
loss = certerion(train_outY,notCurY)		 #计算loss值 certerion是前面就定义的
loss.backward()				        #由loss来更新网络中的参数，但是只是求出了loss没有更新梯度
optimiser.step()					#基于学习率和计算的loss值来更新model的pra