《PyTorch深度学习实践》-P5线性回归

最新推荐文章于 2024-05-30 16:47:46 发布

m0_60673782

最新推荐文章于 2024-05-30 16:47:46 发布

阅读量391

点赞数

分类专栏：《PyTorch深度学习实践》-b站刘二大人文章标签： pytorch 深度学习线性回归

本文链接：https://blog.csdn.net/m0_60673782/article/details/120873247

版权

构造神经网络一般步骤：

1prepare dataset

2design model using Class (计算y_hat)

3consturct loss and optimizer (using PyTorch API构造损失函数和优化器)

4training cycle (forwward backward update 前馈算损失，后馈算梯度，更新权重）

广播机制：

用mini-batch的方式来做线性回归

第一步

X、Y是3x1的tensor（张量），w是3x1的矩阵（这里可以理解为矩阵）（对应位置相乘，不是矩阵相乘）

第二步

重点目标：构造计算图，让pytorch自动求梯度

仿射模型y_hat=x*w+b，在pytorch中近似为线性单元z=wx+b，要确定w、b的大小需要知道x，y_hat的维度，

loss经过计算最终是一个0维张量，也就是标量，向量没办法backward

linearmodule会自动backward，nn.Linear是一类包含weight 和bias两个Tensor

，它可以自动帮我们完成*w+b这个操作

默认bias=True，有偏置，

self.linear(x),对象后面加括号，实现一个collable可调用的对象，python中常用

举例：

class Foobar():
    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print("Hello"+str(args[0]))

def func(*args,**kwargs):#这两个是python中的可变参数。*args 表示任何多个无名参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict
    print(args)
    print(kwargs)

func(1,2,4,3,x=3,y=5)

foobar=Foobar()
foobar(1,2,3)

输出：

(1, 2, 4, 3)
{'x': 3, 'y': 5}
Hello1

第三步：构造损失函数和优化器

损失函数loss= $\sum$ (y_hat-y)**2, 用MSE,size_average=True 求均值，等于 false不求均值，求不求均值都一样，在nimi-batch中，若某一批样本数较少需要求均值，criterion需要y_hat,y就可以求损失（需要构建计算图，继承自nn.module）,reduce表示要不要降维，一般只考虑size_average

优化器不是module，不会构建计算图，SDG是一个类，实例化SDG，第一个参数para是权重，

lr是学习率，pytorch支持对模型不同部分使用不同学习率

model.parameters （）不管模型多复杂都能找到他们的参数

第四步：训练轮数

一共四步：计算y_hat,loss，backard，更新

weight是矩阵，只需要打印值用item()方法

本节完整代码：

import torch

from matplotlib import pyplot as plt
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[2.0],[4.0],[6.0]])

class LinearModel(torch.nn.Module):#our module class inherit from nn.module(neural network module)
    def __init__(self):#构造函数，初始化
        super().__init__()#继承父类的init方法
        self.linear=torch.nn.Linear(1,1)#Class nn.Linear包含权重和偏置两个tensor

    def forward(self,x):#重写父类中forward函数
        y_pred=self.linear(x)
        return y_pred

model=LinearModel() # creat a instance of linearmodel.model是collable,即可以model（x）

#nn.MSELoss继承自nn.Module
criterion=torch.nn.MSELoss(size_average=False)
#选择优化器，lr是learing rate
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)


for epoch in range(100):
    y_pred=model(x_data) #fforwward:predict 算出y_hat
    loss=criterion(y_pred,y_data)#forward :loss
    print(epoch,loss)

    optimizer.zero_grad()#before backard，梯度归零
    loss.backward()#backward:autograd
    optimizer.step()#用step函数update更新


#output weight and bias
print('w=',model.linear.weight.item())
print('b=',model.linear.bias.item())

#test model
x_test=torch.tensor([4.0])
y_test=model(x_test)
print('y_pred=',y_test.data)

输出：

D:\Anacoda\envs\pytorch-py36\python.exe C:/Users/hp/Desktop/python_work/PyTorch/Lesson1/LinearRegression.py
0 tensor(48.8937, grad_fn=<MseLossBackward>)
D:\Anacoda\envs\pytorch-py36\lib\site-packages\torch\nn\_reduction.py:44: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.
  warnings.warn(warning.format(ret))
1 tensor(21.9066, grad_fn=<MseLossBackward>)
2 tensor(9.8907, grad_fn=<MseLossBackward>)
3 tensor(4.5396, grad_fn=<MseLossBackward>)
4 tensor(2.1555, grad_fn=<MseLossBackward>)
5 tensor(1.0922, grad_fn=<MseLossBackward>)
6 tensor(0.6169, grad_fn=<MseLossBackward>)
7 tensor(0.4035, grad_fn=<MseLossBackward>)
8 tensor(0.3066, grad_fn=<MseLossBackward>)
9 tensor(0.2617, grad_fn=<MseLossBackward>)
10 tensor(0.2399, grad_fn=<MseLossBackward>)
11 tensor(0.2284, grad_fn=<MseLossBackward>)
12 tensor(0.2215, grad_fn=<MseLossBackward>)
13 tensor(0.2167, grad_fn=<MseLossBackward>)
14 tensor(0.2129, grad_fn=<MseLossBackward>)
15 tensor(0.2095, grad_fn=<MseLossBackward>)
16 tensor(0.2064, grad_fn=<MseLossBackward>)
17 tensor(0.2034, grad_fn=<MseLossBackward>)
18 tensor(0.2004, grad_fn=<MseLossBackward>)
19 tensor(0.1975, grad_fn=<MseLossBackward>)
20 tensor(0.1947, grad_fn=<MseLossBackward>)
21 tensor(0.1919, grad_fn=<MseLossBackward>)
22 tensor(0.1891, grad_fn=<MseLossBackward>)
23 tensor(0.1864, grad_fn=<MseLossBackward>)
24 tensor(0.1837, grad_fn=<MseLossBackward>)
25 tensor(0.1811, grad_fn=<MseLossBackward>)
26 tensor(0.1785, grad_fn=<MseLossBackward>)
27 tensor(0.1759, grad_fn=<MseLossBackward>)
28 tensor(0.1734, grad_fn=<MseLossBackward>)
29 tensor(0.1709, grad_fn=<MseLossBackward>)
30 tensor(0.1684, grad_fn=<MseLossBackward>)
31 tensor(0.1660, grad_fn=<MseLossBackward>)
32 tensor(0.1636, grad_fn=<MseLossBackward>)
33 tensor(0.1613, grad_fn=<MseLossBackward>)
34 tensor(0.1590, grad_fn=<MseLossBackward>)
35 tensor(0.1567, grad_fn=<MseLossBackward>)
36 tensor(0.1544, grad_fn=<MseLossBackward>)
37 tensor(0.1522, grad_fn=<MseLossBackward>)
38 tensor(0.1500, grad_fn=<MseLossBackward>)
39 tensor(0.1479, grad_fn=<MseLossBackward>)
40 tensor(0.1457, grad_fn=<MseLossBackward>)
41 tensor(0.1436, grad_fn=<MseLossBackward>)
42 tensor(0.1416, grad_fn=<MseLossBackward>)
43 tensor(0.1395, grad_fn=<MseLossBackward>)
44 tensor(0.1375, grad_fn=<MseLossBackward>)
45 tensor(0.1356, grad_fn=<MseLossBackward>)
46 tensor(0.1336, grad_fn=<MseLossBackward>)
47 tensor(0.1317, grad_fn=<MseLossBackward>)
48 tensor(0.1298, grad_fn=<MseLossBackward>)
49 tensor(0.1279, grad_fn=<MseLossBackward>)
50 tensor(0.1261, grad_fn=<MseLossBackward>)
51 tensor(0.1243, grad_fn=<MseLossBackward>)
52 tensor(0.1225, grad_fn=<MseLossBackward>)
53 tensor(0.1207, grad_fn=<MseLossBackward>)
54 tensor(0.1190, grad_fn=<MseLossBackward>)
55 tensor(0.1173, grad_fn=<MseLossBackward>)
56 tensor(0.1156, grad_fn=<MseLossBackward>)
57 tensor(0.1139, grad_fn=<MseLossBackward>)
58 tensor(0.1123, grad_fn=<MseLossBackward>)
59 tensor(0.1107, grad_fn=<MseLossBackward>)
60 tensor(0.1091, grad_fn=<MseLossBackward>)
61 tensor(0.1075, grad_fn=<MseLossBackward>)
62 tensor(0.1060, grad_fn=<MseLossBackward>)
63 tensor(0.1045, grad_fn=<MseLossBackward>)
64 tensor(0.1030, grad_fn=<MseLossBackward>)
65 tensor(0.1015, grad_fn=<MseLossBackward>)
66 tensor(0.1000, grad_fn=<MseLossBackward>)
67 tensor(0.0986, grad_fn=<MseLossBackward>)
68 tensor(0.0972, grad_fn=<MseLossBackward>)
69 tensor(0.0958, grad_fn=<MseLossBackward>)
70 tensor(0.0944, grad_fn=<MseLossBackward>)
71 tensor(0.0930, grad_fn=<MseLossBackward>)
72 tensor(0.0917, grad_fn=<MseLossBackward>)
73 tensor(0.0904, grad_fn=<MseLossBackward>)
74 tensor(0.0891, grad_fn=<MseLossBackward>)
75 tensor(0.0878, grad_fn=<MseLossBackward>)
76 tensor(0.0865, grad_fn=<MseLossBackward>)
77 tensor(0.0853, grad_fn=<MseLossBackward>)
78 tensor(0.0841, grad_fn=<MseLossBackward>)
79 tensor(0.0829, grad_fn=<MseLossBackward>)
80 tensor(0.0817, grad_fn=<MseLossBackward>)
81 tensor(0.0805, grad_fn=<MseLossBackward>)
82 tensor(0.0793, grad_fn=<MseLossBackward>)
83 tensor(0.0782, grad_fn=<MseLossBackward>)
84 tensor(0.0771, grad_fn=<MseLossBackward>)
85 tensor(0.0760, grad_fn=<MseLossBackward>)
86 tensor(0.0749, grad_fn=<MseLossBackward>)
87 tensor(0.0738, grad_fn=<MseLossBackward>)
88 tensor(0.0727, grad_fn=<MseLossBackward>)
89 tensor(0.0717, grad_fn=<MseLossBackward>)
90 tensor(0.0707, grad_fn=<MseLossBackward>)
91 tensor(0.0697, grad_fn=<MseLossBackward>)
92 tensor(0.0686, grad_fn=<MseLossBackward>)
93 tensor(0.0677, grad_fn=<MseLossBackward>)
94 tensor(0.0667, grad_fn=<MseLossBackward>)
95 tensor(0.0657, grad_fn=<MseLossBackward>)
96 tensor(0.0648, grad_fn=<MseLossBackward>)
97 tensor(0.0639, grad_fn=<MseLossBackward>)
98 tensor(0.0629, grad_fn=<MseLossBackward>)
99 tensor(0.0620, grad_fn=<MseLossBackward>)
w= 1.834191083908081
b= 0.3769226372241974
y_pred= tensor([7.7137])

Process finished with exit code 0

迭代100次结果不是很理想，迭代1000词之后的结果：

D:\Anacoda\envs\pytorch-py36\python.exe C:/Users/hp/Desktop/python_work/PyTorch/Lesson1/LinearRegression.py
D:\Anacoda\envs\pytorch-py36\lib\site-packages\torch\nn\_reduction.py:44: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.
  warnings.warn(warning.format(ret))
0 tensor(111.9742, grad_fn=<MseLossBackward>)
1 tensor(49.9149, grad_fn=<MseLossBackward>)
2 tensor(22.2869, grad_fn=<MseLossBackward>)
3 tensor(9.9867, grad_fn=<MseLossBackward>)
4 tensor(4.5101, grad_fn=<MseLossBackward>)
5 tensor(2.0711, grad_fn=<MseLossBackward>)
6 tensor(0.9845, grad_fn=<MseLossBackward>)
7 tensor(0.4998, grad_fn=<MseLossBackward>)
8 tensor(0.2832, grad_fn=<MseLossBackward>)
9 tensor(0.1859, grad_fn=<MseLossBackward>)
10 tensor(0.1417, grad_fn=<MseLossBackward>)
11 tensor(0.1212, grad_fn=<MseLossBackward>)
12 tensor(0.1112, grad_fn=<MseLossBackward>)
13 tensor(0.1060, grad_fn=<MseLossBackward>)
14 tensor(0.1028, grad_fn=<MseLossBackward>)
15 tensor(0.1006, grad_fn=<MseLossBackward>)
16 tensor(0.0988, grad_fn=<MseLossBackward>)
17 tensor(0.0973, grad_fn=<MseLossBackward>)
18 tensor(0.0958, grad_fn=<MseLossBackward>)
19 tensor(0.0944, grad_fn=<MseLossBackward>)
20 tensor(0.0930, grad_fn=<MseLossBackward>)
21 tensor(0.0917, grad_fn=<MseLossBackward>)
22 tensor(0.0904, grad_fn=<MseLossBackward>)
23 tensor(0.0891, grad_fn=<MseLossBackward>)
24 tensor(0.0878, grad_fn=<MseLossBackward>)
25 tensor(0.0865, grad_fn=<MseLossBackward>)
26 tensor(0.0853, grad_fn=<MseLossBackward>)
27 tensor(0.0841, grad_fn=<MseLossBackward>)
28 tensor(0.0828, grad_fn=<MseLossBackward>)
29 tensor(0.0817, grad_fn=<MseLossBackward>)
30 tensor(0.0805, grad_fn=<MseLossBackward

最低0.47元/天解锁文章

m0_60673782

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
《PyTorch深度学习实践》-P5线性回归

1prepare dataset2design model using Class (计算y_hat)3consturct loss and optimizer using PyTorch API构造损失函数和优化器4training cycle (forwward backward update 前馈算损失，后馈算梯度，更新权重）广播机制：用mini-batch的方式来做线性回归第一步X、Y是3x1的tensor（张量），w是3x1的矩阵（这里可以理解为矩阵）（对应位置..
复制链接

扫一扫