Softmax分类器基本实现

#-*- coding: utf-8 -*-
import numpy as np

def softmax_loss_naive(W, X, y, reg):
    """
    使用显式循环版本计算Softmax损失函数
    N表示：数据个数，D表示：数据维度，C：表示数据类别个数。
    Inputs:
    - W: 形状(D, C) numpy数组，表示分类器权重（参数）.
    - X: 形状(N, D) numpy数组，表示训练数据.
    - y: 形状(N,) numpy数组，表示数据类标。
        其中 y[i] = c 意味着X[i]为第c类数据，c取值为[0,c)
    - reg: 正则化惩罚系数
    Returns  二元组(tuple):
    - loss,数据损失值
    - dW,权重W所对应的梯度，其形状和W相同
    """
    # 初始化损失值与梯度.
    loss = 0.0  
    dW = np.zeros_like(W)
    #############################################################################        
    #  任务：使用显式循环实现softmax损失值loss及相应的梯度dW 。                 #
    #  温馨提示： 如果不慎,将很容易造成数值上溢。别忘了正则化哟。               #
    #############################################################################
    # =============================================================================
    # 第一种
    # =============================================================================
    # num_train = X.shape[0]  # 获取训练样本数
    # num_class = W.shape[1]  # 获取分类总数
    # for i in range(num_train):  
    #     s = X[i].dot(W)  # (1, C) 每类的可能性
    #     scores = s - max(s)  # 关注最高分
    #     #使用指数函数，在不影响单调性的情况下，使相对得分更明显
    #     scores_E = np.exp(scores)  
    #     # 计算总得分
    #     Z = np.sum(scores_E)
    #     # 找到目标值
    #     score_target = scores_E[y[i]]
    #     # 计算出损失值
    #     loss += -np.log(score_target/Z)
    #     # 计算梯度值
    #     for j in range(num_class):
    #         if j == y[i]:
    #             dW[:, j] += -(1-scores_E[j]/Z)*X[i]
    #         else:
    #             dW[:, j] += X[i]*scores_E[j]/Z
    # # 使用平均损失，再引入正则化
    # loss = loss/num_train+0.5*reg*np.sum(W*W)
    # # 使用平均梯度，再引入正则化
    # dW = dW/num_train+reg*W

    # =============================================================================
    # 第二种
    # =============================================================================
    N = X.shape[0]  # 获取训练样本数
    C = W.shape[1]  # 获取分类总数

    result = X.dot(W)
    result -= np.max(result,axis=1,keepdims=True)#避免指数太大，导致计算太大，内存不够

    for i in range(N):
        # 计算函数值
        soft_max = np.exp(result[i][y[i]])/np.sum(np.exp(result[i]))
        # 计算出损失值
        loss += -np.log(soft_max)

        for j in range(C):
            
            if j==y[i]:
                dW[:,j] += -X[i].T
            dW[:,j] += (X[i].T * np.exp(result[i][j])) / (np.sum(np.exp(result[i])))

    loss/= N
    loss += reg*np.sum(W*W)
    dW /= N
    dW += reg*2*W
    #############################################################################
    #                           结束编码                                        #
    #############################################################################
    return loss, dW


def softmax_loss_vectorized(W, X, y, reg):
    """
    Softmax损失函数，使用矢量计算版本.
    输入，输出格式与softmax_loss_naive相同
    """
    # 初始化损失值与梯度
    loss = 0.0
    dW = np.zeros_like(W)
    #############################################################################
    # 任务: 不使用显式循环计算softmax的损失值loss及其梯度dW.                    #
    # 温馨提示： 如果不慎,将很容易造成数值上溢。别忘了正则化哟。                #
    #############################################################################
    # 训练样本数
    num_train = X.shape[0]
    # 计算函数值
    s = np.dot(X, W)
    # 关注最高分
    scores = s-np.max(s, axis=1, keepdims=True)
    # 使用指数函数来扩大相对比
    scores_E = np.exp(scores)
    # 求和得到总值
    Z = np.sum(scores_E, axis=1, keepdims=True)
    # 计算每一类的可能性
    prob = scores_E/Z
    # 真实标签标记
    y_trueClass = np.zeros_like(prob)
    y_trueClass[range(num_train), y] = 1.0
    # 计算损失值
    loss += -np.sum(y_trueClass*np.log(prob))/num_train+0.5*reg*np.sum(W*W)
    # 计算梯度
    dW += -np.dot(X.T, y_trueClass-prob)/num_train+reg*W
    #############################################################################
    #                          结束编码                                         #
    #############################################################################
    return loss, dW

softmax.py

#-*- coding: utf-8 -*-

import numpy as np
from random import shuffle
from softmax_loss import *

class Softmax(object):
    
    def __init__(self):
        self.W = None
        
    def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,
            batch_size=200, verbose=False):
        '''
        使用最小批量梯度下降算法训练Softmax分类器

        Parameters
        ----------
        X : TYPE
            数据
        y : TYPE
            数据类标
        learning_rate : TYPE, optional
            学习率. The default is 1e-3.
        reg : TYPE, optional
            权重衰减因子. The default is 1e-5.
        num_iters : TYPE, optional
            迭代次数. The default is 100.
        batch_size : TYPE, optional
            批大小. The default is 200.
        verbose : TYPE, optional
            是否显示中间过程. The default is False.

        Returns
        -------
        loss_history : TYPE
            DESCRIPTION.

        '''
        # 获得训练数据及维度
        num_train, dim = X.shape
        # 我们的计数是从0开始，因此10分类任务其y的最大值为9
        num_classes = np.max(y) + 1
        # 如果没有权重
        if self.W is None:
            # 随机初始化 W
            self.W = 0.001 * np.random.randn(dim, num_classes)
        # 储存每一轮的损失结果 W
        loss_history = []
        for it in range(num_iters):
            X_batch = None
            y_batch = None
            #########################################################################
            #                             任务:                                     #
            #     从训练数据 X 中采样大小为batch_size的数据及其类标，               #
            #     并将采样数据及其类标分别存储在X_batch，y_batch中                  #
            #        X_batch的形状为  (dim,batch_size)                              #
            #        y_batch的形状为  (batch_size)                                  #
            #     提示: 可以使用np.random.choice函数生成indices.                    #
            #            重复采样要比非重复采样快许多                               #
            #########################################################################
            # False表示不可以取相同数字
            indices = np.random.choice(num_train, batch_size, False)
            X_batch = X[indices, :]
            y_batch = y[indices]
            #########################################################################
            #                       结束编码                                        #
            #########################################################################
            # 计算损失及梯度
            loss, grad = self.loss(X_batch, y_batch, reg)
            loss_history.append(loss)
            # 更新参数
            #########################################################################
            #                       任务:                                           #
            #               使用梯度及学习率更新权重                                #
            #########################################################################
            self.W = self.W - learning_rate*grad 
            #########################################################################
            #                      结束编码                                         #
            #########################################################################
            if verbose and it % 500 == 0:
                print('迭代次数 %d / %d: loss %f' % (it, num_iters, loss))
        return loss_history
    
    
    def predict(self, X):
        """
        使用已训练好的权重预测数据类标
        Inputs:
        - X:数据形状 (N,D) .表示N条数据，每条数据有D维
        Returns:
        - y_pred：形状为(N,) 数据X的预测类标，y_pred是一个长度维N的一维数组，
        每一个元素是预测的类标整数
        """
        y_pred = np.zeros(X.shape[0])
        ###########################################################################
        #                         任务:                                           #
        #              执行预测类标任务，将结果储存在y_pred                       #
        ###########################################################################
        # 找到可能性最高的类别作为预测分类
        y_pred = np.argmax(X.dot(self.W), axis=1)	
        ###########################################################################
        #                           结束编码                                      #
        ###########################################################################
        return y_pred
    
    
    def loss(self, X_batch, y_batch, reg):
        """
        Compute the loss function and its derivative. 
        Subclasses will override this.

        Inputs:
        - X_batch: A numpy array of shape (N, D) containing a minibatch of N
          data points; each point has dimension D.
        - y_batch: A numpy array of shape (N,) containing labels for the minibatch.
        - reg: (float) regularization strength.

        Returns: A tuple containing:
        - loss as a single float
        - gradient with respect to self.W; an array of the same shape as W
        """
        return softmax_loss_vectorized(self.W, X_batch, y_batch, reg)