PYTORCH 学习之路

环境搭建

Windows 端

有了 anaconda 使得我们的环境搭建变得十分简单，有两种方案，一种是使用 conda 的方式创建一个专门给 pytorch 的库，还可以直接在 pip 下全局安装 pytorch 。我使用的第二种，因为使用第一种每次要想使用 pytorch 的话还得重新使用 activate 的方式进入 pytorch。

跟着李沐大大的安装配置指南，光速完成

线性模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import numpy as np
import matplotlib.pyplot as plt
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def forward(x):
    return x*w
#线性关系

def loss(x, y):
#损失函数
    y_pred = forward(x)
    return (y_pred - y) * (y_pred - y)

w_list = []
mse_list = []

#遍历找w
for w in np.arange(0.0, 4.1, 0.1):
    print('w=', w)
    l_sum=0
    for x_val,y_val in zip(x_data,y_data):
        y_pred_val = forward(x_val)
        loss_val = loss(x_val,y_val)
        l_sum+=loss_val
        print('\t',x_val,y_val,y_pred_val,loss_val)
    print('MSE=',l_sum/3)
    w_list.append(w)
    mse_list.append(l_sum/3)

plt.plot(w_list,mse_list)
plt.ylabel('loss')
plt.xlabel('w')
plt.show()

这是一个十分简单的数学模型，参数 b 甚至考虑，当然可以加上，但是算出来肯定也是 0。

梯度下降算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import numpy as np
import matplotlib.pyplot as plt
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w=1.0
def forward(x):
    return x*w
#线性关系

def cost(xs, ys):
    cost=0
    for x,y in zip(xs,ys):
        y_pred = forward(x)
        cost+=(y_pred - y) ** 2
        return cost/len(xs)

def gradient(xs, ys):
    grad=0
    for x,y in zip(xs,ys):
        grad+=2*x*(x*w-y)
        return grad/len(xs)
epoch_list = []
cost_list = []
print('Predict(before traning)',4,forward(4))
#遍历找w
for epoch in range(500):
   cost_val=cost(x_data,y_data)
   grad_val=gradient(x_data,y_data)
   w-=0.01*grad_val
   print('Eopch:',epoch,'w=',w,'cost=',cost_val)
   epoch_list.append(epoch)
   cost_list.append(cost_val)
print('Predict(after traning)',4,forward(4))

plt.plot(epoch_list,cost_list)
plt.ylabel('cost_val')
plt.xlabel('epoch')
plt.show()

梯度下降算法，取了个均值平均损失，但是其实挺菜的，如果存在鞍点的话，这种下降方式所算的导数就为 0 了， w 无法迭代更新。这时候随机梯度下降就出现了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import numpy as np
import matplotlib.pyplot as plt
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w=1.0
def forward(x):
    return x*w
#线性关系

def loss(xs, ys):
    y_pred = forward(x)
    return (y_pred - y) ** 2

def gradient(xs, ys):
    return 2* x * (x * w - y)

epoch_list = []
loss_list = []
print('Predict(before traning)',4,forward(4))
#遍历找w
for epoch in range(50):
    for x, y in zip(x_data, y_data):
        grad=gradient(x,y)
        w-=0.01*grad
        print('\tgrad:',x,y,grad)
        l=loss(x,y)
        epoch_list.append(epoch)
        loss_list.append(l)
    print('progress:',epoch,'w=',w,'loss=',l)

print('Predict(after traning)',4,forward(4))

plt.plot(epoch_list,loss_list)
plt.ylabel('loss_list')
plt.xlabel('epoch')
plt.show()

这个迭代速度超级快，而且极其不平滑。这个算法优点就是能够通过部分噪点的小影响来度过一个鞍点。

反向传播

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import torch
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w=torch.Tensor([1.0])
w.requires_grad=True

def forward(x):
    return x*w
#线性关系

def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) ** 2

epoch_list = []
cost_list = []
print('Predict(before traning)',4,forward(4).item())
#遍历找w
for epoch in range(500):
    for x, y in zip(x_data, y_data):
        l=loss(x,y)
        l.backward()
        print('\tgrad:',x,y,w.grad.item())
        w.data=w.data-0.01*w.grad.data
        w.grad.data.zero_()
    print('progress:',epoch,l.item())
print('Predict(after traning)',4,forward(4).item())