逻辑回归是二元分类中最流行的机器学习算法之一。这是因为它是一种简单的算法，在广泛的问题上表现都非常好。
在本教程中，您将分步了解用于二元分类的逻辑回归算法。阅读本教程后，您将了解：
- 如何计算逻辑函数。
- 如何使用随机梯度下降学习逻辑回归模型的系数。
- 如何使用逻辑回归模型进行预测。
本教程是为开发人员编写的，不假定您具有统计学或概率论背景。打开电子表格，跟着做。如果您对逻辑回归有任何疑问，请在评论区提问，我将尽力回答。
用我的新书《精通机器学习算法》快速启动您的项目，书中包含分步教程以及所有示例的Excel电子表格文件。
让我们开始吧。
更新于2016年11月：修复了b0更新方程中的一个小拼写错误。
机器学习逻辑回归教程
照片由 Brian Gratwicke 拍摄，保留部分权利。
教程数据集
在本教程中，我们将使用一个人工数据集。
该数据集有两个输入变量（X1 和 X2）和一个输出变量（Y）。输入变量是从高斯分布中提取的实值随机数。输出变量有两个值，这使得该问题成为一个二元分类问题。
原始数据如下所示。
|
1 2 3 4 5 6 7 8 9 10 11 |
X1 X2 Y 2.7810836 2.550537003 0 1.465489372 2.362125076 0 3.396561688 4.400293529 0 1.38807019 1.850220317 0 3.06407232 3.005305973 0 7.627531214 2.759262235 1 5.332441248 2.088626775 1 6.922596716 1.77106367 1 8.675418651 -0.2420686549 1 7.673756466 3.508563011 1 |
下面是数据集的图。您可以看到它是完全人为设定的，我们可以轻松地画一条线来分隔这些类别。
这正是我们将要用逻辑回归模型做的事情。
逻辑回归教程数据集
逻辑函数
在深入研究逻辑回归之前，让我们先看看逻辑函数，它是逻辑回归技术的核心。
逻辑函数定义为：
transformed = 1 / (1 + e^-x)
其中 e 是数值常数欧拉数，x 是我们输入到函数中的值。
让我们输入从 -5 到 +5 的一系列数字，看看逻辑函数如何转换它们。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
X 转换后 -5 0.006692850924 -4 0.01798620996 -3 0.04742587318 -2 0.119202922 -1 0.2689414214 0 0.5 1 0.7310585786 2 0.880797078 3 0.9525741268 4 0.98201379 5 0.9933071491 |
您可以看到所有输入都已转换为 [0, 1] 范围，最小的负数得到接近零的值，较大的正数得到接近一的值。您还可以看到 0 转换到 0.5，即新范围的中点。
由此我们可以看到，只要我们的均值为零，我们就可以将正值和负值输入到函数中，并始终得到一个一致的转换到新范围的值。
逻辑函数
获取您的免费算法思维导图
方便的机器学习算法思维导图样本。
我创建了一份方便的思维导图，其中包含60多种按类型组织的算法。
下载、打印并使用它。
还可以独家访问机器学习算法电子邮件迷你课程。
逻辑回归模型
逻辑回归模型接收实值输入，并预测输入属于默认类别（类别 0）的概率。
如果概率大于 0.5，我们可以将输出作为默认类别（类别 0）的预测，否则预测是其他类别（类别 1）。
对于这个数据集，逻辑回归有三个系数，就像线性回归一样，例如：
output = b0 + b1*x1 + b2*x2
学习算法的任务将是根据训练数据发现系数（b0、b1 和 b2）的最佳值。
与线性回归不同，输出使用逻辑函数转换为概率：
p(class=0) = 1 / (1 + e^(-output))
在您的电子表格中，这可以写成：
p(class=0) = 1 / (1 + EXP(-output))
通过随机梯度下降进行逻辑回归
我们可以使用随机梯度下降来估计系数的值。
这是一个简单的过程，可供许多机器学习算法使用。它通过使用模型为训练集中的每个实例计算预测值，并计算每个预测的误差来工作。
我们可以将随机梯度下降应用于查找逻辑回归模型系数的问题，如下所示：
对于每个训练实例：
- 使用当前系数的值计算预测值。
- 根据预测中的误差计算新的系数。
该过程将重复进行，直到模型足够准确（例如，误差降低到某个期望水平）或进行固定次数的迭代。您将继续更新训练实例的模型并纠正错误，直到模型足够准确或无法进一步改进。为了混合校正，最好随机化显示给模型的训练实例的顺序。
通过为每个训练模式更新模型，我们称之为在线学习。也可以收集所有训练实例对模型的所有更改，然后进行一次大的更新。这种变体被称为批量学习，如果您喜欢冒险，这可能是本教程的一个很好的扩展。
计算预测
让我们从为每个系数分配 0.0 开始，并计算第一个属于类别 0 的训练实例的概率。
B0 = 0.0
B1 = 0.0
B2 = 0.0
第一个训练实例是：x1=2.7810836, x2=2.550537003, Y=0
使用上述方程，我们可以代入所有这些数字并计算预测值。
prediction = 1 / (1 + e^(-(b0 + b1*x1 + b2*x2)))
prediction = 1 / (1 + e^(-(0.0 + 0.0*2.7810836 + 0.0*2.550537003)))
prediction = 0.5
计算新系数
我们可以使用简单的更新方程来计算新的系数。
b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
其中 b 是我们正在更新的系数，prediction 是使用模型进行预测的输出。
Alpha 是您必须在训练开始时指定的参数。这是学习率，它控制每次更新时系数（以及模型）的变化或学习量。在线学习（当我们将模型更新为每个训练实例时）使用较大的学习率。好的值可能在 0.1 到 0.3 的范围内。让我们使用 0.3 的值。
您会注意到方程中的最后一项是 x，这是系数的输入值。您会注意到 B0 没有输入。这个系数通常称为偏差或截距，我们可以假设它始终具有输入值 1.0。这个假设在实现使用向量或数组的算法时很有帮助。
让我们使用上一节的预测值（0.5）和系数（0.0）来更新系数。
b0 = b0 + 0.3 * (0 – 0.5) * 0.5 * (1 – 0.5) * 1.0
b1 = b1 + 0.3 * (0 – 0.5) * 0.5 * (1 – 0.5) * 2.7810836
b2 = b2 + 0.3 * (0 – 0.5) * 0.5 * (1 – 0.5) * 2.550537003
或者
b0 = -0.0375
b1 = -0.104290635
b2 = -0.09564513761
重复过程
我们可以重复此过程，并为数据集中的每个训练实例更新模型。
对训练数据集的一次完整遍历称为一个 epoch。通常会重复随机梯度下降过程一个固定的 epoch 数。
在 epoch 结束时，您可以计算模型的误差值。由于这是一个分类问题，因此在每次迭代时了解模型的准确性将很有用。
下图显示了模型在 10 个 epoch 中的准确率图。
梯度下降逻辑回归准确率与迭代次数
您可以看到模型在训练数据集上非常快速地达到了 100% 的准确率。
随机梯度下降 10 个 epoch 后计算出的系数为：
b0 = -0.4066054641
b1 = 0.8525733164
b2 = -1.104746259
进行预测
现在我们已经训练了模型，我们可以使用它来进行预测。
我们可以对训练数据集进行预测，但这些也可以是新数据。
使用 10 个 epoch 后学到的系数，我们可以为每个训练实例计算输出值。
|
1 2 3 4 5 6 7 8 9 10 |
0.2987569857 0.145951056 0.08533326531 0.2197373144 0.2470590002 0.9547021348 0.8620341908 0.9717729051 0.9992954521 0.905489323 |
这些是每个实例属于类别 0 的概率。我们可以使用以下方法将它们转换为清晰的类别值：
prediction = IF (output < 0.5) Then 0 Else 1
通过这个简单的过程，我们可以将所有输出转换为类别值。
|
1 2 3 4 5 6 7 8 9 10 |
0 0 0 0 0 1 1 1 1 1 |
最后，我们可以计算模型在训练数据集上的准确率。
accuracy = (correct predictions / num predictions made) * 100
accuracy = (10 /10) * 100
accuracy = 100%
总结
在本教程中，您了解了如何从头开始分步实现逻辑回归。您学到了：
- 如何计算逻辑函数。
- 如何使用随机梯度下降学习逻辑回归模型的系数。
- 如何使用逻辑回归模型进行预测。
您对本教程或逻辑回归有任何疑问吗？
请发表评论并提出您的问题，我将尽力回答。
嗨，Jason，
很棒的博客！做得很好。只是好奇如何确定更新方程的形式？在这种情况下，它是 b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x 的形式。我怎么知道它应该是这样的？
谢谢。
实际上我的问题一样。另外，我尝试重现您的示例，但在 10 次迭代后无法获得相同的（b0,b1,b2）。我得到的是（-0.02,0.312,-0.095）。
谢谢你
我也得到了错误的值，但我找到了我的错误。我不知道如何描述，所以我留下了我的代码，它是用 C++ 编写的。它可能对您有帮助。代码在这里：
int k = 0;
for (int j = 0; j < 100; j++) { // 我忘记了这个循环，添加之后我得到了正确的值。
k = 0;
while (k < 10) {
for (int i = 0; i < 3; i++){
b[i] = b[i] + alpha * (y[k] – prediction) * prediction * (1 – prediction)* x[k][i];
cout << b[i]<<"\n";
}
k++;
output = 0;
for (int i = 0; i < 3; i++)
output += b[i] * x[k][i];
prediction = 1 / (1 + exp(-output));
}
}
请把完整的源代码发给我。
嗨，我设法重现了 10 个 epoch 后的相同结果。提供的代码中有一个拼写错误。更新方程
b0 = 0.0 + 0.3 * (0 – 0.5) * 0.5 * (1 – 0.5) * 1.0
应更改为
b0 = b0 + 0.3 * (0 – 0.5) * 0.5 * (1 – 0.5) * 1.0
希望这有帮助 :)
谢谢 Dylan，我已经更新了示例。
这真是一篇很好的文章。
对于数学背景，我参考了
“[2010] GENERATIVE AND DISCRIMINATIVE CLASSIFIERS- NAIVE BAYES AND LOGISTIC REGRESSION – Tom Mitchell”。
我的程序最终学习到的权重是：
[-0.48985449 0.99888324 -1.4328438 ]
我的笔记可以在以下网址找到：
https://j-dhall.github.io/ml/2021/02/22/logistic-regression-for-binary-classification-of-demo-data.html
笔记：https://github.com/j-dhall/ml/blob/gh-pages/notebooks/Logistic%20Regression%20for%20Binary%20Classification%20of%20Demo%20Data.ipynb
感谢分享。
我的问题一样。
似乎权重更新不正确。
旧：b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
新：b = b + alpha * (y – prediction) * x
导数是
http://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html
我从《人工智能：一种现代方法》中引用了方程，而不是一个随机的备忘单。
非常感谢您提供参考。区别在于他们不同的成本函数。书中——《人工智能：一种现代方法》——的公式使用了二次成本函数 (y-h(x))^2。备忘单中的公式使用了交叉熵作为成本函数。
如果用户期望逻辑回归计算类别值 0 和 1，则二次成本函数更有意义。
如果用户期望逻辑回归计算类别概率，则交叉熵函数更有意义。
这非常有趣。谢谢。
顺便说一句。 Geoffrey Hinton 教授在他的 Coursera 课程——《机器学习神经网络》——第 4 讲中介绍 softmax 输出函数的交叉熵时，有以下评论：
•平方误差度量存在一些缺点
– 如果期望输出是 1 而实际输出是 0.00000001
对于逻辑单位来说，几乎没有梯度来修正错误。
– 如果我们试图为互斥的类别分配概率
标签，我们知道输出应该加起来为 1，但我们
剥夺了网络了解这一点的能力。
说得好！
这本书中的损失函数似乎与《统计学习要素》、《维基百科》以及我的常识所告诉我的其他书籍存在冲突。我对此感到惊讶，因为它如此受欢迎。我不会说它是错的，因为它可以用作成本函数，但它产生的結果与别处的“逻辑回归”显然不同，我认为应该在文章中提到。
寻找逻辑回归系数的方法有很多。
这个方程来自将损失计算为 (y – y_hat)^2 并基于此损失函数计算梯度的视角。
Prof Peter Norvig 的著作《人工智能：一种现代方法》第 726 页（第三版）对此进行了说明。
您也可以基于交叉熵损失计算梯度。两者都应该收敛到相同的解。
你好，
我无法重现您第 10 次迭代的向量（b0,b1,b2）值。
您能再解释一下迭代过程吗？
谢谢你
大家好，
在本博客中，它写道，在随机梯度下降的 10 个
epoch 后计算出的系数是
b0 = -0.4066054641
b1 = 0.8525733164
b2 = -1.104746259
根据我的理解，我有一个输入矩阵大小为（3×10，
x1,x2,y1），权重矩阵为（3×10，b0,b1,b2），在 10 个 epoch 后。
我的疑问是，这些学习到的系数是仅针对该
特定的输入向量（例如第一个输入）还是针对所有其他
输入？
1）如果针对单个输入向量，那么在测试使用
上述方法构建的模型时，如何传入任何未见过的输入？每个
输入是否都会通过所有神经元？
2）如果不，如何计算系数？
这篇文章写得非常好，对我的逻辑回归理解帮助很大。非常感谢。
很高兴听到您这么说，Tom。
Jason，解释得非常好！简洁明了，我看了很多 ML 博客。但您的博客总是让我沉迷于您的知识材料。
谢谢 Karthik。
我非常同意。
谢谢！
嗨 Jason，我有一些问题想问您。
[1] 如何绘制分隔这两个类别的直线？我尝试使用“B0”作为 y 轴截距，“B1”作为斜率。我不确定是否是这种情况，因为“B2”被排除在方程之外。
例如
假设分隔线从 (x0,y0) 到 (x1,y1)
**使用 10 个 epoch 后的 B0 和 B1 值**
当 x0 = minX1 = 1.38807 时
y0 = 1.38807(0.85257334) + (-0.40660548) = 0.77682614
当 x1 = maxX1 = 8.675419 时
y1 = 8.675419(0.8527334) + (-0.40660548) = 6.9898252
这条线（1.38807, 0.77682614）到（8.675419,6.9898252）完美地分隔了两个类别，但是当增加 epoch 数时，斜率会发生变化，从而产生假阳性。
有什么想法吗？
提前感谢您的帮助。
嗨 Dylan，我同意你的直觉，回归线最能区分这两个类别。绘制它应该绘制分类器的类别边界，我期望如此。
有可能是额外的训练导致了过拟合，或者在线梯度下降导致了线条的噪声变化。
非常有帮助，解释得很清楚，非常感谢。
您向我解释的逻辑回归算法的主要用途是什么？
好问题，Harish，
逻辑回归用于二元分类问题，最好是我们可以用一条线或超平面来分隔这两个类别。
如果逻辑回归在您的问题上效果很好，请使用它。如果不行，您可能需要转向更高级的方法，甚至是非线性方法。
如果您使用泊松或对数二项回归来模拟二元结果，该方法会有何不同？
1) 计算新系数的目的是什么？我无法理解这些系数在哪里使用？？
2) 如何绘制准确的图表和进行预测的值？
嗨 Harish，系数用于对新数据进行预测。
我们使用系数和输入值的预测方程来预测新数据的类别。
如果我们对测试数据进行预测，然后计算这些预测的误差，那么我们可以绘制每次更新系数时的准确率图。这就是图表创建的方式。
嗨 Jason – 感谢您的文章。它很有帮助，但您能解释一下每个 Epoch 的迭代过程吗？
我没有得到第 10 个 Epoch 的值。您是否正在为每个训练实例移动到相应的 x1、x2 和 Y 值进行预测和计算系数，这一点尚不清楚。例如，我假设第二个训练实例
prediction = 1 / (1 + e^(-(-0.0375 + -1.043*2.7810836 + -0.0956*2.550537003)))
=0.3974
b0 = b0 + 0.3 * (0 – 0.0375) * 0.0375 * (1 – 0.0375) * 1.0
b1 = b1 + 0.3 * (0 – 0.0375) * 0.0375 * (1 – 0.0375) * 1.4655
b2 = b2 + 0.3 * (0 – 0.0375) * 0.5 * (1 – 0.0375) * 2.3621
我重复这个步骤另外 8 次，更新 y、X1 和 X2 值，但它们与您的不匹配。如果您能指出我缺少的东西或发布您每个训练实例的结果，我将不胜感激。
抱歉，预测行应为：
prediction = 1 / (1 + e^(-(-0.0375 + -1.043*1.4655+ -0.0956*2.3621)))
你说得对，但你对一个 epoch 的理解有误。
第一次，我做了和你一样的事情：更新了 b0、b1 和 b2 10 次，但我没有得到预期的结果。
您必须将 b0、b1 和 b2 更新 10 * 10 次。
一个 epoch 是您数据训练的完整一轮。
做你在帖子中做的事情，但重复 10 次，您将获得与教程相同的结果。
我写了一个 C 程序，我在这里发布了代码：
#include
#include
#include
float x1[10] = {2.7810836,
1.465489372,
3.396561688,
1.38807019,
3.06407232,
7.627531214,
5.332441248,
6.922596716,
8.675418651,
7.673756466
};
float x2[10] = {2.550537003,
2.362125076,
4.400293529,
1.850220317,
3.005305973,
2.759262235,
2.088626775,
1.77106367,
-0.2420686549,
3.508563011
};
int y_1[10] = {0,0,0,0,0,1,1,1,1,1};
float b0 = 0.00f;
float b1 = 0.00f;
float b2 = 0.00f;
float b[3];
float prediction = 0;
float output = 0;
int main()
{
int epoch = 0;
float alpha = 0.3;
while (epoch < 10)
{
int i = 0;
while (i < 10)
{
// 计算预测
output = b0 + (b1 * x1[i]) + (b2 * x2[i]);
prediction = 1/(1 + exp(-output));
printf("Prediciton = %lf\n", prediction);
// 改进系数
b0 = b0 + alpha * (y_1[i] – prediction) * prediction * (1 – prediction) * 1.00f;
b1 = b1 + alpha * (y_1[i] – prediction) * prediction * (1 – prediction) * x1[i];
b2 = b2 + alpha * (y_1[i] – prediction) * prediction * (1 – prediction) * x2[i];
printf("New : b0 = %lf | b1 = %lf | b2 = %lf\n\n", b0, b1, b2);
i++;
}
epoch++;
}
int i = 0;
while (i < 10)
{
output = b0 + (b1 * x1[i]) + (b2 * x2[i]);
prediction = 1/(1 + exp(-output));
printf("Prediciton = %lf\n", prediction);
i++;
}
return 0;
}
亲爱的 Jason 和 Alexander，
我尝试在 MATLAB 中执行 C 代码，但结果完全不同！有什么原因吗？
我下面发布了 MATLAB 代码，请注意，每个 epoch 都保存在 prediction(i,j) 数组的列中。
clear all,
X1 = [2.7810836, 1.465489372, 3.396561688, 1.38807019, 3.06407232, 7.627531214, 5.332441248, 6.922596716, 8.675418651, 7.673756466];
X2 = [2.550537003, 2.362125076, 4.400293529, 1.850220317, 3.005305973, 2.759262235, 2.088626775, 1.77106367, -0.2420686549, 3.508563011];
y = [0,0,0,0,0,1,1,1,1,1];
%初始化变量
b0=0;
b1=0;
b2=0;
epochs =10 ; % epochs 数量 ,, 重复多少次才能选出 b0…bn 的最终值
alpha=0.3; % 学习率
prediction=[]; % 一个用于存储每次迭代、每个数据项的预测值的数组
for i = 1:epochs % 外层循环，处理数据集中的每个数据项
for j = 1:length (X1)
pred =(1/(1+ exp (- (b0+ (b1* X1(i)) + (b2*X2(i))))));
b0 = b0 + alpha * (y(i) – pred) * pred* (1 – pred) * 1;
b1 = b1 + alpha * (y(i) – pred) * pred* (1 – pred) * X1(i);
b2 = b2 + alpha * (y(i) – pred) * pred* (1 – pred) * X2(i);
display (b0);
display (b1);
display (b2);
prediction(i,j)=pred;
结束
结束
disp (‘____预测结果是__________’);
for i= 1:length (X1)
pred =(1/(1+ exp (- (b0+ (b1* X1(i)) + (b2*X2(i))))));
disp (pred);
结束
解决了！
我必须将内层循环中的 i 替换为 j
错误部分
pred =(1/(1+ exp (- (b0+ (b1* X1(i)) + (b2*X2(i))))));
b0 = b0 + alpha * (y(i) – pred) * pred* (1 – pred) * 1;
b1 = b1 + alpha * (y(i) – pred) * pred* (1 – pred) * X1(i);
b2 = b2 + alpha * (y(i) – pred) * pred* (1 – pred) * X2(i);
正确部分
pred =(1/(1+ exp (- (b0+ (b1* X1(j)) + (b2*X2(j))))));
b0 = b0 + alpha * (y(j) – pred) * pred * (1 – pred) * 1;
b1 = b1 + alpha * (y(j) – pred) * pred * (1 – pred) * X1(j);
b2 = b2 + alpha * (y(j) – pred) * pred * (1 – pred) * X2(j);
做得好，很高兴听到这个！
也许是不同平台/库之间的精度差异？如果是这样，这是很常见的。
你好 Jack，
是的，这个过程会重复进行，遍历每一个训练示例。前一次迭代输出的系数（b0、b1、b2）将作为下一次迭代的输入。
这有帮助吗？有什么方面我可以进一步说明吗？
我在我的书中提供了完整的示例和电子表格，如果这对您有帮助的话。
嗨，Jason，
谢谢你的分享，这非常有帮助。我只有两个问题。
1. 关于概率的含义，
一开始你说，“如果概率大于0.5，我们可以将输出视为默认类（类0）的预测”；然而，IF语句指出，“预测=如果输出0.5表示实例属于类0。”你能纠正我吗？：)
2. “在epoch结束时，你可以计算模型的误差值”
我们是通过用训练期间最后一个实例获得的系数来测试训练集中的每个实例，并检查正确分类的实例与错误分类的实例的比例来获得模型的误差吗？
谢谢你的帮助。
你好 Ntate，
是的，这里默认类是类1。如果 P > 0.5，则预测类1。
模型通常在训练数据集上进行训练，并在测试或验证数据集上进行评估。
这有帮助吗？
嗨 Jason
谢谢你的反馈。是的，这很有帮助。我喜欢你的文章。
此致，
Ntate
很高兴听到这个消息。
嗨，Jason，
我注意到你将 alpha 设置为 0.3，并提到“好的”值在 0.1-0.3 之间。
b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
你能解释一下为什么 0.1-0.3 之间的范围是好的值吗？另外，还有其他方法来确定 alpha 吗？
此致，
试错是配置 alpha 的最佳方法。
我的建议是基于观察的。
谢谢。它帮助我轻松理解了它
谢谢，听到这个我很高兴。
我有一些分类和有序变量作为自变量。我需要对它们进行标准化才能进行逻辑回归吗？如果需要，使用哪种标准化？
我建议先将分类变量转换为整数编码或独热编码。然后考虑对实值变量进行标准化或归一化。
嗨，Jason，
我希望你能帮我。我刚刚将数据集加载到 pandas 数据框中，并使用本文提供的函数处理了这些值。但不知何故，我没有得到相同的结果。你能告诉我为什么吗？
b0 = 0.0
b1 = 0.0
b2 = 0.0
alpha = 0.3
for i in range(10)
print(‘epoche ‘+str(i))
for j in range(10)
prediction = 1/(1+math.exp(-(b0+b1*df.X1[j]+0*df.X2[j])))
b0 = b0 + alpha*(df.Y[j]-prediction)*prediction*(1-prediction)*1
b1 = b1 + alpha*(df.Y[j]-prediction)*prediction*(1-prediction)*df.X1[j]
b2 = b2 + alpha*(df.Y[j]-prediction)*prediction*(1-prediction)*df.X2[j]
print(j,’b0:’+str(b0),’b1:’+str(b1),’b2:’+str(b2),’prediction:’,str(prediction))
epoche 0
0 b0:-0.0375 b1:-0.104290635 b2:-0.0956451376125 prediction: 0.5
1 b0:-0.0711363539015 b1:-0.153584354155 b2:-0.175098412628 prediction: 0.4525589342855867
2 b0:-0.0956211308566 b1:-0.2367484095 b2:-0.282838618223 prediction: 0.3559937888383731
3 b0:-0.12398808955 b1:-0.276123739244 b2:-0.335323741529 prediction: 0.3955015163005356
4 b0:-0.140423954937 b1:-0.326484419432 b2:-0.384718545948 prediction: 0.27487029790669615
5 b0:-0.122884891209 b1:-0.192704663377 b2:-0.336323669765 prediction: 0.06718893790753155
6 b0:-0.0812720241683 b1:0.0291935052754 b2:-0.24940992148 prediction: 0.24040302936619257
7 b0:-0.0461629882724 b1:0.27223920187 b2:-0.187229583516 prediction: 0.5301690178124752
8 b0:-0.0439592934139 b1:0.291357177347 b2:-0.187763028966 prediction: 0.9101629406368437
9 b0:-0.041234497312 b1:0.312266599052 b2:-0.178202910151 prediction: 0.8995147707414556
epoche 1
0 b0:-0.0854175615843 b1:0.189389803607 b2:-0.290893450483 prediction: 0.6957636219000934
1 b0:-0.126132084903 b1:0.129723102398 b2:-0.387066246971 prediction: 0.5478855806515489
2 b0:-0.168426127803 b1:-0.013931223349 b2:-0.573172450262 prediction: 0.5779785060018552
3 b0:-0.202118039235 b1:-0.0606979612511 b2:-0.635509909311 prediction: 0.4531965138273989
4 b0:-0.231317727075 b1:-0.150167916514 b2:-0.723263905585 prediction: 0.40417453404597653
5 b0:-0.192771357535 b1:0.143845720337 b2:-0.616904363818 prediction: 0.20153497961346012
6 b0:-0.16786327908 b1:0.2766665853 b2:-0.564880684243 prediction: 0.6397495977782179
7 b0:-0.162238550103 b1:0.315604315639 b2:-0.554918931099 prediction: 0.8516230388309892
8 b0:-0.160844460322 b1:0.327698628134 b2:-0.555256396538 prediction: 0.9292852140544192
9 b0:-0.158782126878 b1:0.34352447273 b2:-0.548020569702 prediction: 0.913238571936509
epoche 2
0 b0:-0.203070195453 b1:0.220355651541 b2:-0.660978927394 prediction: 0.6892441807751586
1 b0:-0.242672456027 b1:0.162318959562 b2:-0.754524420162 prediction: 0.5299288459930025
2 b0:-0.284900459421 b1:0.0188889410738 b2:-0.940340030239 prediction: 0.5765566602275273
3 b0:-0.317036444837 b1:-0.0257180623077 b2:-0.999798683361 prediction: 0.45319651382739894
4 b0:-0.346058130501 b1:-0.114642606031 b2:-1.08701772863 prediction: 0.4023126069119149
5 b0:-0.305303900258 b1:0.196211557251 b2:-0.974566120208 prediction: 0.22784879089424026
6 b0:-0.284135730542 b1:0.309089578586 b2:-0.930353714163 prediction: 0.6772107084944106
7 b0:-0.279392082974 b1:0.341927937662 b2:-0.921952412292 prediction: 0.8647793818147672
8 b0:-0.278250718608 b1:0.351829751376 b2:-0.922228700829 prediction: 0.9362537346812636
9 b0:-0.276418730838 b1:0.365887979368 b2:-0.915801056304 prediction: 0.9184600339928451
epoche 3
0 b0:-0.320829240308 b1:0.242378639814 b2:-1.02907170403 prediction: 0.6772464757372858
1 b0:-0.358962425423 b1:0.186494862307 b2:-1.11914705682 prediction: 0.5085926740259167
2 b0:-0.400784178807 b1:0.0444446970373 b2:-1.30317504761 prediction: 0.5681921310493052
3 b0:-0.431106414978 b1:0.00235530491457 b2:-1.35927786503 prediction: 0.4160301017601509
4 b0:-0.459481564543 b1:-0.0845882054421 b2:-1.4445538715 prediction: 0.39558638097213306
5 b0:-0.417358455079 b1:0.236707126821 b2:-1.32832516633 prediction: 0.24886389211209164
6 b0:-0.398407914119 b1:0.337759773107 b2:-1.28874455908 prediction: 0.6994895638042464
7 b0:-0.394265226466 b1:0.36643792905 b2:-1.28140759549 prediction: 0.8743265198068555
8 b0:-0.393309643975 b1:0.374728007212 b2:-1.28163891205 prediction: 0.9418454578963239
9 b0:-0.391663361645 b1:0.387361176894 b2:-1.27586282676 prediction: 0.9228889145563345
epoche 4
0 b0:-0.436106966113 b1:0.26375979738 b2:-1.38921788451 prediction: 0.6649919679911412
1 b0:-0.472655267001 b1:0.210198650866 b2:-1.47554954252 prediction: 0.4876100903262518
2 b0:-0.514052259808 b1:0.0695912110969 b2:-1.65770846209 prediction: 0.5600333525763922
3 b0:-0.542575863527 b1:0.029998447064 b2:-1.7104834132 prediction: 0.39712596044478815
4 b0:-0.570332853627 b1:-0.0550509779888 b2:-1.79390166134 prediction: 0.38920422454205744
5 b0:-0.52713220805 b1:0.274463294611 b2:-1.67469975148 prediction: 0.2708654841988902
6 b0:-0.510039576896 b1:0.365608746016 b2:-1.63899962439 prediction: 0.7183774008591356
7 b0:-0.506411991601 b1:0.390721056064 b2:-1.63257493987 prediction: 0.8829763460926162
8 b0:-0.505614321279 b1:0.397641180051 b2:-1.63276803085 prediction: 0.9470125245639989
9 b0:-0.504143617348 b1:0.408927003853 b2:-1.62760797344 prediction: 0.9272899884165315
epoche 5
0 b0:-0.548534355846 b1:0.285472649024 b2:-1.74082819456 prediction: 0.6531957979683319
1 b0:-0.583448848755 b1:0.234305830737 b2:-1.82330059378 prediction: 0.4675015748559041
2 b0:-0.624452043388 b1:0.095035950763 b2:-2.00372668579 prediction: 0.5528976488885597
3 b0:-0.651241447361 b1:0.0578503777005 b2:-2.0532929853 prediction: 0.379296457131698
4 b0:-0.678459443818 b1:-0.0255475318494 b2:-2.13509139263 prediction: 0.38367378819364967
5 b0:-0.634483421462 b1:0.309880951336 b2:-2.0137500149 prediction: 0.29456310937959235
6 b0:-0.618957686991 b1:0.392671018235 b2:-1.98132255018 prediction: 0.734570858647913
7 b0:-0.615773112207 b1:0.414716545178 b2:-1.97568246547 prediction: 0.8908395402598338
8 b0:-0.615108589413 b1:0.420481558613 b2:-1.97584332561 prediction: 0.9517573456578646
9 b0:-0.613801104729 b1:0.430514877661 b2:-1.97125593321 prediction: 0.9316021522525871
epoche 6
0 b0:-0.658065683935 b1:0.307411382371 b2:-2.0841543804 prediction: 0.6418716134977803
1 b0:-0.691328362642 b1:0.258665280242 b2:-2.16272498787 prediction: 0.4482960919573821
2 b0:-0.731971685172 b1:0.120617728064 b2:-2.34156753699 prediction: 0.5466747645320021
3 b0:-0.757102763343 b1:0.0857340276128 b2:-2.38806556841 prediction: 0.3624963002614126
4 b0:-0.783848933768 b1:0.00378182714664 b2:-2.46844599415 prediction: 0.3788558237431147
5 b0:-0.739460741679 b1:0.342354147839 b2:-2.34596733203 prediction: 0.3197321661982434
6 b0:-0.725177602262 b1:0.418518149617 b2:-2.31613518462 prediction: 0.747650886073883
7 b0:-0.722359808144 b1:0.438024601926 b2:-2.31114469182 prediction: 0.8977118003459105
8 b0:-0.721803648551 b1:0.442849519233 b2:-2.31127932063 prediction: 0.9559629146792477
9 b0:-0.72064049539 b1:0.451775273321 b2:-2.30719832447 prediction: 0.935626585073733
epoche 7
0 b0:-0.764713491327 b1:0.329204587117 b2:-2.41960813144 prediction: 0.630831196571219
1 b0:-0.796322040457 b1:0.282882594302 b2:-2.49427147796 prediction: 0.4298979150158073
2 b0:-0.836626296602 b1:0.145986702019 b2:-2.67162203546 prediction: 0.54103403758093
3 b0:-0.86017519983 b1:0.113299171441 b2:-2.71519269466 prediction: 0.34660715971969225
4 b0:-0.886491802455 b1:0.0326631977814 b2:-2.79428213772 prediction: 0.37448622204910614
5 b0:-0.842093735283 b1:0.371310840978 b2:-2.67177622766 prediction: 0.34584531374424465
6 b0:-0.828710920588 b1:0.442673914071 b2:-2.64382452257 prediction: 0.7572937776171192
7 b0:-0.826182553165 b1:0.460176782093 b2:-2.63934662288 prediction: 0.9034135590263473
8 b0:-0.825711234308 b1:0.464265670495 b2:-2.6394607144 prediction: 0.9595362539490104
9 b0:-0.82466874439 b1:0.472265484239 b2:-2.63580307284 prediction: 0.9391721159610058
epoche 8
0 b0:-0.868485382532 b1:0.350407750494 b2:-2.74755902977 prediction: 0.6198098107703024
1 b0:-0.898445083971 b1:0.306502126447 b2:-2.8183275918 prediction: 0.4121785664149056
2 b0:-0.938410924898 b1:0.170755682328 b2:-2.99418902301 prediction: 0.535591774903723
3 b0:-0.960450226361 b1:0.140163584958 b2:-3.03496658635 prediction: 0.3315041073863981
4 b0:-0.986352835601 b1:0.0607961169703 b2:-3.11281185262 prediction: 0.37028861216547454
5 b0:-0.942344793064 b1:0.396468835092 b2:-2.99138212281 prediction: 0.37223779515431543
6 b0:-0.92953081713 b1:0.464798608913 b2:-2.96461850958 prediction: 0.7634705770276337
7 b0:-0.927219758977 b1:0.480797132495 b2:-2.96052547844 prediction: 0.9078852161314516
8 b0:-0.926812709449 b1:0.484328457556 b2:-2.96062401238 prediction: 0.9624531770487973
9 b0:-0.925865930278 b1:0.491593810342 b2:-2.957302178 prediction: 0.9421224630749467
epoche 9
0 b0:-0.96935657639 b1:0.370642687688 b2:-3.06822668019 prediction: 0.6085681683087178
1 b0:-0.997678784367 b1:0.329136792905 b2:-3.13512727786 prediction: 0.39503800634778957
2 b0:-1.03728747577 b1:0.19460342917 b2:-3.30941714634 prediction: 0.53002748178722
3 b0:-1.05788693505 b1:0.166009933818 b2:-3.34753068441 prediction: 0.3170928534429609
4 b0:-1.08336985067 b1:0.087928437422 b2:-3.42411464294 prediction: 0.3660452797076954
5 b0:-1.0401081702 b1:0.417908255596 b2:-3.30474432179 prediction: 0.39826657846895
6 b0:-1.02756606041 b1:0.484788319168 b2:-3.27854853547 prediction: 0.7664481691662279
7 b0:-1.0254106916 b1:0.499709068196 b2:-3.27473124008 prediction: 0.9112042239475246
8 b0:-1.02505131574 b1:0.502826804247 b2:-3.27481823372 prediction: 0.9647626216394803
9 b0:-1.02417732025 b1:0.509533632813 b2:-3.27175176546 prediction: 0.9444604863065394
我自己解决了。
错误：prediction = 1/(1+math.exp(-(b0+b1*df.X1[j]+0*df.X2[j])))
信息：0 = b2
更正：prediction = 1/(1+math.exp(-(b0+b1*df.X1[j]+b2*df.X2[j])))
感谢这篇很棒的文章。
很高兴听到这个，Robert。
机器学习算法是随机的，在不同平台上运行时结果会有所不同，即使随机种子固定有时也是如此。
请看这篇文章
https://machinelearning.org.cn/randomness-in-machine-learning/
我看到所有的逻辑回归都有如下的权重更新公式
wj:=wj+η∑i=1n(y(i)−ϕ(z(i)))x(i
但在本文中，我们有这个公式
b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
这两个公式有什么区别？
首先，非常感谢您的博客。这真的帮助我理解了回归是什么以及如何工作，这是我的论文主题。我还有一些关于如何预测新数据（新 x1 和新 x2）的类别（0 或 1）的信息。请您能否提供一些预测新数据的类别值的样本计算，通过学习训练和验证数据集。提前非常感谢。
将每个权重/系数乘以输入值，然后将值相加即可得到预测。
嗨，Jason，
只是想感谢你提供的精彩教程！
现在我清楚地理解了如何在机器学习中实现逻辑回归。
我已将您的文章分享到我的 Facebook 🙂
谢谢！
写了一个使用 Scala 的版本，希望对某人有所帮助。
package com.learn
object LogisticRegression {
def main(args: Array[String]): Unit = {
val input = Array(
(2.7810836, 2.550537003),
(1.465489372, 2.362125076),
(3.396561688, 4.400293529),
(1.38807019, 1.850220317),
(3.06407232, 3.005305973),
(7.627531214, 2.759262235),
(5.332441248, 2.088626775),
(6.922596716, 1.77106367),
(8.675418651, -0.2420686549),
(7.673756466, 3.508563011))
val output: Array[Double] = Array(0, 0, 0, 0, 0, 1, 1, 1, 1, 1)
val b: (Double, Double, Double) = (0, 0, 0)
val (b0, b1, b2) = getCoefficients(input, output, b, 0.3, 10)
}
def getCoefficients(
input: Array[(Double, Double)],
output: Array[Double],
b: (Double, Double, Double),
alpha: Double,
iterationCount: Int): (Double, Double, Double) = {
var remainingIterationCount = iterationCount
var b0 = b._1
var b1 = b._2
var b2 = b._3
while(remainingIterationCount > 0) {
remainingIterationCount -= 1
for(((x1, x2), y) <- input zip output) {
val prediction = getPrediction(b0, b1, b2, x1, x2)
b0 = getNextB(b0, 1, y, prediction, alpha)
b1 = getNextB(b1, x1, y, prediction, alpha)
b2 = getNextB(b2, x2, y, prediction, alpha)
}
println(s"b0: $b0, b1: $b1, b2: $b2")
println(s"accuracy: ${getAccuracy((b0, b1, b2), input, output)}")
}
(b0, b1, b2)
}
private def getPrediction(b0: Double, b1: Double, b2: Double, x1: Double, x2: Double): Double = {
1.0 / (1 + Math.exp(-1 * (b1 * x1 + b2 * x2)))
}
private def getNextB(b: Double, x: Double, y: Double, prediction: Double, alpha: Double): Double = {
b + alpha * (y – prediction) * prediction * (1 – prediction) * x
}
private def getAccuracy(b: (Double, Double, Double), input: Array[(Double, Double)], output: Array[Double]): Double = {
var correctOutputCount = 0
for(((x1, x2), y) <- input zip output) {
val output = if(getPrediction(b._1, b._2, b._3, x1, x2) < 0.5) 0 else 1
if(output == y) correctOutputCount += 1
}
correctOutputCount * 1.0 / input.length
}
}
非常酷，谢谢分享 Searene！
这篇教程很棒。我只是想知道我是否可以通过应用元启发式算法（粒子群优化、布谷鸟搜索算法）而不是梯度下降来学习逻辑回归的系数，从而获得最优值。您对此有何看法？
也许不是最优的，但也许是改进的。
这将是比随机搜索或网格搜索更进一步的步骤，并且仅在您拥有资源的情况下才适用。
感谢您的见解。
您正在使用什么软件进行分析？
R 是数据分析的绝佳工具
https://machinelearning.org.cn/start-here/#r
你做得很好。谢谢
谢谢。
你好，先生，
如何将逻辑回归用于机器学习。
如何计算简单的逻辑回归用于机器学习
上面的教程有帮助吗？
你好。如果我的值从 1-24（X 轴）开始，并且随着值增加到 24，Y 轴增加到 1，这是否是相同的概念？我尝试这样做，但结果很奇怪。您可以在此处查看我的帖子
https://stats.stackexchange.com/questions/325101/error-in-calculating-the-logistic-regression-using-sgd
抱歉，我不明白。
我的意思是，如果我的数据包含从 1 到 24 的数字（代表 X 轴），而 1-12 的数字是 0，而 13-24 的数字是 1，那么我会使用相同的概念来计算此模型的 sgd 吗？
我看不到问题。
上面，Dylan 问了如何获得分隔两个数据集的直线。这是一种方法，也可以让我们深入了解逻辑回归方法。
想象一下分隔示例中两个点集的直线。这就是判别线。如果一个点位于直线上，那么它属于一个集合的概率与它属于另一个集合的概率相同，即如果它位于判别线上，那么它属于任一集合的概率为 0.5。
从 Logit 函数可以看出，当分母中的指数为零时，它值为 0.5，即当
B0 +B1*X1+B2*X2 为零时。
我们有 B0、B1 和 B2 的值，并且有两个未知数，即判别线的斜率和截距。我们只需代入几个方便的 X1 值，计算相应的 X2，然后使用一年级的代数来计算该直线的方程。为此使用 X1=0 和 X1=1 是方便的。如果我们进行符号运算，我们会发现 X2 截距为
-B0/B2
斜率为
-B1/B2。
因此，对于十个 epoch 结果给出的值，判别线的方程为
x2 = 0.7718*X1 – 0.348
如果您查看图表并关联点与逻辑回归模型中它们对应的“预测值”，您会发现更接近判别线的点比离得远的点的“预测值”更接近 0.5，这很合理。
感谢分享。
你好 Jason，我想问一下 Y 的值是多少？是假设它的值为 0 还是其他的？
抱歉，我不明白。你的意思是什么？
第一个预测线是否总是系数初始化为 0？如何猜测一个不是从 0初始化的模型？
对于 SGD，从 0 或小的随机数开始是一个不错的选择。
你具体指的是什么？
如果一个学生英语成绩大于 40 分被归类为 1 类，否则为 0 类，如何使用逻辑回归来实现这个问题的代码？
也许可以先清晰地定义你的问题。
https://machinelearning.org.cn/how-to-define-your-machine-learning-problem/
嗨，Jason，
我用 Java 编写了逻辑回归算法。对于 10 条记录中的 9 条，我得到了正确的输出。但对于第 6 条记录，我得到的输出是 0 而不是 1。代码如下：
干得好！
嗨 Priyanka，
你能解释一下这对于多输入的情况是如何工作的吗？
例如：你能用泰坦尼克号数据集解释一下这个吗？
您好，我正在 Rapid Miner 中使用逻辑回归模型。我尝试提高逻辑回归模型的准确性但失败了。您能否建议任何步骤或方法来提高准确性（在混淆矩阵中）？
我在这里有一系列建议。
https://machinelearning.org.cn/machine-learning-performance-improvement-cheat-sheet/
你好
我正在对一个处理客户流失预测的分类问题实现逻辑回归模型。最终的预测器指示客户是否会流失，用“是”或“否”表示。对于这样一个已经预测“是”或“否”但不会给出概率的逻辑回归模型，我该如何找到阈值？
该模型实际上是概率，解释为标签。你可以直接使用这些概率。
如何用逻辑回归对评论文本进行分类？
如何计算权重和偏差？
请回复我。
使用这个类。
https://scikit-learn.cn/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
请用逻辑回归对这个例子进行分类（不写代码）。
Chinese Beijing Chinese, yes
Chinese Chinese Shanghai, yes
Chinese Macao, yes
Tokyo Japan Chinese, no
Chinese Chinese Chinese Tokyo Japan, ?
抱歉，我没有能力为您准备一个自定义的示例。
很棒的博客！
非常感谢。
谢谢，我很高兴这能有所帮助。
我喜欢你的博客。
谢谢！
你好，我喜欢你的工作。
我无法理解这个过程。
我试着重复了这个过程，一开始还可以，但输出和你不一样。
这是我的表格：
干得好！
也许可以仔细检查一下每个元素的计算？
我也得到了和 Claret 相同的值，我该如何得到你的值……我也多次检查了我的计算……请处理。
也许你会觉得这个教程有帮助。
https://machinelearning.org.cn/implement-logistic-regression-stochastic-gradient-descent-scratch-python/
非常感谢Jason。
我只是使用了你的数据，并在 R 中尝试了 glm 命令，家庭为二项式。
我收到一条警告信息，如下所示：
警告信息
glm.fit: 拟合概率数值上为 0 或 1
summary(mylogit)
调用
glm(formula = Y ~ X1 + X2, family = “binomial”, data = Logi)
偏差残差
最小值 1Q 中位数 3Q 最大值
-1.292e-05 -2.110e-08 0.000e+00 2.110e-08 1.623e-05
系数
估计值 标准误差 z 值 Pr(>|z|)
(Intercept) -37.18 797468.21 0 1
X1 15.87 62778.64 0 1
X2 -11.83 235792.12 0 1
(二项式族的分散参数取为 1)
零偏差：1.3863e+01，自由度为 9
残差偏差：4.9893e-10，自由度为 7
AIC：6
然后我将一个 Y 值从 0 改为 1，它就工作了（当然，不是和你一样的数值）。
我只是好奇为什么第一次没有成功。非常感谢任何帮助。谢谢！
我不确定，也许这取决于数据集中的具体数据？
你好 Jason，逻辑回归中的分离超平面是否保证像 SVM 那样是最优的？
是的，在最大似然的框架下。
但它是基于具体数据的，在我看来，与实际结果相比，这样的说法意义不大。
感谢您的回复 Jason。所以，如果用最大似然法，逻辑回归是否比 SVM 更好，因为它不需要支持向量，所以训练和预测都会更快？请在此提供帮助。
我不确定你的推理。抱歉。
Jason Brownlee 的精彩博客！
我有一个疑问。我有一个训练数据集，我将使用逻辑回归来训练模型，但如何将训练好的模型用于测试数据集？
好问题。我在 [这里](https://machinelearning.org.cn/logistic-regression-tutorial-for-machine-learning/) 回答了。
https://machinelearning.org.cn/faq/single-faq/how-do-i-make-predictions
非常感谢您，老师，我明白了！
还有一个问题。epoch 是否应该等于训练集的数量？就像上面的例子中是 10。
不，将 epoch 设置为一个较大的值，并在没有进一步改进时停止训练。
非常感谢，非常有帮助！
不客气。
scikit-learn 中使用的 ‘c’ 和学习率之间是否存在关系？
我不认为 sklearn 使用 SGD 来实现线性回归。
我认为使用的是线性代数解决方案，例如 [这里](https://www.youtube.com/watch?v=d_iX3575E1Q) 描述的那种。
https://machinelearning.org.cn/solve-linear-regression-using-linear-algebra/
尊敬的 Jason Brownlee 机器学习大师：
非常感谢您的精彩著作。您在写作和以易于理解的方式解释事物方面做得非常出色。
我请求您对以下关于参数 alpha/学习率和 x/截距的方程做一点解释。如果可能的话，对整个方程进行深入分析。
旧：b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
需要更详细的解释，为什么我们选择 alpha 值在 0.1 到 0.3 之间，以及截距 x 为 1.0。
还有一项请求，我想在我的学术活动教育视频制作中使用您的博客。请您允许。我一定会在我的每个视频中注明您的博客。
期待您的回复。
谢谢。
特定的值对于示例来说是任意的。
在使用梯度下降优化逻辑回归时，测试不同的 alpha 值可能是一个好主意。
请不要从我的博客文章中制作视频。
亲爱的 Jason,
祝贺您的博客写得好，我惊叹于您是如何简化事物并持续回复博客评论的。做得好！
既然我已经沉迷于您的博客，我接着在这里看了您关于 SGD 的帖子
https://machinelearning.org.cn/gradient-descent-for-machine-learning/
我有三个小问题，希望能得到您的时间解答
1- 您能澄清一下吗？
“GD 的一个变种叫做 SGD。在这个变种中，运行上述的梯度下降过程，但更新系数是为每个训练实例执行的，而不是在实例批次结束时。”
2- 同一篇帖子中的另一个步骤
“该过程的第一步要求随机化训练数据集的顺序。这是为了混合更新系数的顺序。”
我们是否假设上面的教程已经对数据集进行了随机化处理？
此外，如果我们有无序的实例，那么随机化已随机化的实例的意义何在？
3- 到目前为止，我所知道的是 GD 和 SGD 之间的区别是 SGD 采用数据集的多个样本并使用这些样本拟合模型，而 GD 则遍历整个数据集，对每个条目更新系数。
如果上述句子是有效的，那么上面的 10 个条目数据集是否应该（部分）用于拟合模型？或者我们称之为使用梯度下降的逻辑回归？
谢谢。
批次意味着在 epoch 结束时更新，在线意味着在每个样本后更新。有时在线被称为 SGD。有时 SGD 指的是通用方法，无论更新过程如何。
在每个 epoch 之前洗牌训练集是一个好主意。随机顺序确保我们每次迭代都以不同的顺序获得权重更新 - 避免在最坏情况下陷入停滞和权重振荡。
这或许能给你更多想法。
https://machinelearning.org.cn/learning-rate-for-deep-learning-neural-networks/
Brownlee 博士，非常感谢您的精彩教程！
感谢分享。
您有完整的 C 或 C++ 工作程序吗？
抱歉，我没有 C 或 cpp 的示例。
你好 Jason，
请原谅我的无知，我对此还比较新，有点困惑，
那么我们在这里使用随机梯度下降来估计系数 (b0 –bn) 的值吗？
那么最大似然估计呢？
SGD 是最大似然估计的一部分吗？或者这是另一种替代方法？
不，我们正在“进行 MLE”。SGD 提供了一种（效率不高）遍历 MLE 搜索空间的方法。
更有效的方法是使用二次优化算法，例如 sklearn 实现的那种。
–Jason，
感谢您关于线性逻辑回归的清晰教程。
我有一个问题。当我输入教程中的数据
X1 X2 Y
2.7810836 2.550537003 0
1.465489372 2.362125076 0
……
在 https://statpages.info/logistic.html
与您教程中的值相比，我们得到的 beta 值差异很大
变量 系数 StdErr p O.R. Low — High
1 13.308016029.9345 0.9993 01984.5565 0.0000
2 -12.583472148.4146 0.9999 0.0000 0.0000
截距 -24.868530306.4324 0.9999
任何解释都将非常感谢。
谢谢
不客气。
是的，这里我们使用一种效率不高的优化算法——sgd 来解决。
–Jason，
您的意思是，一种方法（您的教程）得到的结果
b0 = -0.4066054641
b1 = 0.8525733164
b2 = -1.104746259
而另一种方法（https://statpages.info/logistic.html）
截距 (b0) = -24.87
b1 = 13.31
b2 = -12.58
谢谢。
–Sam
为了学习目的，当然可以。
布朗利博士您好，
做得好，这个教程对我帮助很大！
我的问题是
查看系数更新公式（b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x），我想知道这是否与 sklearn 使用的相同？如果不是，您能否重点说明是哪一个？
另外，这就是他们所说的 L1 和 L2 正则化吗？
如果您能推荐一个参考资料，将对我帮助很大。
谢谢
最大值
谢谢 Maxi。
不，他们使用更高级的优化算法来拟合模型。
我推荐任何一本好的机器学习教科书。
https://machinelearning.org.cn/faq/single-faq/what-other-machine-learning-books-do-you-recommend
嗨！
我是机器学习新手，发现您的帖子非常有帮助！它比我导师给的公式更容易理解。
您应该更清楚地说明，步骤 1 和 2 在我们拥有的这个小型数据集上必须重复 10 次！
谢谢。
嗨，Jason，
这确实是一篇很棒的帖子！
您能否帮助我理解，
b = b + alpha * (y – prediction) * prediction * (1 – prediction) * x
这种方法是否适用于调整所有线性模型（如逻辑回归）的系数，如果不适用，如何为非线性和其他复杂模型进行调整。
另外，如何最好地估计 alpha 以及有哪些方法可以调整它。
谢谢。
是的，您可以使用此更新方程来训练逻辑模型。
测试不同的 alpha 值。
嗨，Jason，
如果我的自变量是分类类型，意味着只有 1 或 0（是或否），那么可以使用此方法计算系数吗？
我目前有 4 个自变量，其中 3 个是分类的，另一个是连续的。
您可以这样做，但该方法确实假定输入是实数值。请尝试一下，并与其他方法进行比较。
嗨，Jason，
在进行了多少次 b0、b1、b2 的迭代后我们应该停止？
另外，我们如何通过将 b0、b1、b2 代入变换方程并与实际结果进行比较来检查特定 b0、b1、b2 的准确性？我在这方面有点困惑。
当训练数据集或保留数据集上的误差停止改进时。
写得很好，如何在 Python 中实现 GLM？有什么资源吗？
抱歉，手头没有。
嗨，杰森，
您能否在 Excel 表格中解释 10 个 epoch 来获取值？
b0 = -0.4066054641
b1 = 0.8525733164
b2 = -1.104746259
我试过了，但得到的数值不同。
请帮忙处理一下……
是的，Excel 表格随本书提供。
https://machinelearning.org.cn/master-machine-learning-algorithms/
Jason 你好，我看到了您的回复“当训练数据集或保留数据集上的误差停止改进时”
您能否解释一下我们应该如何计算“误差”？
对于这个模型，将是用于训练模型的对数损失（交叉熵）。
https://machinelearning.org.cn/cross-entropy-for-machine-learning/
你好 Jason，
我刚跟着代码操作，并且成功加载了。
如何为这些数据集绘制边界线？
谢谢您
好问题，这可能会有帮助
https://machinelearning.org.cn/plot-a-decision-surface-for-machine-learning/
嗨，Jason，
感谢您的清晰解释。在使用随机梯度下降时，有什么方法可以检测过拟合吗？
此致
alaaddin
你好 Alaaddin… 下面的资源可能会让你感兴趣
https://machinelearning.org.cn/overfitting-machine-learning-models/
非常感谢
你好 Jason，
感谢这篇文章。
请问，您能演示一下如何使用遗传算法而不是梯度下降来最大化逻辑回归模型的系数吗？
非常感谢。
你好 Ridwan… 下面的内容可能会让你感兴趣
https://machinelearning.org.cn/simple-genetic-algorithm-from-scratch-in-python/