逻辑回归—已解释
详细的理论解释和 scikit-learn 示例
逻辑回归是一种监督学习算法，主要用于二元分类问题。虽然“回归”与“分类”相矛盾，但这里的重点是“逻辑”一词，指的是在该算法中执行分类任务的逻辑函数。逻辑回归是一种简单但非常有效的分类算法，因此它通常用于许多二元分类任务。客户流失、垃圾邮件、网站或广告点击预测是逻辑回归提供强大解决方案的一些领域的例子。
逻辑回归的基础是逻辑函数，也称为 sigmoid 函数，它接受任何实数值并将其映射到 0 到 1 之间的值。
逻辑回归模型将线性方程作为输入，并使用逻辑函数和对数比值来执行二元分类任务。在详细讨论逻辑回归之前，最好先回顾一下范围概率中的一些概念。
概率
概率衡量事件发生的可能性。例如，如果我们说“此电子邮件有 90%的可能性是垃圾邮件”:
Odds 是正类和负类的概率之比。
对数赔率是赔率的对数。
概率 vs 赔率 vs 对数赔率
所有这些概念本质上代表相同的度量，但方式不同。在逻辑回归的情况下，使用对数优势。我们将看到为什么对数概率在逻辑回归算法中是首选的原因。
概率为 0.5 意味着该电子邮件是垃圾邮件还是非垃圾邮件的几率相等。请注意，概率为 0，5 的对数赔率为 0 。我们将利用这一点。
让我们回到 sigmoid 函数，用不同的方式展示它:
取两侧的自然对数:
在等式(1)中，我们可以使用线性等式 z 来代替 x:
那么等式(1)变成:
假设 y 是正类的概率。如果 z 是 0，那么 y 是 0，5。对于 z 的正值，y 大于 0.5，对于 z 的负值，y 小于 0.5。如果正类的概率大于 0，5(即大于 50%的几率)，我们可以预测结果为正类(1)。否则，结果是一个负类(0)。
注意:在二进制分类中，有许多方法来表示两个类别，如正/负、1/0、真/假。
下表显示了一些 z 值和相应的 y(概率)值。所有实数都映射在 0 和 1 之间。
如果我们画出这个函数，我们将得到著名的逻辑回归 s 形图:
分类问题归结为求解一个线性方程:
函数的参数在训练阶段用最大似然估计算法确定。然后，对于任意给定的自变量(x1，… xn)的值，可以计算出正类的概率。
我们可以“原样”使用计算出的概率。例如，输出可以是电子邮件是垃圾邮件的概率是 95%,或者客户将点击该广告的概率是 70%。然而，在大多数情况下，概率被用来分类数据点。如果概率大于 50%，则预测为正类(1)。否则，预测为负类(0)。
到目前为止，除了一个问题，一切似乎都很好。并不总是希望为所有高于 50%的概率值选择正类。关于垃圾邮件的情况，为了将一封邮件归类为垃圾邮件，我们必须几乎确定。由于被检测为垃圾邮件的电子邮件会直接进入垃圾邮件文件夹，我们不希望用户错过重要的电子邮件。除非我们几乎确定，否则电子邮件不会被归类为垃圾邮件。另一方面，当健康相关问题的分类需要我们更加敏感时。即使我们有点怀疑一个细胞是恶性的，我们也不想错过它。因此，作为正类和负类之间的阈值的值取决于问题。好的一面是，逻辑回归允许我们调整这个阈值。
如果我们设置一个高阈值(即 95%)，几乎所有我们做出的预测都是正确的。然而，我们会错过一些积极的类，并将其标记为消极的。
如果我们设置一个低阈值(即 30%)，我们将正确地预测几乎所有的正类。但是，我们会将一些负面类归类为正面类。
这两种情况都会影响我们模型的准确性。测量精度的最简单方法是:
然而，这通常不足以评估分类模型。在一些二元分类任务中，正类和负类之间存在不平衡。想想把肿瘤分为恶性和良性。数据集中的大多数目标值(肿瘤)将为 0(良性)，因为与良性肿瘤相比，恶性肿瘤非常罕见。典型集合将包括 90%以上的良性(0)类。所以如果模型不做任何计算就把所有的例子都预测为 0，准确率在 90%以上。这听起来不错，但在这种情况下没有用。因此，我们需要其他方法来评估分类模型。这些措施是精确和召回。
精度和召回
首先，我们需要定义一些术语:
真阳性:正确预测阳性(1)类
假阳性:将阴性(0)类预测为阳性
真阴性:正确预测阴性(0)类
假阴性:将阳性类(0)预测为阴性
真实值与预测值
需要进行 TP 或 TN 预测，因此模型旨在最大化 TP 和 TN 值。
Precision 衡量当预测为正时，我们的模型有多好。
回忆测量我们的模型在正确预测正类方面有多好。
我们不能试图同时最大化精确度和召回率，因为它们之间有一个平衡。下图清楚地解释了这种权衡:
精确度和召回率之间的权衡
在这两个表中，有 8 个负(0)类和 11 个正(1)类。模型的预测以及精度和召回率根据阈值而变化。精度和召回值的计算如下:
提高精度会降低召回率，反之亦然。根据任务的不同，你的目标可以是最大限度地提高精确度或召回率。对于垃圾邮件检测模型，我们试图最大限度地提高精确度，因为我们希望在电子邮件被检测为垃圾邮件时是正确的。我们不想将一封普通的电子邮件标记为垃圾邮件(即误报)。如果假阳性低，则精度高。
还有另一种将精确度和召回率结合成一个数字的方法: **F1_score。**精度和召回率的加权平均值，计算公式如下:
对于类分布不均匀的问题，F1_score 是比准确性更有用的度量，因为它同时考虑了假阳性和假阴性。
注: L2 正则化默认用于 logistic 回归模型(如岭回归)。正则化由 C 参数控制。由于这种正则化，对逻辑回归模型中的特征(独立变量)进行正则化非常重要。
Scikit-learn 实现
我将使用 scikit-learn 的 datasets 模块下的一个数据集。我将导入数据集和依赖项:
然后加载数据集，并分成训练集和测试集:
创建一个逻辑回归对象，并为其拟合训练数据。
然后预测测试数据集中的目标变量:
Scikit-learn 提供了 classification_report 函数，可以同时计算精度、召回率和 f1-score。它还在支持列中显示了积极类和消极类的数量。
值得注意的是，与这个非常简单的例子相比，现实生活项目中的数据准备、模型创建和评估是极其复杂和耗时的。我只是想给你展示一下模型创建的步骤。在现实生活中，你的大部分时间将花在数据清理和准备上(假设数据收集是由别人完成的)。您还需要花费大量时间对超参数模型的准确性进行多次调整和重新评估。
感谢您的阅读。如果您有任何反馈，请告诉我。
我关于机器学习算法的其他帖子
参考文献
逻辑回归解释
[ —逻辑回归简单解释— ]
在这篇文章中，我将简单地解释逻辑回归。这可以被认为是一种逻辑回归，然而，我从来没有真正喜欢这个表达。
在我们开始之前，这里有一些额外的资源可以让你的机器学习事业突飞猛进:
*Awesome Machine Learning Resources:**- For* ***learning resources*** *go to* [***How to Learn Machine Learning***](https://howtolearnmachinelearning.com/books/machine-learning-books/)*!
- For* ***professional******resources*** *(jobs, events, skill tests) go to* [***AIgents.co — A career community for Data Scientists & Machine Learning Engineers***](https://aigents.co/)***.***
订阅我的专属列表！并获取您喜爱的所有新鲜文章<3! By signing up, you will create a Medium…
z-ai.medium.com](https://z-ai.medium.com/subscribe)
Lets get to it and learn it all about Logistic Regression.
Logistic Regression Explained for Beginners
In the Machine Learning world, 逻辑回归是一种**参数分类模型，**尽管其名称中有单词’回归 ’ 。
这意味着逻辑回归模型是具有某个固定数量的参数的模型，这些参数取决于输入特征的数量，并且它们输出分类预测，例如植物是否属于某个物种。
在现实中，逻辑回归背后的理论与线性回归非常相似，所以如果你不知道什么是线性回归，花 5 分钟阅读这个超级简单的指南:
[ —线性回归简单解释— ]
towardsdatascience.com](/linear-regression-explained-d0a1068accb9)
在逻辑回归中，我们不像线性回归那样直接用直线拟合数据。相反，我们拟合一条 S 形曲线，称为S 形 ，来拟合我们的观察结果。
符合某些数据的 Sigmoid 函数
让我们仔细检查一下这个数字。
首先，就像我们之前说的，Logistic 回归模型是分类模型；特别是二元分类模型(它们只能用于区分两种不同的类别——比如一个人是否肥胖或体重不足，或者一所房子根据其大小是大是小)。这意味着我们的数据有两种观察值(类别 1 和类别 2 观察值)，就像我们在图中可以观察到的一样。
注: 这是逻辑回归的一个非常简单的例子，在实践中更困难的问题可以使用这些模型来解决，使用广泛的特性而不仅仅是单一的一个。
其次，我们可以看到，Y 轴从 0 到 1。这是因为 sigmoid 函数总是将这两个值作为最大值和最小值，这非常符合我们将样本分为两个不同类别的目标。通过计算 X 的 sigmoid 函数(这是输入特征的加权和，就像线性回归中一样)，我们得到属于两个类别之一的观察值的概率 ( 在 0 和 1 之间，显然是)。
s 形函数的公式如下:
如果我们想预测一个人是否肥胖或没有给出他们的体重，我们将首先计算他们体重的加权和(抱歉，词汇冗余)，然后将其输入到 sigmoid 函数中:
1)计算输入的加权和
输入要素的加权总和(本例中为要素)
2)计算肥胖的概率
使用 sigmoid 方程进行计算
好吧，这看起来很酷，但这难道不是一个机器学习模型吗？我们如何训练它？ 这个问题问得好。有多种方法来训练逻辑回归模型(将 S 形线拟合到我们的数据)。我们可以使用类似 梯度下降 的迭代优化算法来计算模型的参数(权重)，或者我们可以使用类似 最大似然 的概率方法。
如果你不知道这些是什么，梯度下降在线性回归文章中有解释，关于机器学习的最大可能性的解释可以在这里找到:
我们成为概率大师的又一步…
towardsdatascience.com](/probability-learning-iii-maximum-likelihood-e78d5ebea80c)
一旦我们使用了这些方法中的一种来训练我们的模型，我们就可以做一些预测了。让我们来看一个示例，演示如何训练逻辑回归模型并使用它来进行预测:
- 首先，我们将收集一个数据集，该数据集包含已被诊断为肥胖和未被诊断为肥胖的患者，以及他们相应的体重。
- 在此之后，我们将训练我们的模型，将我们的 S 形线与数据拟合，并获得模型的参数。使用最大似然法进行训练后，我们得到了以下参数:
X 的参数和方程
3.现在，我们准备做一些预测:假设我们有两个病人；一个 120 斤，一个 60 斤。让我们看看将这些数字代入模型后会发生什么:
在给定患者体重的情况下，使用拟合模型预测肥胖的结果
我们可以看到，第一个病人(60 公斤)肥胖的概率非常低，然而，第二个病人(120 公斤)肥胖的概率非常高。
前面例子的逻辑回归结果。
在上图中，我们可以看到逻辑回归模型给出的结果。现在，给定任何患者的体重，我们可以计算他们肥胖的概率，并给我们的医生一个快速的第一轮信息！
订阅我的专属列表！并获取所有你喜爱的新鲜文章<3! By signing up, you will create a Medium…
z-ai.medium.com](https://z-ai.medium.com/subscribe)
Conclusion and Other resources
逻辑回归是最简单的机器学习模型之一。它们容易理解，可解释，并且能给出相当好的结果。这篇文章的目标是为不是机器学习从业者的人提供一种以非数学方式理解逻辑回归的简单方法，所以如果你想更深入，或者正在寻找更深刻的数学解释，看看下面的视频，它很好地解释了我们在这篇文章中提到的一切。
关于机器学习和数据科学的更多资源，请查看以下资源库: 如何学习机器学习 ！有关职业资源(工作、事件、技能测试)，请访问AIgents.co——数据科学家的职业社区&机器学习工程师 。
牛逼的逻辑回归！
此外，为了更深入地研究逻辑回归和机器学习，可以看看下面文章中描述的书:
让你的机器学习知识更上一层楼
towardsdatascience.com](/the-book-to-really-start-you-on-machine-learning-47632059fd0e)
逻辑回归解释
尽可能简单地解释逻辑回归。
在线性回归中，Y 变量总是连续的。如果 Y 变量是分类变量，则不能使用线性回归模型。
那么，当 Y 是一个有两类的分类变量时，你会怎么做呢？
Logistic 回归可以用来解决这类问题，也称为二元分类问题。
逻辑回归是另一种类型的监督学习算法，但它的目标与其名称正好相反，而不是回归，它的目标是将数据点分类为两个不同的类。它是一个线性模型，产生二进制输出。
区分这两类的线称为超平面，数据点离超平面越远，它属于该类的置信度就越高。
它的目标是找到一个合法的分离超平面，以最好的方式对两个类进行分类。
由 Daksh Trehan 使用 Paint 3D 设计
这里要注意的一个关键点是 Y 只能有两个类，不能超过两个。如果输出类的数量不是二进制的，它将变成多类分类，并且您不能再实施普通的逻辑回归。
下面是一些二元分类问题的例子:
- 垃圾邮件检测:预测一封邮件是否是垃圾邮件
- 信用卡欺诈:预测给定的信用卡交易是否是欺诈
- 健康:预测给定的组织块是良性还是恶性
Sigmoid 函数
我们使用 sigmoid 函数，因为它是非线性的，并且存在于(0 到 1)之间。因此，它特别适用于我们必须预测概率作为输出的模型。我们使用 sigmoid 将预测映射到概率。
乙状结肠的图示
这个函数是可微的，因此我们可以在任意两点找到 sigmoid 曲线的斜率。
g’(z)=g(z)(1-g(z))
计算置信度
如果 sigmoid 函数计算的输出≥0.5，则我们假设该点属于 0 类
如果 sigmoid 函数的输出小于 0.5，则该点被视为在 1 类中。
选择最佳超参数
我们的最终目标是选择最佳的超参数。
第 1 页，共 3 页
如果 P 是属于类 1 的对象的概率，那么(P-1)将是属于类 0 的对象的概率，如
概率总是介于 0 和 1 之间。
第 2 页，共 3 页
我们结合了两个类别的概率，并推导出我们希望最大化的可能性。
第 3 页，共 3 页
我们已经成功导出了更新的超参数。
多类逻辑回归
但是，如果我们希望使用逻辑回归获得许多输出，我们可以使用一个 v/s rest 模型。
为了说明，让我们假设我们的输出可以是属于 dog、cat 和 10 个这样的其他类的任何东西，但是逻辑回归是二元模型，所以我们的方法将为 dog v/s 其他类实现普通的逻辑回归；如果预测的输出是 dog，这很好，但是如果测试图像属于其他类，我们可以迭代我们以前的模型，即 cat v/s 其他类，等等。
使用 Sci-Kit Learn 的逻辑回归
逻辑回归的优势
- 高效率
- 低方差
- 可以使用随机梯度下降很容易地用新数据更新。
逻辑回归的缺点
- 不能很好地处理大量的分类变量。
- 需要非线性特征的转换。
逻辑回归的特征
- 目标是离散变量
- 预测值是目标值的概率。
如果你喜欢这篇文章，请考虑订阅我的简讯: 达克什·特雷汉每周简讯 。
结论
希望这篇文章不仅增加了你对 逻辑回归 的理解，也让你意识到，这并不难，而且已经在我们的日常生活中发生了。
一如既往，非常感谢您的阅读，如果您觉得这篇文章有用，请分享！😃
在 www.dakshtrehan.com加入我
LinkedIN ~https://www.linkedin.com/in/dakshtrehan/
insta gram ~https://www.instagram.com/daksh_trehan/
Github ~T30https://github.com/dakshtrehan
看我的其他文章:-
关注更多机器学习/深度学习博客。
中等~https://medium.com/@dakshtrehan
干杯。
封面模板是我在www.canva.com 做的。 其余图片均来自我的笔记本。
二元分类的逻辑回归
机器学习中的监督学习方法
图片来自 wikicommons
二元分类
在之前的文章中，我谈到了深度学习和用于预测结果的函数。在本文中，我们将使用逻辑回归来执行二元分类。二进制分类之所以这样命名，是因为它将数据分为两种结果。简单来说，结果将是“是”(1)或“否”(0)。为了确定结果是“是”还是“否”，我们将使用一个概率函数:
这个概率函数将给出一个从 0 到 1 的数字，表示这个观察结果属于我们目前确定为“是”的分类的可能性有多大。有了这个，我们知道我们打算如何处理我们的预测。现在，我们将了解如何使用逻辑回归来计算(1)中的方程。
逻辑回归
为了进行逻辑回归，使用了 sigmoid 函数，如下图所示:
图片来自维基公共
我们可以看到，这个函数满足概率函数和等式(1)的特征。同样，我们可以看到，当 S(t)是非常大的正值时，函数趋近于 1，当 S(t)是非常大的负值时，函数趋近于 0。
例子
为了能够理解逻辑回归是如何操作的，我们将举一个例子，在这个例子中，我们的函数将人们分为高或不高。我们将用于校准我们的函数的数据对应于下表(表 1):
假设 t=wx+b ，我们的目标将是找到 w 和 b ，通过将其放入 S(t)中，它将给出正确的预测。我们可以从一个随机数开始，比如说 w=1 和 b=0 ，如果 S(t) 大于 0.5，那么我们就认为它是一个高个子。
我们注意到参数 w=1 和 b=0 不起作用，因为在所有情况下 S(x) > 0.5。现在让我们用 w=6 和 b=-10.5 试试，结果将是:
太好了，我们已经找到了 w 和 b 参数，这样我们的函数就能正确地做出预测！
这些参数用于进行预测；然而，出现了许多问题，例如:
- 我如何计算这些参数？
- 这些参数是最值得推荐的吗？
为了回答这些问题，我们将不得不引入两个新的主题来帮助我们优化函数和理解损失函数。
损失误差函数和成本函数
最好的 w 和 b 参数是什么？这个问题的答案非常简单，因为我们希望参数给我们的误差尽可能小。为此，我们使用损失误差函数:
这个函数基本上告诉我们，我们对实际值的估计有多远( ŷ 估计， y 实际值)。如果我们对所有估计进行总结，我们会得到:
这个总和是我们所有估计的总误差，试图将这个函数减小到 0 意味着试图将我们的误差减小到 0。然而，当在逻辑回归中使用该函数时，我们会得到一个非凸的函数(我们稍后将回到这个主题),由于它不是凸的，所以可能会有几个局部最优点，并且在计算最佳的 w 和 b 时会有很大的困难。为了解决这个问题，我们将使用另一个函数:
在(5)中构造的函数具有与函数(3)相同的目的，以减少误差。我们将对一个观察值做一个实验，看看函数 J(ŷ,y) 的行为。让我们想象一下 J(ŷ,y) 的 4 种可能场景
场景 1- y=1，ŷ=.99
我们观察到，在这种情况下，我们的估计实际上是正确的，当替换时，我们得到:
场景 2- y=1，ŷ=.01
我们观察到，在这种情况下，我们的估计是不正确的，当替换时，我们得到:
场景 3- y=0，ŷ=.99
我们观察到，在这种情况下，我们的估计是不正确的，当替换时，我们得到:
场景 4- y=0，ŷ=.01
我们观察到，在这种情况下，我们的估计是不正确的，当替换时，我们得到:
直观上，我们可以观察这个函数做什么。正确的观测值误差很低，不正确的观测值误差很高。如果我们对所有的观察值求和，我们会得到。
函数(6)相对于函数(4)的优势在于它是凸的。使用函数 6，可以使用梯度下降法以更简单的方式找到最佳点。
梯度下降
梯度下降法试图告诉我们需要向哪个方向移动我们的 b 和 w 参数，以优化函数并获得最小误差。(6)中描述的函数是凸的，所以你可以看到它如下图所示。
图片来自 wikicommons
现在，假设我们的损失函数是 J(w，b) ，要调整的参数是 (w，b) 。我们想找到一个点，使 J(w，b) 尽可能小。梯度下降法告诉我们移动 (w，b) 的方向来减少 J(w，b) 。这些是 (w，b) 的偏导数，也就是 ∂J/∂w 和 ∂J/∂b 。
知道移动 w 和 b 的方向。我们只需要知道它们移动的幅度，这叫做学习率，通常定义为α。最终得到:
最后，我们将总结执行逻辑回归必须遵循的步骤:
- 分析问题，容纳数据。
- 随机提出 w 和 b 来预测你的数据。
- 计算误差
- 执行梯度下降以获得新的 w 和 b.
这 4 个步骤应该重复，直到你得到一个可接受的误差。
分析数据(Python 示例)
我们终于有了应用逻辑回归的所有理论要素。了解如何在 python 等编程语言中应用它们也很重要。这种语言被广泛使用，因此这种算法的实现非常容易。对于这个例子，我们将使用逻辑回归来预测篮球运动员的轨迹。本练习中获得的数据是从 data.world 中提取的。在文章的最后，显示了完整的代码，这样您就可以在 google colab 上跟随并运行代码。
理解此表中每一列的含义很重要:
- 姓名-玩家的姓名
- GP-玩过的游戏
- 播放的分钟数
- 每场比赛的平均得分
- FGM-射门得分
- FGA-尝试射门
- % FG-现场目标的百分比
- 3P 投进了，三分球投进了
- 尝试 3PA 三分球
- 罚球命中
- 尝试罚球
- 罚球百分比
- 进攻篮板
- DREB-防守篮板
- 篮板球
- AST-助攻
- STL-抢断
- BLK 街区
- TOV-失误
- TARGET _ 5 yers-如果玩家持续了 5 年或更长时间，这个值将是 1，否则将是 0。
数据清理
在进行逻辑回归之前，应该对数据进行观察和分析。Pandas 库是 python 上一个非常常用的处理数据的库，我们将使用它来读取和描述数据。
##Import library and read data
import pandas as pd
nbalog=pd.read_csv("path_of_file")
###See data description
decri=nbalog.describe()
以“#”开头的代码只是一些注释，所以对于这段代码，我们只做了 3 件事:
- 导入必要的库。
- 读取基础文件。
- 描述现有数据。
描述表明我们拥有的数据量、最大值、最小值、标准偏差等。通过观察数据，可以看出一些字段是空的。在训练模型之前，必须解决这些问题。空白字段将被替换为 0，皮尔逊相关系数将用于观察具有最高相关性的数据。
###Using the data described we notice that 3P% has some blank ###fields.These fields will be filled with 0\. nbalog=nbalog.fillna(0)
###We check the correlation that exists between the data. pearson=nbalog.corr(method='pearson')
使用皮尔逊相关系数，我们注意到具有最高相关性的列。这样，更有用的列应该保留，其他的应该删除。
###Some variables are higly correlated so they will be dropped
###(pearson>.8).
nbalog=nbalog.drop(['MIN', 'PTS','FGM','3P Made','FTM','FTA','TOV','OREB','DREB'], axis=1)
逻辑回归
有了干净的数据，我们可以开始训练模型。为此，将使用库 sklearn。该库包含许多模型，并不断更新，使其非常有用。为了训练模型，我们将指出哪些是预测变量，哪些是被预测变量。
### X are the variables that predict and y the variable we are ###trying to predict. X=nbalog[['GP','FGA','FG%','3PA','3P%','FT%','REB','AST','STL','BLK']]
y=nbalog[['TARGET_5Yrs']]
现在，使用库 sklearn，数据将被分成训练集和测试集。通过训练集，模型将被调整，通过测试集，我们将看到模型有多好。
### The data has to be divided in training and test set. from sklearn.model_selection import train_test_split X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25)
前面的代码将数据分为训练集和测试集。变量 X 代表自变量，y 代表因变量。这一次，该集合的 75%用于训练，25%用于测试。在分离数据之后，它可以用于拟合模型，在这种情况下，该模型是“逻辑回归”模型。
###We import the model that will be used. from sklearn.linear_model import LogisticRegression.
# Create an instance of the model.
logreg = LogisticRegression()
# Training the model.
logreg.fit(X_train,y_train)
# Do prediction.
y_pred=logreg.predict(X_test)
因此，已经使用函数校准了模型。拟合并准备好使用测试数据进行预测。这是使用功能完成的。预测并使用自变量测试 **(X_test)。**得到的结果可以与真实值 (y_test) 进行比较，看是否是一个好的模型。
# Analyzing the results.
from sklearn import metrics
cnf_matrix = metrics.confusion_matrix(y_test, y_pred)
由此产生的矩阵被称为混淆矩阵。在第一象限中，显示了被正确分类为 0 的条目的数量(61)。第二和第三象限合计不正确的分类(99)。最后，第四象限显示了数字为 1 (175)的正确分类。精度可以通过下式计算:
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))*Output:.7045*
以此，我们结束本文。像往常一样，我将代码留给您，以便您可以测试、运行和尝试不同的模型。祝你愉快，祝贺你学会了如何做逻辑回归。
文献学
新泽西州里普纳(2017 年 1 月 24 日)。二元分类练习数据集。检索于 2020 年 9 月 24 日，来自https://data.world/.
indeed 123/CC BY-SA(https://creativecommons.org/licenses/by-sa/3.0)
loli kar/CC BY-SA(https://creativecommons.org/licenses/by-sa/4.0)
原载于 2020 年 9 月 25 日 https://datasciencestreet.com。
分类任务的逻辑回归
手写数字识别任务
对于模式识别方法，有许多方法来实现手写数字识别任务。在我之前的故事中，我已经介绍了基于高斯模型最大似然估计的线性判别分析。在这篇文章中，我将逻辑回归模型应用于英文数字手写数字识别任务。
逻辑模型
在逻辑回归模型中，事件的发生概率由逻辑函数表示。例如，在两类问题中，通常使用逻辑 sigmoid 函数。在多类问题中，已知 softmax 函数提供良好的性能。
在这篇文章中，我们介绍了如何后验概率可以表示在逻辑函数。接下来，我们暗示每一个类别到输入模式的线性变换，并估计它们的后验概率。
用逻辑函数模拟后验概率
考虑类别数量为 c 的分类任务。使用最大后验概率规则，输入模式 x 的输出类别是类别 y，其中 p(y|x)最大。后验概率 p(y=i|x)为
这里，让我们
因此，
softmax()被称为 softmax 函数。当 C=2 时，称为逻辑 sigmoid 函数。从(3)中，我们可以确认后验概率可以用逻辑函数来表示。
后验概率估计
在多类任务中，我们使用一个 softmax 函数，p(y=i|x)=softmax(a_i)。为了估计这个概率，我们通过将输入模式线性变换成第 I 类来估计 a_i。这意味着，
其中参数 w_i 由最大似然法估计。
现在，后验概率 p(y=i|x)是
设 C 为类别数，{(x_i，y_i)} (i=1，…，N)为样本数据集。似然函数是
在哪里
对数似然可以写成
为了定义最佳参数 w_j，我们计算对数似然函数的梯度。
然而，解析解这个方程是不可能的。作为解决方案，我们应用梯度上升学习算法来最大化对数似然函数。学习算法是
用 Python 实现
from scipy.special import softmax**class** **LogisticRegression**(object):
*"""logistic regression classifier with gradient ascent learning method*
*"""*
**def** __init__(self, lr=0.01, iteration=100, C=10):
self.lr = lr
self.iteration=iteration
self.C = C
**def** fit(self, x, y):
self.w = np.zeros((self.C,1+x.shape[1]))
**for** i **in** range(self.C):
self.w[i,:] = np.random.normal(loc=0.0, scale=0.01, size=1+x.shape[1])
*#self.energy = []*
**for** i **in** range(self.iteration):
inp = self.getInput(x)
out = self.getOutput(inp)
error = y-out
self.w[:,1:] += self.lr*np.dot(error.T,x)
self.w[:,0] += self.lr*np.sum(error)
**return** self
**def** softmax(self, a):
out = softmax(a,axis=1)
**return** out
**def** getInput(self, x):
out = np.dot(x, self.w[:,1:].T)+self.w[:,0]
**return** out
**def** getOutput(self, a):
**return** self.softmax(a)
**def** predict(self,x):
**return** self.getInput(x)lrgd = LogisticRegression(lr=0.0001, iteration=3000, C=10)
lrgd.fit(X_train,y_train)result = np.argmax(lrgd.predict(X_test),axis=1)
print(result)
confusion = np.zeros((C,C))
for i in range(C):
for j in range(C):
confusion[i,j] = np.sum(np.array([1 for k in result[i*200:(i+1)*200] if k==j]))
errors = []
TFs = np.zeros((C,3))
for i in range(C):
fn = 0
fp = 0
for j in range(C):
if j!=i:
fn = fn + confusion[i][j]
fp = fp + confusion[j][i]
#print(s)
TFs[i,0] = confusion[i,i]
TFs[i,1] = fn
TFs[i,2] = fp
fn = fn/np.sum(confusion,axis=1)[i]
errors.append(fn)
print("Class Errors:\n",errors)
print("Confusion Matrix:\n",confusion)
print("Error Rate: ",np.mean(errors))
print("Accuracy : ",np.sum([[confusion[i][i] for i in range(C)]])/(NT*C))
实验结果
资料组
输入模式 : 16x16 的英文手写数字图像(256 维向量)
输出类别 : 1，2，3，4，5，6，7，8，9，0
训练数据 : 5000 张图像
测试数据 : 2000 张图像
学问
学习率 : 0.0001
迭代 : 3000
Class Errors:
[0.005, 0.07, 0.045, 0.07, 0.115, 0.04, 0.075, 0.11, 0.05, 0.035]
Confusion Matrix:
[[199\. 0\. 0\. 0\. 1\. 0\. 0\. 0\. 0\. 0.]
[ 0\. 186\. 0\. 8\. 0\. 0\. 1\. 4\. 1\. 0.]
[ 0\. 1\. 191\. 0\. 4\. 0\. 2\. 2\. 0\. 0.]
[ 1\. 1\. 0\. 186\. 1\. 2\. 0\. 2\. 7\. 0.]
[ 0\. 0\. 11\. 3\. 177\. 1\. 1\. 0\. 3\. 4.]
[ 0\. 1\. 0\. 2\. 1\. 192\. 0\. 2\. 0\. 2.]
[ 0\. 1\. 3\. 2\. 0\. 0\. 185\. 1\. 8\. 0.]
[ 0\. 2\. 6\. 1\. 7\. 0\. 0\. 178\. 2\. 4.]
[ 2\. 0\. 0\. 2\. 0\. 0\. 3\. 3\. 190\. 0.]
[ 0\. 1\. 0\. 0\. 4\. 1\. 0\. 1\. 0\. 193.]]
Error Rate: 0.062
Accuracy : 0.939
与 Fisher 线性判别分析的比较
现在让我们来看看与 Fisher 的线性判别分析相比，识别准确率是如何提高的。
费希尔线性判别分析[ 转到上一个故事
mean = np.zeros((D,C))
cov = np.zeros((D, D))for i in range(C):
mean[:,i] = np.mean(X[:,:,i],1)
cov = cov + np.cov(X[:,:,i])/CinvS = np.linalg.pinv(cov)p = np.zeros((C,NT,C))
for i in range(C):
t = T[:,:,i]
for j in range(C):
m = mean[:,j]
p[i,:,j] = np.dot(t.T,np.dot(invS,m)) - np.dot(m.T,np.dot(invS,m))/2.P = np.argmax(p,axis=2)
confusion = np.zeros((C,C))
for i in range(C):
for j in range(C):
confusion[i,j] = np.sum(np.array([1 for k in P[i,:] if k==j]))errors = []
TFs = np.zeros((C,3))
for i in range(C):
fn = 0
fp = 0
for j in range(C):
if j!=i:
fn = fn + confusion[i][j]
fp = fp + confusion[j][i]
#print(s)
TFs[i,0] = confusion[i,i]
TFs[i,1] = fn
TFs[i,2] = fp
fn = fn/np.sum(confusion,axis=1)[i]
errors.append(fn)print("Confusion Matrix:\n",confusion)
print("Error Rate: ",np.mean(errors))
print("Accuracy : ",np.sum([[confusion[i][i] for i in range(C)]])/(NT*C))
Fisher 线性判别分析的结果
Confusion Matrix:
[[199\. 0\. 0\. 0\. 1\. 0\. 0\. 0\. 0\. 0.]
[ 0\. 169\. 8\. 8\. 1\. 2\. 4\. 8\. 0\. 0.]
[ 0\. 0\. 182\. 1\. 5\. 0\. 2\. 8\. 1\. 1.]
[ 2\. 2\. 0\. 182\. 0\. 1\. 0\. 3\. 10\. 0.]
[ 0\. 0\. 21\. 4\. 162\. 1\. 0\. 4\. 4\. 4.]
[ 1\. 2\. 0\. 1\. 5\. 185\. 0\. 3\. 0\. 3.]
[ 2\. 0\. 1\. 5\. 1\. 0\. 181\. 0\. 9\. 1.]
[ 0\. 1\. 16\. 6\. 6\. 0\. 1\. 164\. 3\. 3.]
[ 1\. 0\. 0\. 8\. 0\. 0\. 7\. 2\. 182\. 0.]
[ 0\. 0\. 3\. 0\. 0\. 4\. 0\. 1\. 0\. 192.]]
Error Rate: 0.101
Accuracy : 0.899
比较
# Fisher’s Linear Discriminant Analysis
**Error Rate: 0.101
Accuracy : 0.899**# Logistic Regression Model
**Error Rate: 0.062
Accuracy : 0.939**
讨论和结论
从实验结果来看，logistic 回归模型提高了识别的准确率。
在 Fisher 的 LDA 中，假设所有类别的方差-协方差相等。因此，缺乏来自每个类别特征的信息。然而，Fisher 的 LDA 是一个极其简单的模型，消耗较少的计算时间。
在逻辑回归模型中，输入到每个类别中的线性变换的概念是线性判别规则的一种形式，这在线性中也发现类似于 Fisher 的 LDA。逻辑回归模型的特点是应用逻辑函数来估计后验概率。这有利于增加数据特征表示的自由度。然而，由于我们不能用解析计算直接获得逻辑回归的线性变换的最佳参数，所以梯度上升学习中的时间计算是一个缺点。此外，该学习规则是数值计算，其中仅获得近似参数，结果往往会根据初始化而改变。
从零开始的逻辑回归
鸣谢:法比奥·罗斯
介绍
在这篇文章中，我们将使用梯度下降从头开始构建我们自己的逻辑回归模型。为了测试我们的模型，我们将使用来自 sklearn 包的“乳腺癌威斯康星州数据集”,并以超过 95%的准确度预测肿块是良性还是恶性。GitHub 回购在这里是。所以让我们开始吧。
模型核心
实质上，逻辑回归模型由两个部分组成:sigmoid 函数和具有权重的特征:
Sigmoid 函数
sigmoid 函数 g(z) 将特征和权重 z 作为输入，并返回介于 0 和 1 之间的结果。sigmoid 函数的输出是实际预测 ŷ 。
特征和重量
在模型做出预测之后，我们可以用交叉熵损失函数来评估结果:
二元交叉熵损失函数
自然对数在这里对我们有利，因为如果预测值与真实值相差很远，它会受到很大的惩罚。例如，如果模型预测值和真实值 y=1 ，则误差高，反之亦然:
损失函数由两部分组成，但我们可以将它们合并成一个等式:
二元交叉熵损失函数
这里我们添加了 y 和 (1 - y) 来根据输出抵消一部分。我们将在我们的模型中使用该函数来计算损失，并在模型训练的梯度下降部分使用该函数。
模特培训
模型训练本质上是损失函数的最小化。我们通过梯度下降技术实现了这一点，该技术可以分为几个步骤:
- 首先，我们找到损失函数相对于每个权重的导数。导数可以告诉我们应该向哪个方向改变权重，以及改变多少，以使模型损失更小一些。
- 根据导数更新每个权重，直到找到局部最小值，即模型不再改进，因此我们可以停止。
派生物
这是最关键也是最难的部分。没有导数，模型就不能训练，所以我们将在这一部分详细讨论。
此时，我们可以放下求和函数，专注于内部内容:
1 个样本的损失函数
符号: y —真值，—预测值(sigmoid)**
为了找到导数，我们将使用链式法则**😗*
当我们需要找到一个包含另一个函数的函数的导数时，我们使用链式法则，等等。在我们的例子中，我们有一个包含 sigmoid 函数的损失函数，该函数包含特征和权重。所以有三个函数，我们将一个接一个地推导它们。****
1.链条中的一阶导数
自然对数的导数很容易计算:
自然对数的导数
由于等式中有两个部分，我们可以分别导出它们:
对数函数的导数
现在，我们可以将两部分重新组合在一起，并进行简化:
对数导数的简化
这看起来很好，现在我们把注意力放在 sigmoid 函数上。
2.链中的二阶导数
根据链式法则，我们要找到*【ŷ】*的导数。你可以在网上找到它的导数的详细解释，因为它在机器学习模型中经常使用，所以我只写下最终结果:
Sigmoid 导数
3.链条中的三阶导数
链中的最后一个函数是包含在 z 中的内容——我们的特征和权重。对于每个权重的导数( w )将是其特征值( x )，例如: (x1 * w1)’ = x1 ，因为 w 的导数是 1。
x*w 的导数
根据链式法则，我们将每个衍生函数相乘，因此得到以下结果:
最终方程
我们完了。最后，我们得到了一个非常紧凑的函数，我们将在梯度下降中使用它。
梯度下降
与寻找导数相比，这部分是轻而易举的。在程序员的语言中，这只是循环的,在这里我们不断地更新权重。****
在此过程中，我们将每个导出值乘以学习率参数，然后从权重中减去该值:
**# example of updating one weightepochs = 50
lr = 0.1for _ in range(epochs):
w1 -= lr * x1 * (y_hat - y) # y_hat is predicted value**
学习率通常是一个很小的数字，用来控制我们向最小化移动的快慢。让我们来看看完整的代码:
估价
乳腺癌威斯康星数据集 569 个样本和 30 个特征:
乳腺癌数据集
经过训练测试后，分裂模型以 97%和 95%的准确度预测了恶性和良性肿块，这是一个不错的结果。
结论
我们创建的模型可以用于现实生活中的应用，而且它非常适合教育目的。虽然物流回收会更快更准确，但我们可以不断优化现有资源，最终达到类似的效果。如果你有任何问题或建议，请在评论中告诉我。
感谢您的阅读，
阿瑟尼。
逻辑回归——长颈鹿和汽车
Marcin Jozwiak 在 Unsplash 上拍摄的照片
不久前，我在 Coursera 上开设了一门应用机器学习的课程。为了帮助上这门课的其他人，也为了帮助我自己更好地理解主题，我决定根据课程安排制作一些简短的教程。我的前两篇文章讨论了 KNN 分类和线性(多项式)回归。有兴趣的话，可以随便看看。
根据油耗和发动机大小对汽车进行简单的 K 近邻(KNN)分类。
towardsdatascience.com](/towards-machine-learning-k-nearest-neighbour-knn-7d5eaf53d36c) [## 走向机器学习——线性回归和多项式回归
什么方法能更好地预测你汽车的二氧化碳排放量？线性回归还是多项式回归？
towardsdatascience.com](/towards-machine-learning-linear-regression-and-polynomial-regression-df0c83c15b6e)
今天，我将介绍一种叫做逻辑回归的技术。尽管它被称为“回归”，但它是一种分类方法。与线性回归相比，主要区别在于输出，线性回归给出连续值，而逻辑回归返回二元变量。简单来说，它解释了两类价值之间的关系，即动物是不是长颈鹿。
但稍后会有更多的内容。
文章的结构:
- 介绍
- 数据集加载和描述
- 数据格式和模型定义
- 结果可视化
- 结论
享受阅读吧！🙂
介绍
最近，我在汽车数据上尝试了 KNN 和线性回归。KNN 帮助我们将汽车分类为“小型车”或“大型车”，结果相当令人满意。假设有人想知道一辆车前轮驱动的概率。逻辑回归开始发挥作用，因为它计算作为目标类的对象的分数(“机会”)。也就是说，它可以根据汽车的燃料消耗、发动机大小、气缸数量或汽车的任何其他相关特征来预测汽车前轮驱动的概率。
逻辑回归是如何工作的？
就像线性回归一样，我们有一些输入变量，X1，X2，X3。线性回归将计算每个变量的权重，添加偏差并返回一个标签(类别)。类似地，在逻辑回归中，计算每个输入变量(X1，X2，X3)的权重，添加偏差项，然后对结果应用逻辑 函数。然后，该函数返回一个介于零(负类)和一(正类)之间的值，该值描述输入对象属于正类的概率值。
乙状结肠函数(来源:作者)
让我们看一个简单的例子，根据维基百科的说法，一只成年长颈鹿的身高在 4.3 到 5.7 米之间。假设我们想知道一只动物是不是长颈鹿，那么我们测量动物的高度，并在 X 轴上显示数值，然后逻辑函数返回一只动物是长颈鹿的概率(Y 轴)。然后，如果该值高于 0.5，该动物被预测为长颈鹿，如果低于 0.5，该模型预测该动物不是长颈鹿。除了分类之外，我们还可以获得概率信息。所以，一只身高 4.8 米的动物比一只身高 2.7 米的动物更有可能是长颈鹿。
让我们更实际一点，好吗？
数据集加载和描述
首先，我们将导入依赖关系，加载汽车燃油经济性数据，并查看数据框架。要使用逻辑回归，我们需要从 Scikit-Learn 模型模块导入 LogisticRegression 类。
同样，我们将使用来自 Udacity 的汽车数据集。它包含 3920 辆汽车的技术规格，包括气缸数、发动机尺寸(排量)、油耗、二氧化碳排放量等数据，以及驱动。
我们今天的目标是根据驱动轮将汽车分为两类。基本上，在我们的数据库中有前轮驱动汽车、后轮驱动汽车和全轮驱动汽车。每种类型都有自己的优点和 CONS，但这不是这里的主题。🙂
我们想根据排量[升]和综合油耗[mpg]来预测汽车前轮驱动的概率。为此，我们需要管理标签，前轮驱动的汽车将收到标签 1(正)，后轮和全轮驱动的汽车标签 0(负)。
前轮驱动的汽车被标记为正类(1)，而后轮和全轮驱动的汽车被标记为负类(0)(来源:作者)
如果我们将排量和综合油耗绘制成一对图表，我们可以注意到前轮驱动的汽车(1 级-橙色点)倾向于燃烧更少的燃料(更高的 mpg 值)，并且排量更低。
数据集的 Pairplot(来源:作者)
此外，在对任何数据应用逻辑回归之前，最好执行数据标准化(源 1 、源 2 )。基本上，它将变量集中在零附近，通过从每次测量中减去平均值并将结果除以标准偏差，将方差设置为 1。我们将在标准化和不标准化的情况下运行我们的模型，只是为了看看它在这个特定的数据集上是否有任何不同。
数据格式和模型定义
首先，我们从数据集中选择所需的列。
此外，当对任何数据应用逻辑回归时，执行数据标准化(源 1 、源 2 )是一个很好的实践。基本上，它将变量集中在零附近，通过从每次测量中减去平均值并将结果除以标准偏差，将方差设置为 1。我们将在标准化和不标准化的情况下运行我们的模型，只是为了看看它在这个特定的数据集上是否有任何不同。
如何进行标准化？
Scikit-learn 也有一个关于这个的类，它叫做 StandardScaler 。让我们看一个例子:
现在，我们来对比一下标准化前后的数据。
(来源:作者)
正如所料，我们可以观察到，现在数据的标准偏差明显更低，数据的范围也更小，因此值更接近。
(来源:作者)
在下一步中，我们想要检查这个度量是否为我们的模型产生一些好处或缺点。
模型定义
我们就可以应用这个模型。和 Scikit-learn 一样，这是一个非常简单的过程。
很好，模型准备好了，现在让我们看看结果！
标准化数据会影响模型的准确性吗？
嗯，可能是由于一个大的数据集，根本不是。让我们看看结果。
未缩放模型的训练和测试集结果(来源:作者)
缩放模型的训练和测试集结果(来源:作者)
与我们的预期相反，训练结果没有变化，而测试集的准确性略有下降。
这些数字看起来不错，但是用一个真实的例子来测试这个模型肯定会更好，不是吗？
测试编号 1(来源:作者)
测试编号 2(来源:作者)
我在两辆车上测试了这款车型，一辆是 2016 年款的福特嘉年华运动版，一辆是 2018 年款的宝马 M5 版。而且对于两款车，模型预测都是正确的。
结果可视化
所以我们问自己，数据集群之间的边界在哪里？好吧，让我们来看看。
有两种方式创造情节。一种包括，计算决策边界线的斜率和截距，绘制成简单的线图。另一种方法是创建网格，并将边界绘制为将数据分成两半的等高线。
有两种方式创造情节。一种包括，计算决策边界线的斜率和截距，绘制成简单的线图。另一种方法是创建网格，并将边界绘制为将数据分成两半的等高线。
首先，我们从更简单的方法开始。
我们检索参数，然后计算边界的斜率和截距。基本上我们是在计算一条线性回归线，它描述了我们的 X 轴值(排量)和 Y 轴值(综合燃油经济性)之间的关系。
使用 plt.plot 的决策边界图(来源:作者)
同样，标签 1 代表正类(前轮驱动的汽车)，而标签 0 代表所有其他汽车(负类)，在这种情况下是后轮和全轮驱动的汽车。
绘制边界的第二种方法是使用等高线法。首先，定义网格，其中为两个特征(排量和综合燃油经济性)定义最小值和最大值。 Numpy.c_ 沿第二个轴串联数组。计算每个网格点的概率。这里需要了解的是，我们在这里使用我们的模型 logreg ，其目的是为了可视化 斜率 和 截距 。
接下来，我们需要定义情节。
用等高线法判定边界图(来源:作者)
为了显示边界线，我们只显示截取汽车前轮驱动的 50%概率的轮廓线。线上的所有汽车都被预测为前轮驱动(正 1 级)，而线下的所有汽车都被预测为非前轮驱动，因此它们要么是后轮驱动，要么是全轮驱动。
我们也可以将概率作为一种颜色添加到我们的绘图中。这有助于直观识别概率，因此无需运行模型或计算准确的概率就可以评估概率。
代码如下:
概率绘制成等高线图(来源:作者)
我需要指出的是，这里我们有两个特征，也有一个二维图。更多的特征会增加绘图的维数。
结论
在这里，我们给出了一个如何使用逻辑回归根据汽车的排量和综合燃油经济性来预测汽车行驶的例子。此外，还评估了数据标准化技术。对于这个特定的数据集，标准化对模型精度没有影响。
已经使用两种技术计算并绘制了两个标签数据集群(前轮和非前轮驱动汽车)之间的判定边界。此外，还添加了概率等值线图。
我希望你喜欢我的文章。如果一些介绍的主题需要进一步解释，请随时通过 LinkedIn 联系我。🙂
也直到下次，检查出我的其他文章。干杯！
使用逻辑回归预测应用订阅
使用 Sklearn 对应用程序行为数据进行功能工程、数据处理和逻辑回归建模演练
通过链接改编自 Unsplash 的 Img
之前的文章是关于原始数据上的 EDA。在这里，我将解释如何执行特征工程、数据处理，并最终使用移动 app 行为数据创建逻辑回归模型。它分为 7 个部分。
- 问题陈述
- 特征工程
- 数据处理
- 模型结构
- 模型试验
- 模型验证
- 摘要
现在让我们开始吧🏃♀️🏃♂️.
1.问题陈述
一家金融科技公司委托我们分析移动应用行为数据，以帮助引导客户获得付费订阅服务。具体来说，任务是确定哪些用户最有可能不注册。图 1 是具有 12 列和 50，000 行 的原始数据片段。
图 1 原始数据片段
2.特征工程
特征工程是将原始数据转化为最能代表问题的特征的艺术。 只有用正确的特征工程，模型才能做出最好的预测。我们将从两个方面进行特征工程。
2.1 因变量工程
因变量是列’已注册’。与’ enrolled’ 密切相关的一列是’ enrolled_date’ 。基本上，用户可以在任何日期报名，以’*报名’*为 1。由于大多数应用程序功能在第一个 24 小时后不可试用，我们需要设置注册的时间限制。
为了设置有效的登记时间限制，我们计算’ first_open ‘和’ enrolled_date’ 之间的时间差，并调查登记分布。
第一步是计算’ first_open ‘和’ enrolled_date’ 之间的时差。具体来说，将’ first_open ‘和’ enrolled_date’ 解析为 datetime 类型，并以小时为单位计算时差。
dataset[“first_open”] = [parser.parse(row_date) for row_date in dataset[“first_open”]]dataset[“enrolled_date”] = [parser.parse(row_date) if isinstance(row_date, str) else row_date for row_date in dataset[“enrolled_date”]]dataset[“difference”] = (dataset.enrolled_date-dataset.first_open).astype(‘timedelta64[h]’)
第二步是通过绘制“*差异”*列的直方图来查看注册分布。
response_hist = plt.hist(dataset[“difference”].dropna(), color=’#3F5D7D’)
plt.title(‘Distribution of Time-Since-Screen-Reached’)
plt.show()
图 2 显示用户注册高度集中在前 50 个小时。因此，我们将响应限制设置为 48 小时。
图 2 注册分布
现在，有了 48 小时的登记限制，我们将’T38 已登记’T39 列重置为 0，即未登记。
dataset.loc[dataset.difference > 48, ‘enrolled’] = 0
dataset = dataset.drop(columns=[‘enrolled_date’, ‘difference’, ‘first_open’])
上面我们删除了*【注册日期】**【差异】【首次公开】*栏，因为培训不需要它们。
2.2 自变量工程
数据集中唯一的非数字列是*‘screen _ list’。这是一个包含用户查看的所有屏幕功能的列表。所以我们需要把它转换成数值变量。一种方法是将‘screen _ list’*中的每个唯一屏幕转换为分类变量。*但是，独特的屏幕太多了。因此，我们将只关注那些最受欢迎的屏幕。*具体来说，
top_screens = pd.read_csv(‘top_screens.csv’).top_screens.values
dataset[“screen_list”] = dataset.screen_list.astype(str) + ‘,’
for sc in top_screens:
dataset[sc] = dataset.screen_list.str.contains(sc).astype(int)
dataset['screen_list'] = dataset.screen_list.str.replace(sc+",", "")
上面，我们为代表最受欢迎屏幕的*‘top _ screens’*中的每个屏幕创建了一个列。
接下来，我们创建一个*‘Other’*列，作为所有非流行屏幕的总和。
dataset[‘Other’] = dataset.screen_list.str.count(“,”)
dataset = dataset.drop(columns=[‘screen_list’])
**最后，如果我们仔细检查列的名称，我们会发现许多列代表相同的特性。**例如，保存 1 、保存 5 是关于保存的屏幕，而信用 1 、信用 3 是关于信用的屏幕。我们需要通过合计相同功能屏幕的数量来聚合相同的功能。具体来说，
cm_screens = [“Credit1”, “Credit2”, “Credit3”, “Credit3Container”, “Credit3Dashboard”]
dataset[“CMCount”] = dataset[cm_screens].sum(axis=1)
dataset = dataset.drop(columns=cm_screens)
对其他特征重复相同的方法(例如，保存、贷款等)，我们得到了包含所有数字变量的最终数据集。图 3 显示了所有的列。
图 3 所有数据列名称
总之，我们使用数据挖掘技术来提炼和提取最能代表移动应用用户行为的属性。
3.数据处理
数据处理包括数据分割和特征缩放。
3.1 数据分割
第一步是分离自变量和因变量。具体来说，
response = dataset[“enrolled”]
dataset = dataset.drop(columns=”enrolled”)
第二步是将数据分成训练集和测试集。具体来说，
X_train, X_test, y_train, y_test = train_test_split(dataset, response, test_size = 0.2, random_state = 0)
3.2 特征缩放
特征缩放是为了避免任何变量支配其他变量，即采用更高的权重和对模型学习的强烈影响。这里，我们通过去除平均值并缩放到单位方差来标准化特征。具体来说，
from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train2 = pd.DataFrame(sc_X.fit_transform(X_train))
X_test2 = pd.DataFrame(sc_X.transform(X_test))
X_train2.columns = X_train.columns.values
X_test2.columns = X_test.columns.values
X_train2.index = X_train.index.values
X_test2.index = X_test.index.values
X_train = X_train2
X_test = X_test2
注意， StandardScaler() 返回一个 numpy 数组，该数组会丢失列名和索引。因此，我们再次将缩放后的数据转换为数据帧，以保留行和列标识符。
太好了。模型的数据终于准备好了。图 4 是具有 50 列和 50，000 行 的最终数据的简要视图。
图 4 最终数据的简要视图
4.模型建筑
这里我们将创建一个逻辑回归模型来预测一个二元因变量，即是否入学。根据维基百科，标签为 1 的概率的对数是一个或多个独立变量的线性组合。本质上，我们试图估计一个逻辑模型的系数，如图 5 所示。
图 5 逻辑回归模型(作者创建的 Img)
具体来说，
from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression(random_state = 0, penalty = ‘l1’)
classifier.fit(X_train, y_train)
注意我们使用拉索(【L1】)正则化模型，而不是正态回归模型。 L1 正则化给损失函数增加一个等于 系数 大小的绝对值之和的惩罚，如图 6 所示。
图 L1 正则化的损失函数(作者创建的 Img)
注意 L1 和 L2 正则化的区别在于 L2 相加的惩罚是 系数大小的平方值之和，如图 7 所示。
图 7 L2 正则化损失函数(作者创建的 Img)
5.模型测试
训练好模型后，让我们在 X_test 上测试模型。
*y_pred = classifier.predict(X_test)
cm = confusion_matrix(y_test, y_pred)*
为了更好地回顾预测结果，让我们将其与实际结果进行比较。所以，具体来说，
*final_results = pd.concat([y_test, test_identity],axis =1).dropna()
final_results[‘predicted_results’] = y_pred
final_results[[‘user’, ‘enrolled’,‘predicted_results’]].reset_index(drop=True)*
图 8 显示了实际登记的结果和预测的结果。
图 8 预测和实际结果对比
图 9 展示了混淆矩阵。这告诉我们测试精度为 0.768。不错的结果😃。如果你想知道如何计算精度，请阅读这篇文章。
图 9 混淆矩阵
6.模型验证
有了上面的测试准确性，作为一个数据科学家，你应该问一个问题:这是模型性能的真实反映吗🤔？为了回答这个问题，我们将使用 K 倍交叉验证。
具体来说，将训练数据分成 10 个子集，使用 9 个子集来训练模型，剩余的用于验证。重复这个训练和验证 10 次。最后平均准确率和损耗。
*accuracies = cross_val_score(estimator= classifier, X= X_train, y = y_train, cv = 10)*
我们得到的平均精度为 0.767 ，标准偏差为 0.10 。很好，模型显示出很小的差异，即模型始终是准确的。
7.总结
概括地说，我们经历了特征工程、数据处理、模型构建、测试和验证。特征工程和数据处理是耗时的，但是为模型准备数据是最重要的。如果你想了解模型优化，请阅读这篇文章。
太好了！这就是所有的旅程！如果您需要源代码，请随时访问我的 Github 页面🤞🤞。
逻辑回归——概念和应用
在 Unsplash 上由 Janita Sumeiko 拍摄的照片
本文将尝试:
- 讨论逻辑回归背后的思想
- 通过一个例子进一步解释
你应该已经知道的
给你一个问题，根据一个人的身高预测他/她的性别。首先，给你提供 10 个人的数据，已知他们的身高和性别。要求您在这些数据中拟合一个数学模型，使您能够预测某个已知身高值但我们不知道其性别的人的性别。这类问题属于监督机器学习的分类领域。如果问题要求你进行各种分类，如真、假或富人、中产阶级、穷人或失败、成功等等，那么你就是在处理分类问题。它在机器学习中的对应部分是一个回归问题，该问题要求我们预测一个连续值，如分数= 33.4%，体重= 60 Kg 等。本文将讨论一种称为逻辑回归的分类算法。
虽然有许多分类算法，它们的复杂程度各不相同，如线性判别分析、决策树、**随机森林、**等，但逻辑回归是最基本的算法，非常适合学习分类模型。让我们跳到上述问题，假设，给我们十个人的数据如下:
这个问题完全不同于其他数学预测问题。原因是，一方面，我们有连续的身高值，但另一方面，我们有性别的分类值。我们的数学运算知道如何处理数字，但处理分类值却是一个挑战。为了克服分类问题中的这一挑战，无论它们是通过逻辑回归还是其他算法解决的，我们总是计算与类相关的概率值。在给定的上下文中，我们将计算与男性类或女性类相关的概率。另一个类别的概率不需要明确计算，但是可以通过从一个类别中减去先前计算的类别的概率来获得。
在给定的数据集中，我们以身高为自变量，性别为因变量。目前，如果我们假设它是一个回归问题，它将通过计算回归模型的参数得到解决，如下所示:
简而言之，我们会计算出 Bo 和 B1 ，问题就解决了。分类问题不能以这种方式解决。如前所述，我们无法计算性别的价值，但可以计算与特定性别阶层相关的概率。在逻辑回归中，我们从线性回归中获得灵感，并使用上面的线性模型来计算概率。我们只需要一个函数，将上述线性模型作为输入，并给我们的概率值作为输出。在数学形式中，我们应该有这样的东西:
上面的模型计算了男性职业的概率，但是我们可以在这里使用这两个职业中的任何一个。等式右侧所示的函数应该满足这样的条件，即它应该接受任何实数输入，但应该只给出 0 和 1 范围内的输出，原因是显而易见的。以下所示的称为 Sigmoid 或逻辑函数的函数满足上述条件:
Sigmoid 函数的定义域为 -inf 到 inf ，取值范围为 0 到 1，非常适合逻辑回归中的概率计算。如果我们将线性模型代入 Sigmoid 函数，我们将得到如下所示的结果:
上面的等式可以很容易地重新排列，以给出更简单和容易理解的形式，如下所示:
等式的右边正是我们在线性回归模型中得到的&左边是几率概率的对数，也称为 logit。因此，上述等式也可以写成:
*logit(性别=男性)= Bo+B1 身高
这是逻辑回归背后的思想。现在让我们解决给我们的问题，看看它的应用。
我们将使用 Python 代码，使用给定的数据来训练我们的模型。我们先导入必要的模块。我们需要来自 sklearn 的 NumPy 和logistics regression类。
*from sklearn.linear_model import LogisticRegression*
现在模块被导入了，我们需要创建一个 LogisticRegression 类的实例。
*lg = LogisticRegression(solver = ‘lbfgs’)*
使用的求解器是 lbfgs 。现在是时候创建我们将用来训练模型的数据集了。
*height = np.array([[132,134,133,139,145,144,165,160,155,140]])**gender = np.array([1,0,1,1,0,0,0,0,0,1])*
注意，sklearn 只能处理数值，所以这里我们用 1 表示女性类，用 0 表示男性类。使用上述数据集，我们来训练模型:
*lg.fit(height.reshape(-1,1),gender.ravel())*
一旦模型被训练，你将得到同样的确认信息。现在我们有了一个训练好的模型，让我们检查一下参数，截距( Bo )和斜率( B1 )。
*lg.coef_**lg.intercept_*
运行上面的行将显示截距值 35.212 和斜率值-0.252。因此，我们的训练模型可以写成:
我们可以使用上面的等式来预测任何给定身高的人的性别，或者我们可以直接使用如下所示的训练模型来查找身高= 140cm 的人的性别值:
*lg.predict(np.array([[140]]))*
试试上面的代码，你会明白的。请注意，该模型实际上给出了与给定类别相关的概率值，由我们来决定概率的阈值。默认值被认为是 0.5，即所有与高于 0.5 的雄性类相关联的概率值都被认为是雄性&如果小于 0.5，则雄性类的概率被认为是雌性。此外，逻辑回归中的分离边界是线性的，这可以很容易地用图形确认。
进一步阅读
这都在逻辑回归中。关于这篇文章的任何疑问，你可以通过 LinkedIn 联系我
谢谢，
祝你玩得愉快😊
原载于 2020 年 4 月 20 日 https://www.wildregressor.com。
使用 Python 的分类模型中的逻辑回归:机器学习
学习如何使用 python 构建机器学习中的基本逻辑回归模型
马库斯·温克勒在 Unsplash 上的照片
逻辑回归是各种行业(如银行、医疗保健)中常用的模型，因为与其他分类模型相比，逻辑回归模型很容易解释。
二元分类
二元分类是最常用的逻辑回归。二元分类问题的一些例子是:
- 一家金融公司想知道客户是否违约
- 预测电子邮件是否是垃圾邮件
- 无论一个人是否患有糖尿病
二元分类总是只有两种可能的结果，要么是‘是’&‘否’，要么是‘1’&‘0’等等。
就像上一篇文章《 多元线性回归模型 》中所说的，一个自变量往往不足以捕捉逻辑回归的目标变量的所有不确定性。
现在让我们在 Jupyter 笔记本中使用 python 构建一个逻辑回归模型。
对于整篇文章，我们使用来自 Kaggle 的数据集。
我们将关注电信客户流失预测数据集。它有 21 个与客户行为相关的变量，用于预测特定客户是否会转向另一家电信提供商(即，客户流失与否)。
导入必要的库和数据
首先，我们将从导入必要的库到笔记本开始，并将.csv文件转换成 pandas 数据框。
数据集看起来像这样，
作者图片— 电信流失数据集
上面数据集中的目标变量是Churn列。
检查数据帧
让我们用.shape、.describe和.info的方法检查数据帧。
代码的输出将是，
图片由作者提供— 检查数据
正如我们所看到的，数据集中有7043 rows和21 columns，数值变量的值从最小值到最大值也没有明显的跳跃，并且数据集没有空值。
数据准备
现在，让我们通过将变量中的“是”和“否”值转换为“1”和“0”来准备数据。我们将通过定义一个函数并将“是”和“否”值映射到“1”和“0”来将值映射到“1”和“0”。
映射值后，数据集如下所示。
图片由作者提供— 为二进制列映射值
创建虚拟变量 对于具有两个以上值的列，我们将创建类似于在“ 多元线性回归模型 ”文章中创建的虚拟变量。
输出将是，
作者图片— 创建虚拟变量
如果我们观察上面的数据集，列的数量从21 columns增加到29 columns。
我们正在为剩余的分类变量创建虚拟变量。
为所有变量创建虚拟变量后的数据集将是，
作者图片— 为所有剩余的列创建虚拟变量
删除原来的变量 现在我们将删除我们为其创建虚拟变量的变量，如果它们之间有任何差异，我们将转换列的数据类型。
数据集的信息看起来像，
图片由作者提供— 创建所有必要虚拟变量后的数据集
异常值和缺失值 现在，在继续建模之前，让我们再次检查数据集中的异常值和空值。
输出将是，
作者图片— 连续变量在不同百分位数的分布
从分布数据中，我们可以看到数据中没有异常值。人数在逐渐增加。
现在让我们检查数据集中缺失的值并处理数据。
作者图片— 列中的空值
让我们检查列中 null 值的百分比，以便就如何处理这些值做出明智的决定。
输出是，
作者图片— 空值的百分比
如果我们观察，Total Charges列的空值不到 0.2%。因此，最好是删除这些行，而不是向其中输入一些值。
处理空值后的输出将是，
按作者排序的图像— 删除列后空值的百分比
既然我们已经处理了空值，现在让我们继续构建模型。
模型结构
在建立模型之前，我们将数据分成train和test数据，类似于线性回归模型。因此，我们将使用train数据建立模型，并根据test数据评估模型。
测试列车分离
通过使用sklearn库，我们将导入test_train_split来分割数据。但是在分割数据之前，我们将数据集分成两个数据帧 X 和 y。
我们将删除customerID列，因为它对我们的模型没有用，并删除churn列，因为它是我们的目标变量。测试数据看起来像这样，
作者图片— 拆分后的测试数据
让我们将目标变量指定为 y，并将数据分成测试集和训练集。
“y”数据集看起来像这样，
作者图片— y 数据集
缩放变量
如果我们观察数据，数据集中的所有数值都在不同的范围内。一个在 100 以下的区间，一个在 200 的区间，还有一个在 1500 以上。如果我们使用这些值构建模型，模型的系数将是不同的单位，因此不容易比较它们来做出明智的决定。
为此，我们将重新调整所有连续变量。为此，我们将使用来自sklearn的StandardScaler方法。
缩放特征后的数据集，
按作者分类的图像— 缩放后的数据集
让我们检查从数据集中流失的客户的百分比，以了解有多少客户转移到了其他网络。
产量是 26.578498293515356
因此，我们有将近 27%的流失率。
相关
让我们看看变量之间的相关性。假设变量之间的相关性很高。在这种情况下，我们可以删除列，因为如果两个变量高度相关，那么就没有必要使用这两个变量来构建模型。我们可以用这两个变量中的一个来解释目标变量。
变量之间的关联热图看起来像这样，
由作者提供的图片— 数据集中的关联热图
如果我们观察热图，一些变量彼此高度相关。所以我们将从数据集中删除这些变量。
删除高度相关的虚拟变量 我们将从上面创建的 X_train 和 X_test 数据集中删除高度相关的变量。
现在，让我们重新检查 X_train 数据集中的相关性。
删除变量后的关联热图，
作者图片— 删除变量后的关联热图
还有一些相关性很高的变量，但是我们可以在建模的时候去掉。就这么办吧。
运行我们的第一个培训模型
我们将使用stasmodel库来构建我们的第一个模型。让我们看看，如果我们考虑所有的变量，我们的模型是什么样的。
我们第一个模型的统计数据是，
作者图片— 我们第一款的统计
上面的模型不是一个好的模型，因为一些变量具有高 p 值，这意味着这些变量是无关紧要的。我们将使用一种叫做 RFE 的方法来选择模型的前 15 个变量，并根据 p 值和 VIF 值删除不太重要的变量，而不是一次删除一个变量并一次又一次地建立模型。
使用 RFE 的特征选择
我们将选择前 15 个变量，这有助于在我们的逻辑回归中建立模型。
前 15 个变量是，
作者图片— 使用 RFE 的前 15 个变量
显示为True的变量是我们感兴趣的变量，如果我们想要添加 15 个以上的变量，我们可以根据它们各自的排名逐一添加。
使用上述 15 个变量建立模型 让我们使用从 RFE 得到的 15 个变量建立第二个模型。
模型统计将是，
图片由作者提供— 使用 RFE 变量的逻辑回归模型
这里我们使用来自statsmodels.api库的 **GLM(广义线性模型)**方法。Binomialin family 参数告诉statsmodels它需要用 logit 曲线拟合二项式数据(即目标变量只有两个值，在本例中为‘流失’和‘非流失’)。
一个简单的 logit 曲线看起来像这样，
按统计数学-自己的工作，抄送 BY-SA 4.0，https://commons.wikimedia.org/w/index.php?curid=92801334
预测产出概率 逻辑回归曲线给我们带来了搅动和不搅动的概率。我们可以通过简单地使用**‘predict’**函数来得到这些概率。
预测的概率是
按作者分类的图片-预测概率
现在，让我们创建一个包含实际流失列和预测概率的数据框架。
上述程序的数据框架如下。
按作者分类的图像——实际流失及其概率的数据框架
由于逻辑曲线给出的是概率，而不是**‘流失’和‘非流失’的实际分类，我们需要找到一个阈值概率**来将客户分类为‘流失’和‘非流失’
这里，让我们选择 0.5 作为任意临界值，其中如果特定客户流失的概率小于 0.5，我们会将其分类为**“非流失”，，如果大于 0.5，我们会将其分类为“流失”**
创建新列 在这个阶段，0.5 的选择完全是任意的，我们将学习如何在“模型评估”中找到最佳临界值
选择任意截止值后，数据帧如下所示。
按作者分类的图像—任意截断后的数据帧
这里，我们使用 0.5 的临界值将客户分为’流失客户’和’非流失客户’既然这些都是概率，那就一定会有误差。
我们会遇到两种类型的错误:
- '流失’客户被错误归类为’非流失’
- '非流失’客户被错误分类为’流失’
混淆矩阵
为了找到这些错误和模型的健康状况，我们将使用一种叫做“混淆矩阵”的现象
典型的混淆矩阵如下所示。
作者图片-混淆矩阵
注意:以上矩阵中显示的值只是一个示例
如果我们观察上面的矩阵:
- 第一行第一列(1250)是实际有’未搅过’的客户数；该模型还预测它们为“未搅动”这一列被称为真阴性(TN)。
- 第一行和第二列(150)是实际上’没有搅动，'但模型预测他们为’搅动’的客户数量这一列被称为假阳性(FP)。
- 第二行第一列(290)是实际上’搅动了，'但是模型预测他们为’没有搅动’此列称为假阴性(FN)。
- 第二行第二列(343)是实际“搅了”的客户数；此外，该模型还预测它们会被“搅动”。这一列被称为真阳性(TP)。****
我们可以通过从sklearn导入metrics库，在 python 中创建这个混淆矩阵。
上述代码的混淆矩阵如下所示。
作者图片-混淆矩阵
评估模型的方法有很多种；我们为上述模型测量的指标之一是准确性**。**
准确(性)
准确度是正确预测的标签的百分比。从矩阵中正确预测的标签将是:
- 真阳性(TP): 流失客户被预测为**流失**
- 真阴性(TN): 非流失客户被预测为非流失客户。
准确度=(正确预测的标签)/(标签总数)
准确度= (TN+TP )/ (TN+FP+FN+TP)
根据我们上面的模型，
TN = 3270
FP = 365
FN = 579
TP = 708
精确度将是，
ACC =(3270+708)/(3270+365+579+708)= 0.808 = 80.8%
我们建立的模型大约有 81%的准确性。
我们可以直接用 python 计算精度，
我们通过上面的代码得到的精度是
0.8082080455099553
检查 VIF
现在让我们检查上述模型的 VIF 值，看看是否有任何变量高度相关。
我已经在我的上一篇文章“多元线性回归”中解释了 VIF 及其工作原理我们将遵循同样的程序。
让我们看看模型中变量的 VIF 值。
按作者分类的图像-用于查找多重共线性的 VIF 值
高 VIF 有几个变量。最好放弃这些变量。变量PhoneService具有最高的 VIF。因此，让我们从放弃它开始，重新构建模型。
上面代码的模型是，
按作者分类的图像-逻辑回归模型统计
接下来，我们将预测这些值，并打印由原始流失值和预测值组成的数据帧。
数据帧看起来像这样，
按作者分类的图像-原始值和预测值的数据框架
让我们检查模型的准确性。
模型的准确性将是
0.8051605038602194
这与原来的差距并不大。我们必须重新检查 VIF 值，删除变量，建立模型，并计算精确度。我们将继续下去，直到每个变量的 VIF 值都小于 5。
对于最终的模型，在反复遵循上述过程后，我们得到的混淆矩阵是，
矩阵看起来像这样，
array([[3269, 366],
[ 595, 692]],)
最终矩阵的精确度= 0.80。18866.888888888687
现在，出现的问题是——准确性是我们用来评估我们建立的模型的好坏的唯一标准吗？
答案是否****
****考虑一个例子:假设我们试图为癌症患者建立一个逻辑回归模型，其中 1 表示患者“患癌”，0 表示患者“未患癌”在这种情况下，如果我们错误地预测一些患者“没有患癌症”，这将是非常危险的。在这种情况下，我们不考虑整体精度，而是正确预测 1。
在另一种情况下，如果我们为银行构建一个模型来阻止客户识别欺诈，其中 1 表示阻止，0 表示不阻止，我们更关心 0 是否正确。是因为我们不想把好客户挡在门外。
理解我们试图解决的整体业务问题，了解我们想要使用的度量标准是至关重要的。
因此，除了准确性，我们还有另外三个更重要的指标:
- 灵敏度/召回率
- 特异性
- 精度
灵敏度/召回率
**对于癌症类型的问题，我们使用敏感性。所以我们应该建立一个模型，这个模型的结果是高灵敏度，即 **FN(假阴性)的值应该尽可能的低。
灵敏度= (TP)/(TP+FN)
特异性
对于欺诈交易类型的案件，我们建立一个具有高特异性的模型，即 FP(False Positive) 的值应该尽可能低。
特异性= (TN)/(TN+FP)
精度
如果我们想要建立一个模型来预测一封电子邮件是否是垃圾邮件，我们将使用精确度指标。**在这种情况下，我们必须开发具有高精度的模型，即 **FP(假阳性)的值应该尽可能低。
精度= (TP)/(TP+FP)
现在，让我们找出我们之前建立的最终模型的灵敏度和特异性的值。
首先，我们将从最终矩阵中分配 TP、TN、FP 和 FN 值。
这里，混淆是我们之前创建的矩阵的名字。
现在，让我们找出不同指标的值。
上述代码的灵敏度和特异性值是，
**# Sensitivity**
0.5376845376845377**# Specificity**
0.8993122420907841
因此，我们的模型具有高准确性(80.4%)** 和高特异性(89.9%) ，但低****【53.7%)，我们对识别可能流失的客户感兴趣，因此我们需要处理这一点。但是是什么导致了如此低的敏感度呢？**
如果我们记得，当预测模型为 0 和 1 时，我们选择了 0.5 的截止值，这个截止值是随机选择的，没有特定的逻辑。
预测的标签完全取决于我们选择的截止值。对于低截止值，我们将有更多的客户预测为 1，这意味着更多的客户被识别为“流失”类似地，对于高截止值，我们将低数量的客户预测为 0，这意味着高数量的客户被识别为“非流失客户”
寻找最佳截止点
在我们的问题中，我们试图找到一个最佳的临界值，在灵敏度和特异性之间取得平衡。首先，我们将找到从 0.1 到 0.9 的不同临界值的预测值
不同截止值下的流失概率看起来像，
按作者分类的图像—不同截止点的流失概率
现在，让我们计算这些临界值的准确性、敏感性和特异性。
度量的不同值将是，
按作者分类的图像—准确性、敏感性和特异性值
让我们绘制一个线形图，看看在这些概率下准确性、敏感性和特异性是如何表现的。
线形图如下所示，
按作者分类的图像-折线图
从上面的曲线来看，0.3 或稍大一点是将其作为截止概率的最佳点。为了便于理解，我们将 0.3 作为临界值。
让我们使用这个 0.3 作为最终截止值来预测模型。
输出将是
作者图片—最终预测
让我们找出准确性、特异性、敏感性和混淆矩阵。
上述代码的输出是:
**# Accuracy**
0.771434376269809**# Confusion Matrix** array([[2793, 842],
[ 283, 1004]])**# Sensitivity**
0.7801087801087802**# Specificity** 0.768363136176066
既然我们有了最终的模型，让我们根据测试数据来评估我们的模型。
模型评估
让我们使用最终模型对测试数据进行预测。首先，我们将扩展测试数据，类似于我们在分割后对训练数据所做的那样。
测试集看起来像这样，
按作者排序的图像—缩放后的测试集
让我们现在对测试数据进行预测，仔细遵循下面的代码；我们正在对数据集进行许多更改。
最终数据集是在所有更改完成后生成的，
按作者分类的图像-最终数据集
为了便于理解，让我们重命名该列并重新排列它们。
数据集看起来像，
按作者分类的图像-最终数据集
让我们使用 0.3 作为截止值来预测模型，这是我们之前在训练数据集上获得的。
测试集的预测值是，
按作者分类的图像-预测值
让我们检查测试数据的准确性、敏感性和特异性值，并进行比较。
测试集的值是:
**# Accuracy**
0.7440758293838863**# Confusion Matrix**
array([[1150, 378],
[ 162, 420]],) **# Sensitivity**
0.7216494845360825**# Specificity** 0.7526178010471204
如果我们比较训练数据集的准确性，敏感性和特异性值，没有太大的变化。因此，我们建立的模型足以预测任何未来的电信数据。
结论
总而言之，我们已经看到了构建基本逻辑回归模型所需的步骤。我们还可以学习更多的概念，如 ROC 曲线、精确度、召回率等。但是要构建一个基本的逻辑回归模型，我们在本文中看到的过程已经足够好了。一旦我们掌握了这个过程，我们就可以在这个模型中探索更多的东西。
感谢您阅读和快乐编码！！！
点击这里查看我以前的文章
- 使用 Python 的多元线性回归模型:机器学习
- 使用 Python 的简单线性回归模型:机器学习
- 探索性数据分析(EDA): Python
- 中心极限定理(CLT):数据科学
- 推断统计:数据分析
- Seaborn:Python
- 熊猫:蟒蛇
- Matplotlib:Python
- NumPy: Python
参考
- ****机器学习—逻辑回归:https://www . tutorialspoint . com/Machine _ Learning _ with _ python/Machine _ Learning _ with _ python _ classification _ algorithms _ Logistic _ Regression . htm
- ****逻辑回归:https://machine learning mastery . com/Logistic-Regression-for-machine-learning/
- ****逻辑回归:https://ml-cheat sheet . readthedocs . io/en/latest/Logistic _ Regression . html
- ****用于机器学习和分类的逻辑回归:https://kambria . io/blog/Logistic-Regression-For-Machine-Learning/
Python 中的逻辑回归
详细的逻辑回归
照片由 Trace Hudson 从 Pexels
Python 中的逻辑回归
逻辑回归用于机器学习中的分类问题。它用于处理二值分类和多值分类。在逻辑回归中，目标变量/因变量应该是离散值或分类值。
二元分类→ 有两个类值的问题比如男/女，是/否，真/假，0/1，通过/失败。
多类分类→ 超过 2 个类值的问题。
让我们在这个故事中了解一下二元分类的逻辑回归。
涵盖的主题
- 为什么不是线性回归？
- Sigmoid 或 Logit 函数
- 对数损失函数
- 准确度分数
- 为什么称之为逻辑回归？
- 线性回归与逻辑回归
- 使用 sklearn 实现逻辑回归
为什么不是线性回归
问题:如果一个学生学习了 x 个小时，他通过的可能性有多大？
这是一个分类问题。这里我们必须预测一个学生通过/失败的可能性。在逻辑回归中，目标变量不应该是字符串类型。我们必须将通过/失败转换为 0/1。所以，预测的范围是从 0 到 1。但在线性回归中，范围是从 -∞到+∞。
如果我们想预测一个学生学习 x 个小时所获得的分数，这将是一个线性回归问题。
让我们取大约 20 名学生的数据，学习时间与结果(通过/失败)
作者图片
从数据点来看，我们可以解释，学习时间越长，结果越倾向于 1(通过)。
如果我们试着拟合一条线性回归线，它会是这样的。
作者图片
线性回归线范围从 -∞到+∞。但是对于我们的分类问题，结果应该属于 0 或 1，或者我们必须预测介于 0 和 1 之间的概率。
我们的数据看起来不像是一条直线。我们强行排成一条直线。大部分数据点没有经过那条直线。
解决方法:
1。我们的线应该穿过大部分数据点。
2。它应该介于 0 和 1 之间。
3。类似于S curve的东西会穿过大多数数据点。
4。使用 sigmoid 函数将最佳拟合线转换成 S 曲线。
线性回归方程: y=mx+c
作者图片
使用此公式将最佳拟合线转换为 S 曲线。
作者图片
Sigmoid 或 logit 函数
我们来看看 sigmoid 公式的解释。该函数也称为 Logit 函数。
作者图片
e →欧拉常数
作者图片
因此，通过使用 sigmoid 方程，我们可以保证 y 总是在 0 和 1 之间。
这个等式还有另一种解释。
作者图片
这两个等式是一样的。
对数损失函数
方程中 m 和 c 怎么算？
在线性回归方程中，最佳拟合线将最小化平方和误差。通过找出观察值和预测值之间的差异来计算误差平方和。我们把所有的误差平方，然后求和。
在逻辑回归方程中，最佳曲线将最小化 logloss 函数。
作者图片
y 值将始终为 0 或 1。
ŷ值将介于 0 和 1 之间。
有两种情况
- 如果 y=0
logloss=-log(1-ŷ)
(因为ylog(ŷ)会变成 0)
2.如果 y=1
logloss=-log(ŷ)
[因为log(1-ŷ)会变成 0]
通过最小化 logloss 函数，观测值和预测值会更接近。
准确度分数
准确度分数用于确定模型的整体预测准确度。
混淆矩阵
混淆矩阵是一个表格，通常用于描述一个分类模型对一组真实值已知的测试数据的性能。矩阵的每一行代表预测类中的实例，而每一列代表实际类中的实例(反之亦然)
作者图片
TP →真阳性
FP →假阳性
FN →假阴性
TN →真阴性
准确度得分
作者图片
为什么称之为逻辑回归？
术语**“逻辑”来源于用于分类的“逻辑函数”。
使用术语“回归”是因为我们使用了类似于线性回归的技术。**
线性回归与逻辑回归
作者图片
使用 sklearn 实现逻辑回归
- 导入库
- 加载数据
- 电子设计自动化(Electronic Design Automation)
- 数据争论(清理数据)
- 将特征分配给 x 和 y
- 培训和测试
- 计算准确度
- 预言；预测；预告
1。导入库
**import** numpy **as** np
**import** pandas **as** pd
**import** seaborn **as** sns
**import** matplotlib.pyplot **as** plt
2。加载数据
数据集 results.csv 包含小时与结果。[学生学习的小时数与他们的成绩通过/未通过]。它包含 StudentId列也。
df=pd.read_csv(**"results.csv"**)
df.head(5)
df.shape
(20,3)
数据集包含 20 行和 3 列
df.info()
它包含三列 Hours、StudentID 和 Result
3。EDA
通过创建不同的图来分析数据，以检查变量之间的关系。
sns.countplot(x=**"Result"**,data=df)
散点图
plt.scatter(df.Hours,df.Result,color=**'red'**)
plt.xlabel(**"Hours"**)
plt.ylabel(**"Pass"**)
从散点图中，我们可以看出学习时间越长的学生越有可能通过考试。
4。数据争论
- 检查是否有数据缺失
df.isnull().sum()
只有小时列有两个缺失数据。我们可以不排了。如果我们的数据集有许多列，意味着我们不能删除行。我们可能需要来自其他列的数据，在这种情况下，我们可以通过均值替换缺失的值。
df.dropna(inplace=**True**)
df.shape
(18,3)
删除缺少值的两行。现在数据集中只有 18 行。
- 移除不需要的柱
在我们的数据集中，不需要StudentID列。我们不打算对 StudentID 列进行任何分析。我们将根据学生学习的小时数来预测结果。
df1=df.drop(**"StudentId"**,axis=1)
df1.head()
StudentID列现在已从数据集中删除。
- 在逻辑回归中，它不会处理字符串数据类型。我们要预测结果→通过/失败。我们可以将该列转换为离散变量 0 和 1。
result=pd.get_dummies(df[**"Result"**])
result.head(3)
现在，我们可以保留失败/通过列，删除另一列。
result=pd.get_dummies(df[**"Result"**],drop_first=**True**)
result.head(3)
在“通过”列中，0 表示失败，1 表示通过。
现在将传递列连接到数据帧
df1=pd.concat([df1,result],axis=1)
df1.head(3)
现在我们可以从 dataframe 中删除Result列。我们已经将结果列转换为Pass列。
df1=df1.drop(**"Result"**,axis=1)
df1.head(3)
5。给 x 和 y 分配特征
x=df1.iloc[:,0:1]
x.head(3)
y=df1.iloc[:,1:]
y.head(3)
6.训练和测试数据
**from** sklearn.model_selection **import** train_test_split
xtrain,xtest,ytrain,ytest=train_test_split(x,y,test_size=0.2,random_state=2)
**from** sklearn.linear_model **import** LogisticRegression
log_reg=LogisticRegression()
log_reg.fit(xtrain,ytrain)
7.计算准确度
predictions=log_reg.predict(xtest)
**from** sklearn.metrics **import** confusion_matrix
cm=confusion_matrix(ytest,predictions)
print (cm)
输出: [[2 1]
[0 1]]
**from** sklearn.metrics **import** accuracy_score
accuracy_score(ytest,predictions)
输出: 0.75
准确度得分为 0.75。
根据混淆矩阵计算准确度分数[图片由作者提供]
8.预言；预测；预告
我们来预测一下，如果一个学生学习 7 个小时，这个学生通过的可能性有多大？
log_reg.predict(np.array([[7]]))
**输出:**数组([1]，dtype=uint8)
1表示通过。
预测概率
log_reg.predict_proba(np.array([[7]]))
**输出:**数组([[0.00182823，0.99817177]])
0.00182823 →表示学生不及格的概率
0.99817177 →表示学生及格的概率
Github 链接。
这里使用的代码可以作为 Jupyter 笔记本从我的 GitHub 下载。
我关于机器学习的其他博客
相关系数、决定系数、模型系数
towardsdatascience.com](/line-of-best-fit-in-linear-regression-13658266fbc8) [## 支持向量机简介
如何在分类问题中使用 SVM？
towardsdatascience.com](/an-introduction-to-support-vector-machine-3f353241303b) [## K-最近邻算法简介
什么是 KNN？
towardsdatascience.com](/an-introduction-to-k-nearest-neighbours-algorithm-3ddc99883acd) [## 机器学习中的朴素贝叶斯分类器
使用 sklearn 的数学解释和 python 实现
pub.towardsai.net](https://pub.towardsai.net/naive-bayes-classifier-in-machine-learning-b0201684607c) [## 机器学习中的朴素贝叶斯分类器
使用 sklearn 的数学解释和 python 实现
pub.towardsai.net](https://pub.towardsai.net/naive-bayes-classifier-in-machine-learning-b0201684607c)
请关注此空间，了解更多关于 Python 和数据科学的文章。如果你喜欢看我的更多教程，就关注我的 中LinkedInTwitter。**
点击此处成为中等会员:
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
