这边拿了两个大佬的课程作为学习
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模型训练的基本步骤
训练套路
- 准备数据集,数据集得有输入量 和 标签量 ( 输入量是图片等等,标签是图片对应的名称或者其他)
- 搭建model 这个一般是自己建一个class 里面调用torch.nn.module的子类模型
- 确定 optimizer 和 loss的计算方法
- 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