写这篇文章的起因是，我一个做数据分析的朋友最近在啃逻辑回归，翻了一堆教程，公式都能背了，但一到自己写代码就卡壳。他问我：“为什么我看懂了损失函数，却不知道怎么把梯度下降落到代码里？”这个问题很典型。逻辑回归是机器学习入门必须跨过的一道坎，它比线性回归多了一层概率映射，比决策树又多了明确的损失函数优化过程，搞懂它的代码实现，你才算真正理解了“模型是怎么学出来的”。
这篇文章我会从零开始，拆解一份完整的Logistic Regression代码详解以及Demo，包括手写numpy实现核心算法、用sklearn快速搭建对比、可视化决策边界和损失下降曲线，以及我在实际调试中踩过的坑。适合刚学完理论、想动手写代码的初学者，也适合想复习算法细节的开发者。
1. 项目概述与核心思路拆解
1.1 逻辑回归是什么，这个Demo要解决什么问题
逻辑回归（Logistic Regression）虽然名字里带“回归”，但它本质上是分类算法，而且是最常用的二分类算法。它的核心思想是：把线性回归的输出结果，通过sigmoid函数压缩到0到1之间，得到一个概率值，然后根据这个概率做分类判断。
网上关于逻辑回归的教程少说也有几千篇，但大多数只讲理论，或者只给一段调sklearn库的代码。真正能让人“豁然开朗”的，是那种从零手写实现的代码——你亲自把sigmoid、损失函数、梯度下降一个个敲出来，再看模型怎么一步步收敛，这个过程对理解机器学习本质的帮助，远大于调库。
这个Demo解决三个核心问题：逻辑回归的数学原理如何转化为可执行代码？训练过程中的参数如何更新？如何用可视化验证模型学到的决策边界是否正确？我见过太多初学者跑通sklearn代码就觉得自己会了，但一问“逻辑回归的目标函数是什么”就答不上来，一问“梯度下降的参数怎么算”就更懵了。
1.2 为什么选择“手写numpy + sklearn对照”的路线
我给朋友设计这条路线，核心考量是“先拆解，再对照”。
很多教程直接甩一个sklearn的LogisticRegression，几行代码跑完，看起来很简单，但脑子里留下的只有“调用”这个动作。所以我坚持让他先手写一个numpy版本，把每个公式都变成代码行。比如sigmoid函数就是1 / (1 + np.exp(-z))，损失函数就是对数的求和，梯度更新就是那三行参数迭代。这些代码写出来的过程，就是理论变实践的过程。
举个例子，当你手写交叉熵损失的时候，你会注意到对数函数在预测概率接近0或1时会出现极端值，这时候你自然会想到需要加一个eps防止除零或取对数报错。这种细节是调库永远学不到的。
sklearn的版本作为对照，验证我们的手写实现是否正确，同时让读者知道实际工程中不用重复造轮子。数据生成我用make_classification或者手动构造线性可分的数据点，这样决策边界可视化出来非常直观。整个Demo我尽量控制在200行代码以内，保证逻辑清晰、重点突出。
1.3 这个项目的适用人群和前置知识要求
先说结论：有一点Python基础、学过线性回归，就可以跟下来。不需要你精通高数，也不要求你熟悉深度学习的反向传播。
前置知识就三块：第一，Python的numpy基本操作，比如数组切片、矩阵乘法、广播机制；第二，线性回归的基本概念，知道y = wx + b是怎么回事；第三，对“训练”和“预测”有一个模糊的概念就行，哪怕你只是跑过别人写的鸢尾花分类代码。
数学方面的门槛很低，核心就是一个sigmoid公式和一个求导结果。很多教程会把梯度推导写满一整页，我看着都头大，其实真正写代码的时候，你只需要记住线性回归的梯度是(ŷ - y) * x，逻辑回归的梯度同样也是(ŷ - y) * x，只是ŷ变成了经过sigmoid压缩后的概率。这个结论可以帮你省掉80%的推导时间。
2. 逻辑回归核心原理：公式是怎么变成代码的
2.1 sigmoid函数：从线性输出到概率的关键转换
逻辑回归的第一步，是把线性回归的结果z = w·x + b变成一个概率。这里起关键作用的就是sigmoid函数：
z = w1*x1 + w2*x2 + b ŷ = 1 / (1 + exp(-z))这个函数有几个很有意思的性质。当z趋近于正无穷时，ŷ趋近于1；当z趋近于负无穷时，ŷ趋近于0；当z等于0时，ŷ等于0.5。这意味着决策边界刚好就是z = 0的那条线，也就是w1*x1 + w2*x2 + b = 0这条直线。在二维平面上，这条直线把数据点分成两类，逻辑回归学到的就是这么一条线。
很多初学者不理解为什么非要用sigmoid而不是别的函数。我打个比方：你在预测一个人会不会购买某件商品，特征是他的收入、年龄、历史购物频次。线性回归算出来的分数可能是5分、-3分或者100分，这些数字不好解释。但如果把它们压缩到0到1之间，就可以直接当作购买概率来用，大于0.5就判断会买，小于0.5就判断不会买。sigmoid函数的光滑性和可导性，让我们能顺利地对它求梯度。
代码实现非常简洁：
import numpy as np def sigmoid(z): # 防止溢出，对于过大的负值做裁剪 z = np.clip(z, -500, 500) return 1 / (1 + np.exp(-z))注意这里的np.clip是我加上去的。如果不加，当z是很大的负数时，np.exp(-z)会爆炸成一个天文数字，直接导致溢出报错。这是我实际跑代码时踩过的坑。
2.2 损失函数：为什么用交叉熵而不是均方误差
模型要优化，必须有一个衡量“错得有多离谱”的函数，这就是损失函数。逻辑回归常用的损失函数是交叉熵（cross-entropy）：
J(w) = -1/m * Σ [ y·log(ŷ) + (1-y)·log(1-ŷ) ]这里m是样本数，y是真实标签（0或1），ŷ是预测概率。为什么不用线性回归的均方误差？因为逻辑回归的ŷ是经过sigmoid函数压缩的，MSE在sigmoid的非线性区域会导致梯度很小，训练速度会非常慢，也就是所谓的梯度消失问题。而交叉熵在预测错误时梯度很大，能快速修正，预测正确时梯度趋近于0，不会过度更新。
从另一个角度看，交叉熵还有一个很直观的解释：当真实标签y=1时，损失项只剩下-log(ŷ)；如果ŷ接近1，损失接近0；如果ŷ接近0，损失趋向无穷大。这特别符合直觉——你把一个正样本预测成概率为0，那错的可不是一星半点。
代码实现：
def compute_loss(y, y_pred): m = y.shape[0] eps = 1e-15 y_pred = np.clip(y_pred, eps, 1 - eps) loss = -np.mean(y * np.log(y_pred) + (1 - y) * np.log(1 - y_pred)) return lossnp.clip在这里的作用是防止log(0)出现负无穷。理论上预测概率可以是0或1，但数学上log(0)没有定义，加上一个小数eps，让数值稳定，这是工程实现和理论的一个区别。
2.3 梯度下降：参数更新的每一行代码都是什么意思
有了损失函数，下一步就是让损失最小化。这里用到的优化方法是梯度下降，核心思想是沿着梯度的反方向更新参数。对逻辑回归来说，最终梯度公式极其简洁：
dz = ŷ - y dw = 1/m * X^T · dz db = 1/m * Σ dz我见过很多人在这一步卡住，因为他们试图从零开始推导矩阵形式。我的建议是，先看单样本的标量形式：对于一个样本x，梯度是(ŷ - y) * x，这个形式和线性回归的梯度完全一样。然后把所有样本放到矩阵里，用矩阵乘法统一计算。理解了这个“先标量、后矩阵”的思路，梯度下降的代码就没那么吓人了。
参数更新：
w = w - learning_rate * dw b = b - learning_rate * db所谓“学习率”，你可以把它理解成下山时的步幅。步幅太大，可能直接冲过最低点，永远震荡不收敛；步幅太小，下山速度慢，要跑很多轮迭代。这个调参过程放在代码里就是一行赋值，但背后是精度和速度的平衡。我一般从0.1开始试，如果loss不降反升就减小，如果下降太慢就增大，这个技巧写在后面实操部分。
2.4 决策边界与分类阈值：模型到底学到了什么
训练完成之后，模型学到的东西就是一组权重w和偏置b。在二维特征空间中，决策边界是满足w1*x1 + w2*x2 + b = 0的直线。你把这根直线画出来，就能直观看到模型是否把两类数据切分干净了。
阈值默认是0.5，但这个值不是死的。实际业务中，你可能想要高召回率，那就把阈值调低，比如0.3，让更多样本被预测为正类；如果你更看重精确率，阈值可以调到0.7。这就好比体检报告上的某个指标，超过某个值就要复查，但这个“超过多少”可以根据人群特点灵活调整。逻辑回归的另一个名字叫“对数几率回归”，本质上它输出的是对数几率，不只是简单的0/1判断。
3. 手写代码全流程：从数据到可视化的完整Demo
3.1 数据准备：自己构造一份线性可分的二分类数据
为了把决策边界可视化得清清楚楚，我没用现成的库自带数据，而是手动生成100个二维数据点，分为两类。这样数据是自己造的，心里有数，知道真实的决策区域长什么样。
import numpy as np import matplotlib.pyplot as plt np.random.seed(42) # 类别1：中心点大约在(2,2)附近 x1 = np.random.randn(50, 2) + [2, 2] # 类别2：中心点大约在(-2,-2)附近 x0 = np.random.randn(50, 2) + [-2, -2] X = np.vstack([x1, x0]) y = np.hstack([np.ones(50), np.zeros(50)]) # 可视化原始数据 plt.scatter(X[y==1][:, 0], X[y==1][:, 1], label='class 1', alpha=0.7) plt.scatter(X[y==0][:, 0], X[y==0][:, 1], label='class 0', alpha=0.7) plt.legend() plt.show()每次跑这个数据生成，要记得设置随机种子np.random.seed(42)，否则每次生成的数据都不同，后面调参和排查问题的时候会非常头疼。我就是因为没设种子，在调学习率的时候怎么搞都无法复现上一次的loss曲线，白白浪费了半个小时。
3.2 手写LogisticRegression类：把公式变成标准代码结构
我建议把函数包成一个类，虽然对一个Demo来说多写了几行代码，但当你后面要扩展成多分类、加正则化的时候，类的结构会帮你省掉大量重构时间。
class LogisticRegression: def __init__(self, learning_rate=0.1, n_iterations=1000): self.learning_rate = learning_rate self.n_iterations = n_iterations self.w = None self.b = None self.loss_history = [] def _sigmoid(self, z): z = np.clip(z, -500, 500) return 1 / (1 + np.exp(-z)) def fit(self, X, y): m, n = X.shape # 初始化权重为零向量和标量偏置 self.w = np.zeros(n) self.b = 0 for i in range(self.n_iterations): linear_output = np.dot(X, self.w) + self.b y_pred = self._sigmoid(linear_output) # 计算损失并记录 eps = 1e-15 y_pred_clipped = np.clip(y_pred, eps, 1 - eps) loss = -np.mean(y * np.log(y_pred_clipped) + (1 - y) * np.log(1 - y_pred_clipped)) self.loss_history.append(loss) # 梯度计算 dz = y_pred - y dw = (1 / m) * np.dot(X.T, dz) db = (1 / m) * np.sum(dz) # 更新参数 self.w -= self.learning_rate * dw self.b -= self.learning_rate * db def predict_proba(self, X): linear_output = np.dot(X, self.w) + self.b return self._sigmoid(linear_output) def predict(self, X, threshold=0.5): proba = self.predict_proba(X) return (proba >= threshold).astype(int)这个类的重点是fit方法里的梯度计算。把dz = y_pred - y放在最前面，你会发现逻辑回归的梯度公式比线性回归只多了一个sigmoid的处理，其他一模一样。这种代码结构其实是仿照sklearn的接口风格设计的，fit、predict、predict_proba的名字都一致，以后切换到真实框架时毫无障碍。
3.3 训练过程与结果分析：loss曲线会告诉你一切
代码写完了，直接实例化并训练：
model = LogisticRegression(learning_rate=0.1, n_iterations=500) model.fit(X, y) # 绘制损失下降曲线 plt.plot(model.loss_history) plt.xlabel('iteration') plt.ylabel('loss') plt.title('Loss Curve') plt.show()一段靠谱的训练过程，loss曲线应该是一个平滑下降然后趋于平稳的形状。如果loss曲线出现明显的“先跌后涨”，大概率是学习率太大，参数在最低点附近反复横跳；如果loss一直在高位徘徊，大概率是学习率太小，需要加大或增加迭代次数。
我跑这个Demo时的学习率从0.01换成0.1，loss下降速度明显加快，从500轮迭代降到100轮左右就收敛了。但要提醒的是，这只是在当前这份数据上的经验，不同数据集量纲差异很大，学习率的“最优值”没有通用标准。判断收敛与否，看loss曲线是否平坦比看具体轮数更可靠。
训练完成后，打印权重和准确率：
train_pred = model.predict(X) accuracy = np.mean(train_pred == y) print(f"w: {model.w}, b: {model.b}") print(f"训练准确率: {accuracy:.4f}")在构造的线性可分数据上，逻辑回归的准确率应该是1.0或者非常接近1.0，因为数据本身就是两类完美分开的。如果准确率连95%都不到，优先检查是不是特征没有归一化。比如某个特征数值是几千，另一个是零点几，那么梯度更新会被大数值特征主导，模型基本学不到另一个特征的规律。
3.4 决策边界可视化：把模型学到的东西画出来
代码写到这里，很多人会觉得“完了”。但我要说，没把决策边界画出来，这份代码的价值就少了一半。你只有亲眼看到那根分割线，才会真正理解逻辑回归到底做了什么。
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200), np.linspace(y_min, y_max, 200)) grid = np.c_[xx.ravel(), yy.ravel()] proba = model.predict_proba(grid).reshape(xx.shape) plt.contourf(xx, yy, proba, levels=20, cmap='RdBu', alpha=0.6) plt.colorbar() plt.scatter(X[y==1][:, 0], X[y==1][:, 1], label='class 1') plt.scatter(X[y==0][:, 0], X[y==0][:, 1], label='class 0') # 画出概率为0.5的决策边界 plt.contour(xx, yy, proba, levels=[0.5], colors='k', linewidths=2) plt.legend() plt.show()等高线图填充的是模型预测的概率，黑色线是0.5阈值对应的决策边界。你会看到一条斜线把两类数据完美切开，当数据线性可分时，这条边界其实有无数种可能，逻辑回归找的是在交叉熵意义下最优的那一条。如果把两类数据的间距拉近，决策边界就会通过一些“模糊地带”，概率热力图会从红色渐变到蓝色，而不是突然跳变。
这个可视化还有一层深意：它展示了逻辑回归的“线性”本质。无论你给它多复杂的非线性数据，它只能画出一条直线。数据分布是圆形嵌套的，它照样只能硬切一条直线，准确率一定会很差。这个局限性不是代码可以弥补的，除非你手动构造多项式特征，让线性分类器在高维空间作出非线性分割。
3.5 sklearn版本对照：工程上为什么可以“偷懒”
手写版本正确跑通之后，再用sklearn做对照就很轻松了：
from sklearn.linear_model import LogisticRegression as SklearnLR from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) clf = SklearnLR() clf.fit(X_train, y_train) test_pred = clf.predict(X_test) print(f"测试集准确率: {accuracy_score(y_test, test_pred):.4f}") print(f"学到的系数: {clf.coef_}, 截距: {clf.intercept_}")观察到没有，sklearn学到的coef_和我手写版本学到的w应该非常接近，这不仅验证了手写实现的正确性，也说明了一件事：在实际项目中，我们不需要每次都重复实现底层算法，框架帮我们做了优化、正则化、多分类和各种边界处理。
但是，前提是你自己写得出来。写不出来的话，框架只是一个黑盒子，出问题根本不知道从哪排查。这就是我坚持“先手写、再用库”的原因。手写代码的最大收益，是训练阶段每一个数值的含义都清清楚楚，一旦遇到模型不收敛、loss为nan、准确率异常等问题，你能直接定位到是哪一步的数学逻辑出了问题，而不是对着文档干瞪眼。
4. 常见问题与排查技巧实录
4.1 loss为nan或者inf，是哪里出了问题
我在调试这个Demo的过程中遇到的第一个问题，就是loss直接输出nan。排查到最后，定位到是为防止log(0)而加的eps没生效。具体场景是这样的：如果y_pred经过sigmoid后刚好等于0，那么log(y_pred)是负无穷，乘以0（真实标签刚好是0）还会得到一个nan。解决方式是给y_pred做clip，而不是在log之后才处理。
另外一个非常常见的坑是数据溢出：np.exp(-z)在z是很大的负数时会变成一个天文数字，直接给出inf或nan。sigmoid里加np.clip可以解决，但这只是治标。如果要治本，就要做特征标准化，把所有特征缩放到相近的数值区间。我在写代码时把这两种情况都踩了一遍，所以最后给出的示例代码里两处预防都有。如果有人不幸把学习率设成10，梯度更新后参数直接跑到几百，那loss曲线大概率会飞上天，这种情况直接重置参数，从较小学习率开始。
4.2 特征不归一化，模型为什么死活不收敛
这个Demo里我用的数据是randn生成的，均值0、方差1，天然就在一个“不错”的尺度上，所以我没做归一化。但如果你换成真实业务数据，比如一个特征是“年龄”（两位数范围），另一个特征是“月收入”（四到五位数范围），逻辑回归的损失函数等高线会变成一个狭长的椭圆，梯度下降在这个椭圆上走“之”字路线，效率极低。
解决办法很简单，用StandardScaler：
from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test)注意一定要在训练集上fit，再在测试集上transform，千万不能在测试集上重新fit。这个错误很多新手会犯，后果是训练集均值、方差和测试集不一致，相当于测试时数据分布被“污染”了，模型的评估结果全是假的。
4.3 学习率怎么调：我常用的一个笨办法
学习率是逻辑回归最重要的超参数，没有之一。我的调参策略简单粗暴：对数网格搜索。先试0.01，观察loss下降；再试0.1，对比速度；然后0.5和1.0，看哪个会导致loss震荡。经过几轮，你会找到一个“下降最快但还没发散”的值。
有一个特别有用的经验：loss曲线“锯齿状”但不升高，通常是学习率偏大的临界信号。如果锯齿非常大，直接砍到当前值的1/10；如果曲线平滑但低垂，可以放心加到3倍。
这个Demo里0.1是我试出来的合适值，500轮迭代loss从0.69降到接近0.1以下，曲线平滑稳定。换成0.5的时候，loss在前20轮疯狂跳动，之后才慢慢平稳，显然不是最优。调参不要凭感觉，一定要配合可视化。
4.4 类别不平衡怎么办：正负样本1：9的真实场景
逻辑回归在类别不平衡的数据上表现不佳，因为交叉熵损失对所有样本一视同仁，负样本太多会导致模型倾向把所有样本都预测成负类，准确率虚高，但召回率惨不忍睹。
常用解法是对正负样本设置不同的权重。numpy手写版本里，你可以把损失函数每一项乘以类别权重：
weights = np.where(y == 1, 10, 1) # 正类权重设为10 loss = -np.mean(weights * (y * np.log(y_pred_clipped) + (1 - y) * np.log(1 - y_pred_clipped)))sklearn里直接设class_weight='balanced'就行，它会根据样本频率自动计算权重。选择阈值也是一个思路，比如把预测阈值从0.5调到0.3，让更多样本被分为正类，提高召回率，代价是精确率下降。这个取舍没有绝对的对错，只有业务导向的平衡。
4.5 多分类问题：逻辑回归的两种扩展路径
二元逻辑回归写清楚之后，自然有人会问：“三类、五类怎么办？”两条路径：OvR（一对多）和Softmax回归。sklearn默认用的是OvR的变体，它把类别A与剩余所有类别做一次二分类，类别B与剩余所有类别再做一次，最后选出概率最大的那个。Softmax则是把逻辑回归的概率映射扩展到K个类别，用Softmax函数替代sigmoid，决策边界不在是一条线，而是一片区域划分。
我个人的学习路径建议是，先把二分类手写实现吃透，再理解OvR的思路，最后再去碰Softmax的数学推导。一次吃太多反而消化不良。
5. 工程实践中的额外心得
5.1 正则化：逻辑回归过拟合了怎么办
逻辑回归虽然模型结构简单，但在高维特征下同样会过拟合。比如你有100个特征，但只有50个样本，模型完全有机会把训练集“背”下来。解决方案是给损失函数加正则化项，L2正则化会把权重约束在一个较小的范围内。
L2正则化的梯度更新有一个非常优雅的写法，在原有梯度基础上多一项lambda * w / m：
# 在梯度下降里加上L2正则化 dw = (1 / m) * np.dot(X.T, dz) + (regularization_param / m) * self.wsklearn里一行配置搞定：LogisticRegression(penalty='l2', C=1.0)。注意这里的C是正则化强度的倒数，C越小，正则化越强，权重越接近0；C越大，越接近原始逻辑回归。实际项目中我一般优先试C=1.0，然后看验证集表现再决定方向。
5.2 从代码Demo到真实项目的距离
这个Demo适合教学和理解，但距离真实项目还差几步。第一，真实数据通常需要大量特征工程，比如处理缺失值、编码类别变量、构造交叉特征。第二，真实场景中很少只用逻辑回归裸跑，通常要和特征筛选、异常检测配合使用。第三，线上部署时你需要把训练好的权重序列化，比如存成npy、json或者mlflow格式，拿到线上服务里去加载，再对单条样本做预测。
举一个具体的例子：你有一个用户流失预警系统，输入特征是用户的登录频率、消费金额、客服投诉次数等，逻辑回归输出一个流失概率，运营团队根据概率决定是否要做用户召回。这种业务场景下，代码本身可能还是几十行，但数据处理、评估上线、监控报表占了绝大部分工作量。逻辑回归在真实项目中的地位，不是因为它“简单”，而是因为它“可靠”——有清晰的概率解释、训练速度快、不容易过拟合，在中小型数据规模的场景下，依然是首选基线方案。
5.3 下一步可以怎么扩展
这篇文章的手写Demo，我已经把损失曲线和决策边界都画了出来。下一步的扩展方向很多，我简单列几个值得动手的：把数据换成非线性分布，比如同心圆或者月牙形，你立刻就能看到逻辑回归的局限性；加入多项式特征生成器，把二维特征扩展成二次项，看看决策边界能不能变成曲线；改成多分类，比较OvR和Softmax的表现差异；或者干脆调大学习率，观察发散过程，加深对梯度下降的理解。
如果以上这些都做过了，建议去读一下sklearn源码中solver参数的逻辑，了解lbfgs和liblinear的异同，这是从“调包侠”走向“懂原理”的重要一步。
最后分享一个实际经验：如果你在面试或者项目汇报里被问到“为什么选逻辑回归”，最好的回答思路是——因为线性 + 概率输出 + 可解释性强 + 训练高效，先摆出四个优点，再说它的局限（无法处理非线性关系），然后补一句“所以我用特征工程把部分非线性信息抽出来，或者后续用树模型做对比”。这个回答框架直接来自于动手实现一份代码Demo带来的自信，希望你也能亲手跑一遍，体会到那种把公式变成代码的掌控感。
