softmax回归原理及从零开始实现+简洁实现

softmax回归原理

softmax回归是一个分类问题。

回归和分类的区别：回归估计一个连续值，分类预测一个离散类别。

softmax思想：希望正确的类执行度远远大于其他类（关心相对值）

softmax保证输出是概率

 

 衡量的损失函数：交叉熵损失

 

    

应用场景例如：

(1)数字识别

（2）图像分类

（3）判断软件类型

（4）对文字分类，评论情感类别

等等

总结

softmax回归是一个多类分类模型

使用softmax回归得到每个类的预测置信度

使用交叉熵来衡量预测和标号的区别

 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)

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

num_inputs=784
num_outputs=10

W=torch.normal(0,0.01,size=(num_inputs,num_outputs),requires_grad=True)#定义权重，正态分布均值为0方差为0.01，需要计算梯度
b=torch.zeros(num_outputs,requires_grad=True)# 需要计算梯度

实现softmax

def softmax(X):
    x_exp=torch.exp(X)  #对每个元素做指数计算
    partition=x_exp.sum(1,keepdim=True)  #按照行求和，keepdim=True保持还是二维矩阵
    return x_exp/partition

 验证函数softmax，把每个元素变成了一个非负数，并且根据概率原理，每行总和为1

x=torch.normal(0,1,(2,5))
x_prob=softmax(x)  #维度不变，非负
x_prob,x_prob.sum(1)  #每一行总和为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=torch.tensor([0,2])
y_hat=torch.tensor([[0.1,0.3,0.6],[0.3,0.2,0.5]])
y_hat[[0,1],y]  #表示输出第1个样本的第一个类别的概率，第2个样本第三个类别的概率

实现交叉熵损失函数

def cross_entropy(y_hat,y):  #给定y_hat和真实标号y
    return -torch.log(y_hat[range(len(y_hat)),y])  #y_hat[range(len(y_hat)),y]每一个样本对应的y真实标号的预测概率，（1个正类标号1，其余0）
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是多维且列数大于1
        y_hat=y_hat.argmax(axis=1)    #当y_hat是2维，取每一行元素值最大的下标存到y_hat作为预测分类的类别
    cmp=y_hat.type(y.dtype)==y      #将y_hat转为与y相同的类型，比较，相等为1，否则为0
    return float(cmp.type(y.dtype).sum())   #预测正确的样本数
accuracy(y_hat,y)/len(y)   #预测正确的样本数/y的长度 =预测正确的概率

可以评估任意模型net的准确率

def evaluate_accuracy(net,data_iter):
    """计算在指定数据集上模型的精度"""
    if isinstance(net,torch.nn.Module):
        net.eval() #设置成评估模式，不用计算梯度
    metric=Accumulator(2) #正确的预测数，预测总数
    for X,y in data_iter:
        metric.add(accuracy(net(X),y),y.numel())  #accuracy(net(x),y)预测争取的样本数，y.numel()样本总数
    return metric[0]/metric[1] #分类正确的/总样本数

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]

evaluate_accuracy(net, test_iter)

Softmax回归训练

def train_epoch_ch3(net,train_iter,loss,update):
    if isinstance(net,torch.nn.Module):  #如果使用torch.nn.Module模块
        net.train() #开始训练模式，计算梯度
    metric=Accumulator(3)
    for X,y in train_iter:  #扫一遍数据
        y_hat=net(X)
        l=loss(y_hat,y) #交叉熵损失函数
        if isinstance(updater,torch.optim.Optimizer):
            updater.zero_grad() #先把梯度设置成0
            l.backward()
            updater.step()
            metric.add(
            float(l)*len(y),accuracy(y_hat,y),y.numel()
            )
        else:  #如果自己实现
            l.sum().backward()  #l是向量，进行求和
            updater(X.shape[0])
            metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
        return metric[0]/metric[2],metric[1]/metric[2]
              #loss累加/样本数，预测正确的/样本数
            

class Animator:  #@save
    """在动画中绘制数据"""
    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):  #@save
    """训练模型"""
    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
   

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

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):  #@save
    """预测标签"""
    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])

predict_ch3(net, test_iter)

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))  #nn.Flatten()将任何维度的tensor展开为2维度

def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal(m.weight,std=0.01) #weight初始化为均值为0（默认）方差为0.01
net.apply(init_weights); #net每一层跑一下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)