Pytorch深度学习入门（笔记）_pytorch学习笔记

1.线性模型

 1.方差与平均方差

这是方差（损失）

这是平均损失（MSE）这个值越小，拟合性越好

2.代码实现

算法：穷举法 求线性模型的权重，从0试到4.0，步长0.1，要使用np.arange( ,  , )函数

代码实现：一般训练过程中，横轴是一个训练轮数而不是权重。

import matplotlib.pyplot as plt
import numpy as np
 
x_data=[1,2,3]
y_data=[2,4,6]
def predict(x):   #预测y值
    return x*w
def loss(x,y):
    y_predict=predict(x)  #计算损失
    return (y_predict-y)*(y_predict-y)
w_list=[]         #权重列表
mse_list=[]       #平均损失列表
for w in np.arange(0.0,4.1,0.1):
    print("w=",w)
    loss_sum=0
    for x_val,y_val in zip(x_data,y_data):
        y_pre=predict(x_val)
        loss_val=loss(x_val,y_val)
        loss_sum+=loss_val
        print('\t',x_val,y_val,y_pre,loss_val)
    MSE=loss_sum/3
    print("MSE=",MSE)
    w_list.append(w)
    mse_list.append(MSE)
plt.plot(w_list,mse_list)   #绘制图像
plt.xlabel("MSE")
plt.ylabel("loss")
plt.show()                  #展示图象

结果：

作业:利用y=a*w+b模型，画出三维图像

import matplotlib.pyplot as plt
import numpy as np
 
from matplotlib import cm
 
x_data=[1,2,3]
y_data=[3,5,7]
def predict(x):
    return (x*w)+b
def loss(x,y):
    y_predict=predict(x)
    return (y_predict-y)*(y_predict-y)
w_list=[]
mse_list=[]
b_list=[]
for w in np.arange(0.0,4.1,0.1):
    print("w=",w)
    for b in np.arange(-2.0,2.1,0.1): 
        print("b=",b)
        loss_sum=0          #这里loss_sum要先归零，后归零会影响初次循环的数据
        for x_val,y_val in zip(x_data,y_data):
            y_pre=predict(x_val)
            loss_val=loss(x_val,y_val)
            loss_sum+=loss_val
            print('\t',x_val,y_val,y_pre,loss_val)
        MSE=loss_sum/3
        print("MSE=",MSE)
        b_list.append(b)
        mse_list.append(MSE)
        w_list.append(w)
        #loss_sum=0
#X,Y=np.meshgrid(w_list,b_list)
fig = plt.figure (figsize= (12,6))
ax1 = plt.axes(projection="3d")
ax1.plot_trisurf(w_list,b_list,mse_list,cmap='rainbow')
plt.show()

2.梯度下降算法

 1.优化问题

优化问题就是要求1个函数的最小值问题。当参数数量较小的时候还可以用分支方法解决（只访问某些在最小值附近的点，在一步步逼近最小值。）但由于目标函数不一定是凸函数以及参数可能非常多，因此分支的方法也不一定可行。

2.梯度下降算法-核心公式

梯度 gradiant=(cost即为y轴坐标,在这里是loss的均值)指向函数上升的方向（导数为正时，x轴正向为上升，导数为负时，x轴反向为上升）

核心公式：（对倒数取相反数，指向函数下降的方向，以期得到最小值）

其中a为学习率，不能太高，否则导致不收敛。不收敛时loss-epoch函数存在极小值点，此时训练失败了。

这一算法是一种贪心算法，不一定能得到真正的最小值（如果函数不是凸函数的话）只能找到局部最优点（也可能是鞍点，鞍点使模型几乎无法继续迭代，导数接近零）。

3.随机梯度下降算法

由于梯度下降算法的w值是由整个数据集得出，容易导致在鞍点时无法继续迭代，因此大多数时间改用随机梯度下降算法，以期望在鞍点时，用数据集中单个数据所含的随机噪声推动w去迭代。也就是直接用loss去对w求导。使用该算法时，随着梯度减小，w所移动的步长随之减小。

在这里,其中

随机梯度下降算法比梯度下降具有更好的性能，更有机会是目标收敛，但时间复杂度较梯度下降更大。 

4.代码实现

import matplotlib.pyplot as plt
import numpy as np
 
x_data=[1.0,2.0,3.0]
y_data=[2.2,4.1,5.9]
w=1.0
def forward(x):
    return x*w
def loss(x,y):                        #损失函数
    y_pre=forward(x)
    return (y_pre-y)**2
def gradient(x,y):                    #计算梯度，即对损失函数求导
    return 2*x*(x*w-y)
epoch_list=[]
loss_list=[]
print("Trainning Start\n")
for epoch in range(100):               
    for x_val,y_val in zip(x_data,y_data):
        grad=gradient(x_val,y_val)
        w-=0.01*grad                  #对权重进行迭代，其中训练率为0.01
        print("\tX=",x_val,"Y=",y_val,"grad=",grad)
        loss_val=loss(x_val,y_val)    
    epoch_list.append(epoch)
    loss_list.append(loss_val)        #去第三次的loss作为代表
    print("epoch=",epoch,"w=",w,"loss=",loss)
print("Trainning Finish\n")
plt.plot(epoch_list,loss_list)   #绘制图像
plt.xlabel("epoch")
plt.ylabel("loss")
plt.show()