动手学深度学习Pytorch---线性神经网络

【1】线性神经网络

1.1 softmax回归—分类问题

1）回归 vs 分类
回归估计一个连续值 分类预测一个离散类别
回归：1.单连续数值输出；2.自然区间R；3.跟真实的区别作为损失。
分类：1.通常多个输出；2.输出i是预测为第i类的置信度。

2）从回归到多类分类
----------均方损失、无校验比例

1. 对类别进行一位有效编码 y=$[$y_1$，$y_2$，...，$y_n${]}^T$
   $$y_i=\{\begin{array}{ll}1& \text{ if }i=y\\ 0& \text{ if }otherwises\end{array}$$
2. 使用均方损失训练
3. 最大值作为预测 $$y=\underset{i}{\mathrm{argmax}}{o}_i$$
4. 需要更置信的识别正确类（大余量）$$o_y-o_i\ge △(y,i)$$
   ----------校验比例
5. 输出匹配概率（非负，和为1）----$$y=softmax(o)$$
6. 概率y和$y$的区别作为损失。

3）softmax和交叉熵损失 ？？？

1. 交叉熵常用来衡量两个概率的区别$$H(p,q)=\sum _i-p_{i}log(q_i)$$
2. 将它作为损失$$l(y,y)=-\sum _i{y}_{i}log(y_i)=-log(y_y)$$
3. 其梯度是真实概率和预测概率的区别$${\partial }_{o_i}l(y,y)=softmax(o{)}_i-y_i$$

4）总结

1. softmax回归是一个多类分类模型。
2. 使用softmax操作子得到每个类的预测置信度。
3. 使用交叉熵来衡量预测和标号的区别。

1.2 损失函数

1）均方损失（L2 Loss）

1. 定义：$$l(y,y^{\prime })=\frac{1}{2}(y-y^{\prime }{)}^2$$

2）绝对值损失函数（L1 Loss）

1. 定义：$$l(y,y^{\prime })=|y-y^{\prime }|$$

3）Huber’s Robust Loss

1.3 图片分类数据集

将使用与MNIST数据集类似但更复杂的Fashion-MNIST数据集

#读取多类分类数据集

import matplotlib.pyplot as plt
import torch
import torchvision
from torch.utils import data
from torchvision import transforms  #对数据进行操作的模组
from d2l import torch as d2l

d2l.use_svg_display()  #用svg显示图片，清晰度高一点

#####通过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中
#通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式(将图片转成Tensor)
#并除以255使得所有像素的数值均在0到1之间
trans=transforms.ToTensor()
#transform=trans:需要得到的是pytorch的tensor,而不是一堆图片
mnist_train=torchvision.datasets.FashionMNIST(root="../Fashiondata",train=True,transform=trans,download=False)
mnist_test=torchvision.datasets.FashionMNIST(root="../Fashiondata",train=False,transform=trans,download=False)

#print(len(mnist_train),len(mnist_test))
#print(mnist_train[0][0].shape)

#####两个可视化数据集的函数
def get_fashion_mnist_labels(labels):
    '''返回Fashion-MNIST数据集的文本标签。'''
    text_labels=['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt',
        'sneaker', 'bag', 'ankle boot']
    return[text_labels[int(i)] for i in labels]

def show_images(imgs,num_rows,num_cols,titles=None,scale=1.5):
    """Plot a list of images."""
    figsize=(num_cols*scale,num_rows*scale)
    _,axes=d2l.plt.subplots(num_rows,num_cols,figsize=figsize)
    axes=axes.flatten()
    for i,(ax,img) in enumerate(zip(axes,imgs)):
        if(torch.is_tensor(img)):
            #图片张量
            ax.imshow(img.numpy())
        else:
            #PIL图片
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

#几个样本的图像及其相应的标签
#X,y=next(iter(data.DataLoader(mnist_train,batch_size=18)))#next是拿到第一个小批量
#show_images(X.reshape(18,28,28),2,9,titles=get_fashion_mnist_labels(y))
#d2l.plt.show()

#####读取一小批量数据，大小为batch_size
batch_size=256

def get_dataloader_workers():
    '''使用4个进程来读取的数据。'''
    return 1

train_iter=data.DataLoader(mnist_train,batch_size,shuffle=True,num_workers=get_dataloader_workers())
timer=d2l.Timer()
#for X,y in train_iter:
#    continue
#print(f'{timer.stop():.2f} sec')

1.4 softmax回归的从零开始实现

import torch
from IPython import display
from d2l import torch as d2l

batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size)#取出训练数据和测试数据到相应迭代器中

将展平每个图像，将它们视为长度为784的向量。因为我们的数据集有10个类别，所以网络输出维度为10。

num_inputs=784  #784=28*28
num_outputs=10

W=torch.normal(0,0.01,size=(num_inputs,num_outputs),requires_grad=True)
b=torch.zeros(num_outputs,requires_grad=True)

实现softmax

def softmax(X):
    X_exp=torch.exp(X)
    partition=X_exp.sum(1,keepdim=True)
    return X_exp/partition   #这里应用了广播机制

我们将每个元素变成一个非负数。此外，依据概率原理，每行总和为1。（验证）

X=torch.normal(0,1,(2,5))
X_prob=softmax(X)
print(X_prob,X_prob.sum(1))

实现softmax模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1,W.shape[0])),W)+b)

创建一个数据y_hat，其中包含2个样本在3个类别的预测概率，使用y作为y_hat中概率的索引。
—根据y中的标号拿出y_hat中对应的值

y=torch.tensor([0,2])
y_hat=torch.tensor([[0.1,0.3,0.6],[0.3,0.2,0.5]])
print(y_hat[[0,1],y])

实现交叉熵损失L=−[ylog y^+(1−y)log (1−y^)]

def cross_entropy(y_hat,y):
    return -torch.log(y_hat[range(len(y_hat)),y])
print(cross_entropy(y_hat,y))

#将预测类别与真实y元素进行比较

def accuracy(y_hat,y):
    '''计算预测正确的数量。'''
    if len(y_hat.shape)>1 and y_hat.shape[1]>1:
       y_hat=y_hat.argmax(axis=1)   #argmax：最大数的索引
    cmp=y_hat.type(y.dtype)==y
    return float(cmp.type(y.dtype).sum()) #预测正确的多有样本数

print(accuracy(y_hat,y)/len(y)) 

#Accumulator实例中创建了2个变量，用于分别存储正确预测的数量和预测的总数量。

class Accumulator:  #---累加器
    '''在n个变量上累加。'''
    def __init__(self,n):
        self.data=[0.0]*n
    
    def add(self,*args):
        self.data=[a+float(b) for a,b in zip(self.data,args)]
    
    def reset(self):
        self.data=[0.0]*len(self.data)

    def __getitem__(self,idx):
        return self.data[idx]

#我们可以评估在任意模型net的准确率

def evaluate_accuracy(net,data_iter):
    '''计算在指定数据集上模型的精度'''
    if isinstance(net,torch.nn.Module):   #isinstance：来判断⼀个对象是否是⼀个已知的类型。
        net.eval()  #将模型设置为评估模式
    metric=Accumulator(2)
    for X,y in data_iter:
        metric.add(accuracy(net(X),y),y.numel())
    return metric[0]/metric[1]  #metric[0]：分类正确的样本数。metric[1]：总样本数。

print(evaluate_accuracy(net,test_iter))

#softmax回归的训练（手动的和nn模具都可用）

def train_epoch_ch3(net,train_iter,loss,updater):
    """训练模型一个迭代周期（定义见第3章）。"""
    # 如果是nn模具 将模型设置为训练模式
    if isinstance(net,torch.nn.Module):
        net.train()
    metric=Accumulator(3) #长度为3的一个迭代器来累加。3：# 训练损失总和、训练准确度总和、样本数
    for X,y in train_iter:

        y_hat=net(X)   #求出预测值
        l=loss(y_hat,y) #求出损失
        if isinstance(updater,torch.optim.Optimizer): # 使用PyTorch内置的优化器和损失函数
           updater.zero_grad()  #梯度设为0
           l.backward()  #计算梯度
           updater.step()  #对参数进行自更新
           metric.add(float(l)*len(y),accuracy(y_hat,y),y.size().numel())  
        else: #下面是自己实现时，即使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
            metric.add(float(l.sum()),accuracy(y_hat,y),y.numel())
    return metric[0]/metric[2],metric[1]/metric[2]

#定义一个在动画中绘制数据的实用程序类

class Animator:
    """在动画中绘制数据。"""
    def __init__(self,xlabel=None,ylabel=None,legend=None,xlim=None,
                 ylim=None,xscale='linear',yscale='linear',
                 fmts=('-','m--','g-.','r:'),nrows=1,ncols=1,figsize=(3.5,2.5)):
        # 增量地绘制多条线
        if legend is None:
            legend=[]
        d2l.use_svg_display()
        self.fig,self.axes=d2l.plt.subplots(nrows,ncols,figsize=figsize)
        if nrows*ncols==1:
            self.axes=[self.axes,]
        # 使用lambda函数捕获参数
        self.config_axes = lambda: d2l.set_axes(self.axes[
            0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表中添加多个数据点
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

#训练函数

def train_ch3(net,train_iter,test_iter,loss,num_epochs,updater):
    animator=Animator(xlabel='epoch',xlim=[1,num_epochs],ylim=[0.3,0.9],
                      legend=['train loss', 'train acc', 'test acc']) #可视化动画
    for epoch in range(num_epochs):
        train_metrics=train_epoch_ch3(net,train_iter,loss,updater)
        test_acc=evaluate_accuracy(net,test_iter) #在测试数据集上面评估精度
        animator.add(epoch+1,train_metrics+(test_acc,))
    train_loss,train_acc=train_metrics
    assert train_loss <0.5,train_loss
    assert train_acc <=1 and train_acc >0.7,train_acc
    assert test_acc <=1 and test_acc >0.7 ,test_acc

#小批量随机梯度下降来优化模型的损失函数

lr=0.1
def updater(batch_size):
    return d2l.sgd([W,b],lr,batch_size)

#训练模型10个迭代周期

num_epochs=10
train_ch3(net,train_iter,test_iter,cross_entropy,num_epochs,updater)

#对图像进行分类预测

def predict_ch3(net,test_iter,n=6):
    '''预测标签'''
    for X,y in test_iter:
        break
    trues=d2l.get_fashion_mnist_labels(y)
    preds=d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles=[true+'\n'+pred for true,pred in zip(trues,preds)]
    d2l.show_images(X[0:n].reshape((n,28,28)),1,n,titles=titles[0:n])
    d2l.plt.show()
predict_ch3(net,test_iter)

1.5 softmax回归的简洁实现

通过深度学习框架的高级API能够使实现softmax回归变得更加容易

import torch
from torch import nn
from d2l import torch as d2l

batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size)

#softmax回归的输出层是一个全连接层
#pytorch不会隐式地调整输入的形状。
#因此，我们定义了展平层(flatten)在线性层前调整网络的输入形状
net=nn.Sequential(nn.Flatten(),nn.Linear(784,10))

def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight,std=0.01)

net.apply(init_weights)
#在交叉熵损失函数中传递未归一化的预测，并同时计算softmax及其对数
loss=nn.CrossEntropyLoss()

#使用学习率为0.1的小批量随机梯度下降作为优化算法
trainer=torch.optim.SGD(net.parameters(),lr=0.1)
num_epochs=10
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,trainer)