分类——Logistic回归与SoftMax回归以及Python实现

Logistic 回归

逻辑斯谛回归实质上是一种分类算法。由于历史原因名称中带有“回归”二字。

从传统统计学角度看

传统线性回归模型无法处理因变量是0-1型变量的情况，于是引入因变量y的均值$E(y)=\pi (\pi 为y=1时的概率)$ 作为新的因变量进行回归分析，并且抛弃线性模型，改用取值范围为(0,1)的逻辑斯蒂函数。

从机器学习角度看

模型

与朴素贝叶斯相比，逻辑斯谛回归模型使用了属于正类的概率服从logistic分布(逻辑函数)这一先验信息，模型参数少。即$$p(y=1|x)=\frac{1}{1+e^{-wx}}$$
那么，这一分布有什么意义呢？一个事件的几率是该事件发生的概率与不发生的比值，则$$\log \frac{p}{1-p}=wx$$可见对于逻辑斯谛回归模型对数几率与输入向量x是线性关系。

策略

对数损失函数最小化，等同于极大对数似然函数。

学习方法

根据策略，问题演变成最优化问题，通常采用最速梯度下降法。$$grad=\sum _{i=1}^N{x}_i(y_i-y_i^{pred})$$注意：该式与平方损失函数梯度十分相似，但这个是由对数损失函数(或极大似然函数推导而来)

SoftMax回归

SoftMax回归是逻辑斯谛回归在多分类问题上的推广。

核心思想

求解输入向量x属于每个类的概率，取概率最大的为预测类。

算法简介

SoftMax回归与逻辑斯谛回归的模型唯一的区别在于，SoftMax的每个类对应一组权值向量w，所以其参数是一个n_class*n_dimension的矩阵。更多具体内容请参考SoftMax回归

代码

###Logistic回归

"""
逻辑斯谛回归
"""

import numpy as np


class LR:
    def __init__(self, alpha=0.01, maxstep=1000):
        self.w = None
        self.maxstep = maxstep
        self.alpha = alpha

    def sig(self, z):
        # Logistic函数, 正类的概率
        return 1.0 / (1 + np.exp(-z))

    def bgd(self, X_data, y_data):  # 损失函数采用对数损失函数，其数学形式与似然函数一致
        # 批量梯度下降法
        b = np.ones((X_data.shape[0], 1))
        X = np.hstack((X_data, b))  # 考虑阈值，堆输入向量进行扩充
        w = np.ones(X.shape[1])  # 初始化各特征的权重
        i = 0
        while i <= self.maxstep:
            i += 1
            err = y_data - self.sig(w @ X.T)
            w += self.alpha * err @ X  # 注意，其表达式与平方误差损失函数的非常相似，但这是由对数损失函数推导而来的
        self.w = w
        return

    def fit(self, X_data, y_data):
        self.bgd(X_data, y_data)
        return

    def predict(self, x):
        x = np.append(x, 1)
        PT = self.sig(self.w @ x.T)
        if PT > 1 - PT:
            return 1
        else:
            return 0


if __name__ == '__main__':
    from sklearn import datasets

    data = datasets.load_digits(n_class=2)
    X_data = data['data']
    y_data = data['target']

    from machine_learning_algorithm.cross_validation import validate
    g = validate(X_data, y_data, ratio=0.2)
    for item in g:
        X_train, y_train, X_test, y_test = item
        clf = LR()
        clf.fit(X_train, y_train)
        score = 0
        for x, y in zip(X_test, y_test):
            if clf.predict(x)==y:
                score += 1
        print(score/len(y_test))

SoftMax回归

"""
SoftMax回归，逻辑斯蒂回归的多分类推广。所以，本质还是一种分类算法
"""
import numpy as np


class SoftMax:
    def __init__(self, maxstep=10000, C=1e-4, alpha=0.4):
        self.maxstep = maxstep
        self.C = C  # 权值衰减项系数lambda, 类似于惩罚系数
        self.alpha = alpha  # 学习率

        self.w = None  # 权值

        self.L = None  # 类的数量
        self.D = None  # 输入数据维度
        self.N = None  # 样本总量

    def init_param(self, X_data, y_data):
        # 初始化，暂定输入数据全部为数值形式
        b = np.ones((X_data.shape[0], 1))
        X_data = np.hstack((X_data, b))  # 附加偏置项
        self.L = len(np.unique(y_data))
        self.D = X_data.shape[1]
        self.N = X_data.shape[0]
        self.w = np.ones((self.L, self.D))  # l*d, 针对每个类，都有一组权值参数w
        return X_data

    def bgd(self, X_data, y_data):
        # 梯度下降训练
        step = 0
        while step < self.maxstep:
            step += 1
            prob = np.exp(X_data @ self.w.T)  # n*l, 行向量存储该样本属于每个类的概率
            nf = np.transpose([prob.sum(axis=1)])  # n*1
            nf = np.repeat(nf, self.L, axis=1)  # n*l
            prob = -prob / nf  # 归一化， 此处条件符号仅方便后续计算梯度
            for i in range(self.N):
                prob[i, int(y_data[i])] += 1
            grad = -1.0 / self.N * prob.T @ X_data + self.C * self.w  # 梯度， 第二项为衰减项
            self.w -= self.alpha * grad
        return

    def fit(self, X_data, y_data):
        X_data = self.init_param(X_data, y_data)
        self.bgd(X_data, y_data)
        return

    def predict(self, X):
        b = np.ones((X.shape[0], 1))
        X = np.hstack((X, b))  # 附加偏置项
        prob = np.exp(X @ self.w.T)
        return np.argmax(prob, axis=1)


if __name__ == '__main__':
    from sklearn.datasets import load_digits

    data = load_digits()
    X_data = data['data']
    y_data = data['target']

    from machine_learning_algorithm.cross_validation import validate

    g = validate(X_data, y_data, ratio=0.2)
    for item in g:
        X_train, y_train, X_test, y_test = item
        clf = SoftMax(maxstep=10000, alpha=0.1, C=1e-4)
        clf.fit(X_train, y_train)
        y_pred = clf.predict(X_test)
        score = 0
        for y, y_pred in zip(y_test, y_pred):
            score += 1 if y == y_pred else 0
        print(score / len(y_test))

我的GitHub
注：如有不当之处，请指正。