一、softmax的理论部分

1、softmax提出的原因

利用回归模型来做分类问题的时候，虽然可以将预测值就近定点化到固定离散值之一（类别），但这种连续值到离散值的转化会影响分类的效果。因此提出softmax作为最后部分的概率输出，将输出的值控制在0到1之间，代表属于每个类别的概率。

2、softmax公式

$Y=XW+B$

$X\in R_{n*d},W\in R_{d*c},B\in R_{c*1},Y\in R_{n*c}$ （其中n为批量数，d为特征数，c为类别数）

$Y_{final}=\frac{exp(Y)}{\sum(exp(Y_{line}))}$

即每行是一个样本，分母是每行的所有类别得分之和，分子是该样本的每种类别的得分，这样就能得到每个样本所属每个类别的概率值。

3、常搭配的损失函数——交叉熵损失函数

（1）分类要求

不求每类概率的精准性，只求每类概率间的大小比较能突出那个正确类别的概率（即要求正确类别概率最大）

（2）引入原因

平方损失函数过于严格的要求每类概率的精准性，所以不适合，因此引入了交叉熵损失函数。

（3）公式

$H(y^{i},\hat{y_{i}})=-\sum_{j=1}^{c} y_{j}^{i}log(\hat{y_{j}^{i}})$

$Loss=\frac{1}{n}\sum_{i=1}^{n}H(y^{i},\hat{y_{i}})$

其中 $y_{j}^{i}$ 即样本真实的类别概率（所属类别概率为1，其余为0）， $\hat{y_{j}^{i}}$ 为预测样本的类别概率（第i个样本第j类的概率）。

即实现了只关心正确的概率，目标：尽可能地让他变小。

同时也等价于： $exp(-nLoss)=\prod_{i=1}^{n}\hat{y^{i}_{y^{i}}}$ （最大化）

二、softmax的代码实现

1、自行实现

（1）全连接层和softmax层定义

import numpy as np

####################全连接网络定义部分########################
class FullyConnectedLayer(object):
    def __init__(self, num_input, num_output):  # 全连接层初始化
        self.num_input = num_input
        self.num_output = num_output
        # 参数初始化
        self.w = np.random.normal(loc=0.0, scale=0.01, size=(self.num_input, self.num_output))#W(d,c)
        self.b = np.zeros([1, self.num_output])#B(1,c)
    def forward(self, input):  # 前向传播计算
        self.input = input#X(n,d)
        # 全连接层的前向传播，计算输出结果
        self.output = np.matmul(self.input,self.w)+self.b#利用矩阵乘法(Y=XW+B)——（n,c）
        return self.output
    def backward(self, top_diff,lr):  # 反向传播的计算
        #全连接层的反向传播，计算参数梯度和本层损失
        self.d_weight = np.matmul(self.input.T,top_diff)#Y对W求导为X^T，再乘上一个梯度
        self.d_bias = top_diff#Y对B求导为全1矩阵
        bottom_diff = np.matmul(top_diff,self.w.T)#Y对X(输入,即上一层的输出)求导为W^T
        self.update_param(lr)
        return bottom_diff
    def update_param(self, lr):  # 参数更新
        # TODO：对全连接层参数利用参数进行更新
        self.w = self.w - lr*self.d_weight
        self.b = np.reshape(np.average(self.b - lr*self.d_bias, axis=0),(1, self.num_output))#从(n,c)重新变为(1,c)
    def load_param(self, weight, bias):  # 参数加载
        assert self.w.shape == weight.shape
        assert self.b.shape == bias.shape
        self.w = weight
        self.b = bias
    def save_param(self):  # 参数保存
        return self.w, self.b
####################全连接网络定义部分########################

####################softmax网络定义部分#######################
class SoftmaxLossLayer(object):
    def __init__(self):
        pass
    def forward(self, input):  # 前向传播的计算
        # TODO：softmax 损失层的前向传播，计算输出结果
        #input_max = np.max(input, axis=1, keepdims=True)#生成(n,1)大小的每行的最大值
        input_exp = np.exp(input)#生成(n,class)大小的e^(每个类别的概率)
        sum_denominator = np.sum(input_exp,axis=1,keepdims=True)#取每行的和,变成（n,1)
        self.prob = input_exp / sum_denominator#得到softmax最终公式（即属于每一类的概率）,分母（n，1）拓展成（n，c）
        #print(self.prob.shape)
        return self.prob
    def get_loss(self, label):   # 计算损失（这边要的是一个确切的数值结果）
        self.batch_size = self.prob.shape[0]#n
        #构建真实label
        self.label_onehot = np.zeros_like(self.prob)
        self.label_onehot[np.arange(self.batch_size), label] = 1.0#第几个样本最终属于哪一类(概率为1，其他为0)
        loss = -np.sum(np.log(self.prob) * self.label_onehot) / self.batch_size
        return loss
    def backward(self):  # 反向传播的计算
        # TODO：softmax 损失层的反向传播，计算本层损失（这边要的是一个梯度矩阵）
        bottom_diff = (self.prob - self.label_onehot)/self.batch_size        
        return bottom_diff
####################softmax网络定义部分#######################

（2）网络部分

import random
import numpy as np
from layer_softmax_linear import SoftmaxLossLayer,FullyConnectedLayer

#读取数据集
def data_iter(batch_size,num_examples,features,lables):
    index=list(range(num_examples))#获取每个样本的索引
    random.shuffle(index)#使索引顺序变成随机的，即样本读取顺序随机
    for i in range(0,num_examples,batch_size):#每次读取batch_size数据量出来
        j=np.array(index[i:min(i+batch_size,num_examples)])#获取这次小批量样本的索引
        yield features[j],lables[j]

#模型
class Model(object):
    def __init__(self,num_examples,num_input,num_output,batch_size,num_epochs,lr):
        self.num_examples=num_examples
        self.batch_size=batch_size
        self.num_epochs=num_epochs
        self.lr=lr
        self.linear=FullyConnectedLayer(num_input, num_output)
        self.softmax=SoftmaxLossLayer()
    def forward(self,input):#前向传播
        layer1=self.linear.forward(input)
        self.output=self.softmax.forward(layer1)
        return self.output
    def backward(self):#后向传播
        bottom_diff=self.softmax.backward()
        self.linear.backward(bottom_diff,self.lr)
    def get_loss(self,label):#得到损失loss
        self.loss=self.softmax.get_loss(label)
        return self.loss
    def train(self,features,labels):#训练
        for epoch in range(self.num_epochs):
            loss=0
            for x,y in data_iter(self.batch_size,self.num_examples,features,labels):
                self.forward(x)#前向传播
                loss=loss+self.get_loss(y)#得到一次batchsize的loss
                self.backward()#后向传播
            loss=loss/(self.num_examples//self.batch_size)
            print('epoch'+str(epoch+1)+', loss:'+str(loss))
    def parms(self):#返回模型参数
        return self.linear.save_param()
    def test(self,input):#用训练好的模型测试样本，返回标签和各类别的概率
        layer1=self.linear.forward(input)
        output=self.softmax.forward(layer1)
        label=np.argmax(output,axis=1).reshape(-1,1)#求每行最大值的索引，对应预测的类
        return label,output
    def evaluate(self,features,labels):#验证
        label,_=self.test(features)
        accuracy = np.mean(label==labels.reshape(-1,1))
        print("准确率为：",accuracy)

（3）主函数部分

import numpy as np
from sklearn import datasets
from model import Model

##########################数据准备部分##########################
iris = datasets.load_iris() # 导入鸢尾花数据集
features = iris.data # 特征集
labels = iris.target # label集
##########################数据准备部分##########################

##########################模型构建部分##########################
#参数定义部分
num_examples=features.shape[0]#样本数
num_inputs=features.shape[1]#特征数目
num_outputs=3#类别数
batch_size=15
num_epochs=100
lr=0.01

net=Model(num_examples,num_inputs,num_outputs,batch_size,num_epochs,lr)
net.train(features,labels)
net.evaluate(features,labels)
parms=net.parms()
print(parms)

（4）结果

?2、sklearn实现

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

#数据准备
iris = datasets.load_iris()
x,y=iris.data,iris.target
x_train,x_test,y_train,y_test = train_test_split(x,y)

#数据标准化
std = StandardScaler()
x_train = std.fit_transform(x_train)
x_test = std.fit_transform(x_test)

#模型训练
model = LogisticRegression()
model.fit(x_train,y_train)
print("参数W为：",model.coef_)
print("参数b为：",model.intercept_)
y_pred = model.predict(x_test)
print("测试集准确率为：",accuracy_score(y_pred,y_test))

结果：