【机器学习】一文掌握逻辑回归全部核心点(上)。

逻辑回归核心点-上

1、引言
2、逻辑回归核心点
- 2.1 定义与目的
- 2.2 模型原理
- - 2.2.1 定义解析
  - 2.2.2 公式
  - 2.2.3 代码示例
- 2.3 损失函数与优化
- - 2.3.1 定义解析
  - 2.3.2 公式
  - 2.3.3 代码示例
- 2.4 正则化
- - 2.4.1 分类
  - 2.4.2 L1正则化
  - 2.4.3 L2正则化
  - 2.4.4 代码示例
3、总结

1、引言

小屌丝：鱼哥，你说逻辑归回需要掌握哪些技能？
小鱼：我上一篇不是写了逻辑回归的的博文嘛~
小屌丝：意犹未尽，我还想探索的更深层的。
小鱼：额… 有多深？
小屌丝：逻辑回归的核心要点有哪些？
小鱼：这个…
小屌丝：这个不可以吗？
小鱼：这个可以啊。
小屌丝：吓我一跳，我还以为不行呢。
小鱼：鉴于最近学习这么认真，我们今天就来聊一聊逻辑回归的核心要点。
在这里插入图片描述

2、逻辑回归核心点

2.1 定义与目的

定义：逻辑回归是一种广义的线性模型，用于解决二分类问题。尽管名字中包含“回归”，但逻辑回归实际上是一种分类算法，它输出的是样本属于某个类别的概率。
目的：逻辑回归的目的是根据给定的输入特征预测样本所属的类别。它通常用于处理二分类问题，但也可以通过一些技术扩展到多分类问题。
应用场景：逻辑回归广泛应用于各种领域，如垃圾邮件检测、疾病预测、金融风险评估等

2.2 模型原理

2.2.1 定义解析

线性回归部分：逻辑回归首先通过线性回归模型计算出一个得分或线性预测值。这个值是基于输入特征和相应权重的加权和，再加上一个偏置项。
逻辑函数（sigmoid函数）：线性预测值通过sigmoid函数转换为概率值。sigmoid函数将任何实数映射到(0, 1)区间内，使得输出可以解释为属于某个类别的概率。
决策边界：根据权重和偏置项，逻辑回归模型定义了一个决策边界，用于分隔不同类别的样本。这个边界可以是线性的，也可以是非线性的，取决于特征的变换和选择。

2.2.2 公式

sigmoid函数的公式为：

$\sigma(z) = \frac{1}{1 + e^{-z}} ]$

2.2.3 代码示例

便于理解，代码展示

# 使用上面定义的sigmoid函数  
z = 2.0  
probability = sigmoid(z)  
print("sigmoid函数输出:", probability)

2.3 损失函数与优化

2.3.1 定义解析

对数损失函数（log-loss）：逻辑回归使用对数损失函数来衡量模型预测与实际标签之间的差异。对数损失函数鼓励模型对正确类别的预测概率接近1，而对错误类别的预测概率接近0。
优化算法：为了最小化损失函数，逻辑回归通常使用梯度下降法或其变种（如随机梯度下降、批量梯度下降等）进行优化。这些算法通过迭代更新权重和偏置项来逐步降低损失函数的值。
学习率与收敛条件：在优化过程中，学习率是一个重要的超参数，它控制权重更新的步长。此外，还需要设置收敛条件来确定优化何时停止，以避免过度拟合或过早停止训练。

2.3.2 公式

对数损失函数的公式为：

$J(\theta) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(h(x^{(i)}; \theta)) + (1 - y^{(i)}) \log(1 - h(x^{(i)}; \theta))] ]$

其中，

( m ) 是样本数量。
( y^{(i)} ) 是第 ( i ) 个样本的实际标签（0或1）。
( h(x^{(i)}; \theta) ) 是第 ( i ) 个样本的预测概率。
( \theta ) 是参数向量，包括权重和偏置项。

2.3.3 代码示例

代码示例

# -*- coding:utf-8 -*-
# @Time   : 2024-03-02
# @Author : Carl_DJ

import numpy as np  
  
# 定义对数损失函数  
def log_loss(y_true, y_pred):  
    m = len(y_true)  
    cost = -np.sum(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)) / m  
    return cost  
  
# 示例真实标签和预测概率  
y_true = np.array([0, 1, 1, 0])  
y_pred = np.array([0.1, 0.9, 0.8, 0.4])  
  
# 计算对数损失  
loss = log_loss(y_true, y_pred)  
print("对数损失:", loss)

2.4 正则化

2.4.1 分类

L1正则化：通过在损失函数中加入权重系数的绝对值之和，L1正则化可以产生稀疏的权重矩阵，即许多权重为0。这有助于减少模型的复杂度，并可能提高模型的泛化能力。
L2正则化：L2正则化通过在损失函数中加入权重系数的平方和来实现。它倾向于使权重整体偏小，但并不使它们为0。L2正则化有助于减少过拟合，提高模型的稳定性。
正则化系数的选择：正则化系数 (\lambda) 是一个超参数，需要手动设置。选择合适的 (\lambda) 值对于平衡模型的复杂度和拟合能力至关重要。通常，我们可以通过交叉验证等技术来选择最优的 (\lambda) 值。

2.4.2 L1正则化

L1正则化的损失函数为：

$J(\theta) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(h(x^{(i)}; \theta)) + (1 - y^{(i)}) \log(1 - h(x^{(i)}; \theta))] + \lambda \sum_{j=1}^{n} |\theta_j| ]$

2.4.3 L2正则化

L2正则化的损失函数为：

$J(\theta) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(h(x^{(i)}; \theta)) + (1 - y^{(i)}) \log(1 - h(x^{(i)}; \theta))] + \frac{\lambda}{2} \sum_{j=1}^{n} \theta_j^2 ]$

2.4.4 代码示例

# -*- coding:utf-8 -*-
# @Time   : 2024-03-02
# @Author : Carl_DJ

import numpy as np  
  
# 定义sigmoid函数  
def sigmoid(z):  
    return 1 / (1 + np.exp(-z))  
  
# 定义L2正则化逻辑回归的损失函数  
def logistic_regression_loss(w, b, X, y, lambda_val):  
    m = len(y)  
    A = sigmoid(np.dot(X, w) + b)  
    cost = (-1 / m) * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A))  
    regularization = (lambda_val / (2 * m)) * np.sum(w**2)  
    return cost + regularization  
  
# 定义梯度下降优化函数  
def gradient_descent(w, b, X, y, learning_rate, lambda_val, num_iterations):  
    m = len(y)  
    J_history = []  
      
    for i in range(num_iterations):  
        A = sigmoid(np.dot(X, w) + b)  
        dw = (1 / m) * np.dot(X.T, (A - y)) + (lambda_val / m) * w  
        db = (1 / m) * np.sum(A - y)  
          
        w = w - learning_rate * dw  
        b = b - learning_rate * db  
          
        J = logistic_regression_loss(w, b, X, y, lambda_val)  
        J_history.append(J)  
          
    return w, b, J_history  
  
# 示例数据  
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])  
y = np.array([0, 0, 1, 1])  
  
# 初始化参数  
w = np.zeros(X.shape[1])  
b = 0  
  
# 设置超参数  
learning_rate = 0.1  
lambda_val = 0.1  
num_iterations = 1000  
  
# 运行梯度下降  
w, b, J_history = gradient_descent(w, b, X, y, learning_rate, lambda_val, num_iterations)  
  
# 输出训练过程中的损失值  
print("训练过程中的损失值:", J_history)