机器学习之逻辑回归模型

一、逻辑回归核心思想
1、核心目标
只解决二分类问题，比如
邮件是 “垃圾邮件（1）” 还是 “正常邮件（0）”
用户会 “购买（1）” 还是 “不购买（0）”
肿瘤是 “恶性（1）” 还是 “良性（0）”
它的最终输出不是明确的 “是/否”，而是 “属于某一类的概率”（比如80%概率是垃圾邮件），再根据概率阈值（通常是0.5）判断类别。
2、核心思路
把“线性结果”变成“概率”，这是逻辑回归最关键的一步，分两步走：
(1)先找线性关系：和线性回归一样，先通过特征计算一个 “线性得分”。比如用 “邮件含敏感词数量x1”“发送时间x2”，计算得分z=w1x1+w2x2+b（w是权重，b是偏置，和线性回归完全一样）。
(2)把得分转换成概率：线性得分z的范围可以是任意实数（比如-100到100），但概率必须在0-1之间。这时候需要一个“转换函数”——Sigmoid函数。
重点：Sigmoid函数怎么用？
Sigmoid函数的公式是σ(z)=1/(1+e^(-z))，它的作用特别简单：
当z很大（比如z=10）：e^(-z)≈0，σ(z)≈1/1=1（概率接近1）。
当z很小（比如z=-10）：e^(-z)≈很大的数，σ(z)≈0（概率接近0）。
当z=0：σ(z)=1/(1+1)=0.5（概率正好是0.5）。
简单说，Sigmoid函数会把任意线性得分，压缩成0-1之间的概率值，这个概率就是“样本属于类别1的可能性”。
3、概率阈值说了算
训练好模型后，输入新样本的特征，计算出概率p（属于类别1的概率）：
如果p≥0.5（默认阈值），判断为类别1。
如果p＜0.5，判断为类别0。
阈值可以根据需求调整，比如医疗场景要 “少漏诊”，可以把阈值调小（比如0.3），只要概率≥0.3 就判断为阳性。
二、逻辑回归的损失函数
1、核心目标
核心是“衡量预测值与真实值的差距”，逻辑回归是做二分类，判断是/否，正/负，输出的是0-1之间的概率，比如预测某用户购买概率30%，损失函数的作用是预测越准，损失越小；预测越错，损失越大。
2、为什么不用线性回归的损失函数？
线性回归用“均方误差”（预测值和真实值的平方差），但逻辑回归不适用；逻辑回归输出是概率（0-1），均方误差会导致损失函数是“非凸的”，容易找到局部最小值而非全局最优；均方误差对“极端错误”的惩罚不够狠，比如真实是1，预测是0.01，平方后差距被缩小。
3、逻辑回归的损失函数：交叉熵损失
交叉熵损失也叫“对数损失”，核心思路是“对正确答案的概率越有信心，损失越小”，分两种情况（y是真实标签，ŷ是预测概率):
(1)当真实标签y=1（比如确实购买了）：损失=-ln(ŷ)。ŷ越接近1，ln(ŷ) 越接近0，损失越小；ŷ越接近0，ln(ŷ) 越负，损失越大（惩罚越重）。
(2)当真实标签y=0（比如没购买）：损失=-ln(1-ŷ)。ŷ越接近0，1-ŷ越接近1，损失越小；ŷ越接近1，损失越大。
把两种情况整合，整体损失函数为：
Loss=-[y・ln(ŷ)+(1-y)・ln(1-ŷ)]
当y=1时，(1-y)=0，公式只剩-ln(ŷ)（对应第一种情况）。
当y=0时，y=0，公式只剩-ln(1-ŷ)（对应第二种情况）。
假设 3 个样本的真实标签和预测概率如下：
(1)真实y=1，预测ŷ=0.9：损失=-ln (0.9)≈0.105（预测准，损失小）。
(2)真实y=1，预测ŷ=0.1：损失=-ln (0.1)≈2.303（预测错，损失大）。
(3)真实y=0，预测ŷ=0.8：损失=-ln (0.2)≈1.609（预测错，损失大）。
很明显：预测越贴合真实情况，损失值越小，符合我们的直觉。
4、整个数据集的总损失
单个样本有损失，整个数据集的总损失就是所有样本损失的平均值（或总和），模型训练的目标就是“最小化这个总损失”。
三、梯度下降
1、核心结论
梯度下降是一种优化算法，核心作用是帮模型（比如逻辑回归，线性回归）找到最合适的参数，让损失函数的值最小，它不用一次性算准最优解，而是通过“小步快跑、不断修正”的方式逼近目标。
2、用“下山”理解核心逻辑
把损失函数想象成一座山，你的目标是走到山底（损失最小的地方）：
你站在山上的某个位置（对应一组初始参数w和b，以及此时的损失值）。
第一步：判断 “往哪个方向走，能最快下山”—— 这个方向就是 “梯度”（梯度是损失函数对参数的偏导数，本质是“损失变化最快的方向”）。
第二步：确定 “每一步走多大”—— 这个步长叫 “学习率”（比如每次走0.01，不能太大也不能太小）。
第三步：朝着 “梯度的反方向” 走一步（因为梯度指向损失增大的方向，反方向才是损失减小的方向），到达新位置。
重复以上步骤，直到走到山底（损失不再明显减小），此时的位置就是最优参数。
3、关键概念拆解
(1)梯度：“方向指引器”
梯度不是一个数值，而是一个“向量”（有方向、有大小）。
对单个参数（比如w1），梯度就是 “损失函数对w1的偏导数”—— 表示“w1稍微变一点，损失会怎么变”。
比如逻辑回归有w1、w2、b三个参数，梯度就是（∂Loss/∂w1, ∂Loss/∂w2, ∂Loss/∂b），告诉我们每个参数该怎么调，损失降得最快。
(2)学习率：“步长大小”
学习率（常用η表示）是控制每一步走多远的关键，直接影响 “下山效率”：
学习率太大：步子跨太大，可能从山的一侧跨到另一侧，永远到不了山底（甚至越走越远）。
学习率太小：步子迈得太小，需要走成千上万步才能到山底，训练速度极慢。
实际应用中，学习率通常选0.001、0.01这类较小的值，根据模型效果调整。
(3)迭代：“重复走步”
梯度下降不是走一步就到山底，而是 “计算梯度→调整参数→计算新梯度→再调整参数” 的循环过程，这个循环叫“迭代”。
每迭代一次，参数就更新一次，损失函数的值会慢慢减小。
当迭代到 “损失值变化特别小”（比如两次迭代的损失差小于0.0001），就认为已经到山底，停止迭代。
4、逻辑回归中的梯度下降
逻辑回归的目标是找到最优的w和b，让交叉熵损失最小，梯度下降的具体操作：
(1)初始化参数：给w1、w2、b赋一个初始值（比如全为0，或随机小数值）。
(2)计算总损失：用当前的w和b，通过交叉熵损失函数，算出所有样本的总损失。
(3)计算梯度：分别算出损失函数对w1、w2、b的偏导数（即梯度）。
(4)更新参数：按“参数=参数-学习率×梯度”的公式，调整w1、w2、b。
(5)重复步骤(2)-(4)：直到总损失不再明显下降，此时的w和b就是最优参数。
四、逻辑回归核心函数

点击查看代码

class LogisticRegression:
    def __init__(self, learning_rate=0.01, epochs=1000):
        self.learning_rate = learning_rate  # 学习率（步长）
        self.epochs = epochs  # 迭代次数（走多少步）
        self.weights = None  # 权重w（后续计算）
        self.bias = None     # 偏置b（后续计算）

    # 1. Sigmoid函数：把线性得分转成概率
    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))  # 公式：σ(z) = 1/(1+e^(-z))

    # 2. 训练模型（核心：梯度下降）
    def fit(self, X, y):
        n_samples, n_features = X.shape  # 样本数=100，特征数=2
        self.weights = np.zeros(n_features)  # 初始化权重：[0, 0]
        self.bias = 0  # 初始化偏置：0

        # 迭代更新参数
        for _ in range(self.epochs):
            # 计算线性得分 z = w1*x1 + w2*x2 + b
            z = np.dot(X, self.weights) + self.bias
            # 转成概率：ŷ = sigmoid(z)
            y_pred = self.sigmoid(z)

            # 计算梯度（根据交叉熵损失推导的简化公式）
            dw = (1 / n_samples) * np.dot(X.T, (y_pred - y))  # 权重的梯度
            db = (1 / n_samples) * np.sum(y_pred - y)         # 偏置的梯度

            # 更新参数：往梯度反方向走一步
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db

    # 3. 预测函数
    def predict(self, X):
        z = np.dot(X, self.weights) + self.bias
        y_pred_prob = self.sigmoid(z)  # 预测概率
        return [1 if p >= 0.5 else 0 for p in y_pred_prob]  # 概率≥0.5判为1，否则0