【机器学习】（六）——逻辑回归

最新推荐文章于 2024-09-10 14:26:22 发布

独脚行

最新推荐文章于 2024-09-10 14:26:22 发布

阅读量373

点赞数

分类专栏：机器学习文章标签：逻辑回归

本文链接：https://blog.csdn.net/qq_27276951/article/details/103531209

版权

机器学习专栏收录该内容

9 篇文章 2 订阅

订阅专栏

学习目标：

1、逻辑回归：损失函数、梯度、决策边界

2、实践：代码实现及sklearn逻辑回归

知识整理：

【1】

逻辑回归引入

损失函数：

逻辑回归模型：

线性回归中的损失函数：

由于已知 $\theta ^{T}\cdot x_{b}$ 是估计值，于是用估计值与真值的差来度量模型的好坏。使用MSE（差值的平方和再平均）作为损失函数。然后就可以通过导数求极值的方法，找到令损失函数最小的 $\theta$ 了。

逻辑回归中的损失函数：

逻辑回归和线性回归最大的区别就是：逻辑回归解决的是分类问题，得到的y要么是1，要么是0。而我们估计出来的p是概率，通过概率决定估计出来的p到底是1还是0。因此，也可以将损失函数分成两类：

1.如果给定样本的真实类别y=1，则估计出来的概率p越小，损失函数越大（估计错误）

2.如果给定样本的真实类别y=0，则估计出来的概率p越大，损失函数越大（估计错误）

使用函数表示上面的两种情况：

当y=1时，损失函数为。特点是：越趋于0，损失（loss）越大；越趋于1，损失（loss）越小。

当y=0时，损失函数为。特点是：越趋于1，损失（loss）越大；越趋于0，损失（loss）越小。

将上面的两个式子合并：

以上是对于单个样本的误差值，那么求整个集合内的损失可以取平均值

然后，我们将替换成sigmoid函数，得到逻辑回归的损失函数如下：

梯度：

对于损失函数：

使用梯度下降法，就要求出梯度，对每一个向量 $\theta$ 中每一个参数，都求出对应的导数：

对sigmoid函数进行求导（链式求导法则）：

然后对外层的log函数进行求导：

然后进行整理：

下面就可以对损失函数前半部分的表达式：对 $\theta$ 进行求导了。带入上面的结果，得到：

同样地，可以对损失函数的后半部分做求导，跟上面类似。

最终求的损失函数 $L\left ( \theta \right )$ 对 $\theta$ 的导数如下，即逻辑回归的损失函数经过梯度下降法对一个参数进行求导，得到结果如下：

其中就是逻辑回归模型的预测值。

在求得对一个参数的导数之后，则可以对所有特征维度上对损失函数进行求导，得到向量化后的结果如下：

决策边界：也称为决策面，是用于在N维空间，将不同类别样本分开的平面或曲面

线性决策边界：
preview

这里决策边界为:

非线性决策边界：

这里决策边界为:

上面两张图很清晰的解释了什么是决策边界，决策边界其实就是一个方程，在逻辑回归中，决策边界由定义

【2】

# 我们在线性回归的基础上，修改得到逻辑回归。主要内容为：
# 定义sigmoid方法，使用sigmoid方法生成逻辑回归模型
# 定义损失函数，并使用梯度下降法得到参数
# 将参数代入到逻辑回归模型中，得到概率
# 将概率转化为分类

import numpy as np
# 因为逻辑回归是分类问题，因此需要对评价指标进行更改
from .metrics import accuracy_score

class LogisticRegression:

    def __init__(self):
        """初始化Logistic Regression模型"""
        self.coef_ = None
        self.intercept_ = None
        self._theta = None

    """
    定义sigmoid方法
    参数：线性模型t
    输出：sigmoid表达式
    """
    def _sigmoid(self, t):
        return 1. / (1. + np.exp(-t))
    
    """
    fit方法，内部使用梯度下降法训练Logistic Regression模型
    参数：训练数据集X_train, y_train, 学习率, 迭代次数
    输出：训练好的模型
    """
    def fit(self, X_train, y_train, eta=0.01, n_iters=1e4):
        
        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must be equal to the size of y_train"

        """
        定义逻辑回归的损失函数
        参数：参数theta、构造好的矩阵X_b、标签y
        输出：损失函数表达式
        """
        def J(theta, X_b, y):
            # 定义逻辑回归的模型：y_hat
            y_hat = self._sigmoid(X_b.dot(theta))
            try:
                # 返回损失函数的表达式
                return - np.sum(y*np.log(y_hat) + (1-y)*np.log(1-y_hat)) / len(y)
            except:
                return float('inf')
        """
        损失函数的导数计算
        参数：参数theta、构造好的矩阵X_b、标签y
        输出：计算的表达式
        """
        def dJ(theta, X_b, y):
            return X_b.T.dot(self._sigmoid(X_b.dot(theta)) - y) / len(y)

        """
        梯度下降的过程
        """
        def gradient_descent(X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
            theta = initial_theta
            cur_iter = 0
            while cur_iter < n_iters:
                gradient = dJ(theta, X_b, y)
                last_theta = theta
                theta = theta - eta * gradient
                if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
                    break
                cur_iter += 1
            return theta

        X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
        initial_theta = np.zeros(X_b.shape[1])
        # 梯度下降的结果求出参数heta
        self._theta = gradient_descent(X_b, y_train, initial_theta, eta, n_iters)
        # 第一个参数为截距
        self.intercept_ = self._theta[0]
        # 其他参数为各特征的系数
        self.coef_ = self._theta[1:]
        return self

    """
    逻辑回归是根据概率进行分类的，因此先预测概率
    参数：输入空间X_predict
    输出：结果概率向量
    """
    def predict_proba(self, X_predict):
        """给定待预测数据集X_predict，返回表示X_predict的结果概率向量"""
        assert self.intercept_ is not None and self.coef_ is not None, \
            "must fit before predict!"
        assert X_predict.shape[1] == len(self.coef_), \
            "the feature number of X_predict must be equal to X_train"

        X_b = np.hstack([np.ones((len(X_predict), 1)), X_predict])
        # 将梯度下降得到的参数theta带入逻辑回归的表达式中
        return self._sigmoid(X_b.dot(self._theta))

    """
    使用X_predict的结果概率向量，将其转换为分类
    参数：输入空间X_predict
    输出：分类结果
    """
    def predict(self, X_predict):
        """给定待预测数据集X_predict，返回表示X_predict的结果向量"""
        assert self.intercept_ is not None and self.coef_ is not None, \
            "must fit before predict!"
        assert X_predict.shape[1] == len(self.coef_), \
            "the feature number of X_predict must be equal to X_train"
        # 得到概率
        proba = self.predict_proba(X_predict)
        # 判断概率是否大于0.5，然后将布尔表达式得到的向量，强转为int类型，即为0-1向量
        return np.array(proba >= 0.5, dtype='int')

    def score(self, X_test, y_test):
        """根据测试数据集 X_test 和 y_test 确定当前模型的准确度"""

        y_predict = self.predict(X_test)
        return accuracy_score(y_test, y_predict)

    def __repr__(self):
        return "LogisticRegression()"