本文是吴恩达老师的机器学习课程[1]的笔记和代码复现部分（逻辑回归）。
作者：黄海广[2]
备注：笔记和作业（含数据、原始作业文件）、视频都在github[3]中下载。
我将陆续将课程笔记和课程代码发布在公众号“机器学习初学者”，敬请关注。这个是第二部分：逻辑回归，是原教程的第三周，包含了笔记和作业代码（原课程作业是 OCTAVE 的，这里是复现的 python 代码）
本文作业代码[4]可以下载完整版
笔记的markdown 文件[5]
笔记的pdf 文件[6]
笔记部分目录
六、逻辑回归(Logistic Regression)
- 6.1 分类问题
- 6.2 假说表示
- 6.3 判定边界
- 6.4 代价函数
- 6.5 简化的成本函数和梯度下降
- 6.6 高级优化
- 6.7 多类别分类：一对多
七、正则化(Regularization)
- 7.1 过拟合的问题
- 7.2 代价函数
- 7.3 正则化线性回归
- 7.4 正则化的逻辑回归模型
六、逻辑回归(Logistic Regression)
6.1 分类问题
参考文档: 6 - 1 - Classification (8 min).mkv
在这个以及接下来的几个视频中，开始介绍分类问题。
在分类问题中，你要预测的变量 是离散的值，我们将学习一种叫做逻辑回归 (Logistic Regression) 的算法，这是目前最流行使用最广泛的一种学习算法。
在分类问题中，我们尝试预测的是结果是否属于某一个类（例如正确或错误）。分类问题的例子有：判断一封电子邮件是否是垃圾邮件；判断一次金融交易是否是欺诈；之前我们也谈到了肿瘤分类问题的例子，区别一个肿瘤是恶性的还是良性的。
我们从二元的分类问题开始讨论。
我们将因变量(dependent variable)可能属于的两个类分别称为负向类（negative class）和正向类（positive class），则因变量 ，其中 0 表示负向类，1 表示正向类。
如果我们要用线性回归算法来解决一个分类问题，对于分类， 取值为 0 或者 1，但如果你使用的是线性回归，那么假设函数的输出值可能远大于 1，或者远小于 0，即使所有训练样本的标签 都等于 0 或 1。尽管我们知道标签应该取值 0 或者 1，但是如果算法得到的值远大于 1 或者远小于 0 的话，就会感觉很奇怪。所以我们在接下来的要研究的算法就叫做逻辑回归算法，这个算法的性质是：它的输出值永远在 0 到 1 之间。
顺便说一下，逻辑回归算法是分类算法，我们将它作为分类算法使用。有时候可能因为这个算法的名字中出现了“回归”使你感到困惑，但逻辑回归算法实际上是一种分类算法，它适用于标签 取值离散的情况，如：1 0 0 1。
在接下来的视频中，我们将开始学习逻辑回归算法的细节。
6.2 假说表示
参考视频: 6 - 2 - Hypothesis Representation (7 min).mkv
在这段视频中，我要给你展示假设函数的表达式，也就是说，在分类问题中，要用什么样的函数来表示我们的假设。此前我们说过，希望我们的分类器的输出值在 0 和 1 之间，因此，我们希望想出一个满足某个性质的假设函数，这个性质是它的预测值要在 0 和 1 之间。
回顾在一开始提到的乳腺癌分类问题，我们可以用线性回归的方法求出适合数据的一条直线：
根据线性回归模型我们只能预测连续的值，然而对于分类问题，我们需要输出 0 或 1，我们可以预测：
当 时，预测 。
当 时，预测 。
对于上图所示的数据，这样的一个线性模型似乎能很好地完成分类任务。假使我们又观测到一个非常大尺寸的恶性肿瘤，将其作为实例加入到我们的训练集中来，这将使得我们获得一条新的直线。
这时，再使用 0.5 作为阀值来预测肿瘤是良性还是恶性便不合适了。可以看出，线性回归模型，因为其预测的值可以超越[0,1]的范围，并不适合解决这样的问题。
我们引入一个新的模型，逻辑回归，该模型的输出变量范围始终在 0 和 1 之间。逻辑回归模型的假设是： 其中： 代表特征向量 代表逻辑函数（logistic function)是一个常用的逻辑函数为S形函数（Sigmoid function），公式为： 。
python代码实现：
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-z))
该函数的图像为：
合起来，我们得到逻辑回归模型的假设：
对模型的理解： 。
的作用是，对于给定的输入变量，根据选择的参数计算输出变量=1 的可能性（estimated probablity）即 例如，如果对于给定的 ，通过已经确定的参数计算得出 ，则表示有 70%的几率 为正向类，相应地 为负向类的几率为 1-0.7=0.3。
6.3 判定边界
参考视频: 6 - 3 - Decision Boundary (15 min).mkv
现在讲下决策边界(decision boundary)的概念。这个概念能更好地帮助我们理解逻辑回归的假设函数在计算什么。
在逻辑回归中，我们预测：
当 时，预测 。
当 时，预测 。
根据上面绘制出的 S 形函数图像，我们知道当
时
时
时
又 ，即： 时，预测 时，预测
现在假设我们有一个模型：
并且参数 是向量[-3 1 1]。则当 ，即 时，模型将预测 。我们可以绘制直线 ，这条线便是我们模型的分界线，将预测为 1 的区域和预测为 0 的区域分隔开。
假使我们的数据呈现这样的分布情况，怎样的模型才能适合呢？
因为需要用曲线才能分隔 的区域和 的区域，我们需要二次方特征：是[-1 0 0 1 1]，则我们得到的判定边界恰好是圆点在原点且半径为 1 的圆形。
我们可以用非常复杂的模型来适应非常复杂形状的判定边界。
6.4 代价函数
参考视频: 6 - 4 - Cost Function (11 min).mkv
在这段视频中，我们要介绍如何拟合逻辑回归模型的参数 。具体来说，我要定义用来拟合参数的优化目标或者叫代价函数，这便是监督学习问题中的逻辑回归模型的拟合问题。
对于线性回归模型，我们定义的代价函数是所有模型误差的平方和。理论上来说，我们也可以对逻辑回归模型沿用这个定义，但是问题在于，当我们将 带入到这样定义了的代价函数中时，我们得到的代价函数将是一个非凸函数（non-convexfunction）。
这意味着我们的代价函数有许多局部最小值，这将影响梯度下降算法寻找全局最小值。
线性回归的代价函数为： 。我们重新定义逻辑回归的代价函数为：，其中
与 之间的关系如下图所示：
这样构建的 函数的特点是：当实际的 且 也为 1 时误差为 0，当 但 不为 1 时误差随着 变小而变大；当实际的 且 也为 0 时代价为 0，当 但 不为 0 时误差随着 的变大而变大。将构建的 简化如下： 带入代价函数得到： 即：
Python代码实现：
import numpy as np
def cost(theta, X, y):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
first = np.multiply(-y, np.log(sigmoid(X* theta.T)))
second = np.multiply((1 - y), np.log(1 - sigmoid(X* theta.T)))
return np.sum(first - second) / (len(X))
在得到这样一个代价函数以后，我们便可以用梯度下降算法来求得能使代价函数最小的参数了。算法为：
Repeat { (simultaneously update all ) }
求导后得到：
Repeat { (simultaneously update all ) }
在这个视频中，我们定义了单训练样本的代价函数，凸性分析的内容是超出这门课的范围的，但是可以证明我们所选的代价值函数会给我们一个凸优化问题。代价函数 会是一个凸函数，并且没有局部最优值。
推导过程：
考虑： 则：
所以：
注：虽然得到的梯度下降算法表面上看上去与线性回归的梯度下降算法一样，但是这里的 与线性回归中不同，所以实际上是不一样的。另外，在运行梯度下降算法之前，进行特征缩放依旧是非常必要的。
一些梯度下降算法之外的选择：除了梯度下降算法以外，还有一些常被用来令代价函数最小的算法，这些算法更加复杂和优越，而且通常不需要人工选择学习率，通常比梯度下降算法要更加快速。这些算法有：共轭梯度（Conjugate Gradient），局部优化法(Broyden fletcher goldfarb shann,BFGS)和有限内存局部优化法(LBFGS) 。
6.5 简化的成本函数和梯度下降
参考视频: 6 - 5 - Simplified Cost Function and Gradient Descent (10 min).mkv
在这段视频中，我们将会找出一种稍微简单一点的方法来写代价函数，来替换我们现在用的方法。同时我们还要弄清楚如何运用梯度下降法，来拟合出逻辑回归的参数。因此，听了这节课，你就应该知道如何实现一个完整的逻辑回归算法。
这就是逻辑回归的代价函数：
这个式子可以合并成：
即，逻辑回归的代价函数：
根据这个代价函数，为了拟合出参数，该怎么做呢？我们要试图找尽量让 取得最小值的参数 。 所以我们想要尽量减小这一项，这将我们将得到某个参数 。如果我们给出一个新的样本，假如某个特征 ，我们可以用拟合训练样本的参数 ，来输出对假设的预测。另外，我们假设的输出，实际上就是这个概率值： ，就是关于 以 为参数， 的概率，你可以认为我们的假设就是估计 的概率，所以，接下来就是弄清楚如何最大限度地最小化代价函数 ，作为一个关于 的函数，这样我们才能为训练集拟合出参数 。
最小化代价函数的方法，是使用梯度下降法(gradient descent)。这是我们的代价函数：
如果我们要最小化这个关于 的函数值，这就是我们通常用的梯度下降法的模板。
我们要反复更新每个参数，用这个式子来更新，就是用它自己减去学习率 乘以后面的微分项。求导后得到：
如果你计算一下的话，你会得到这个等式： 我把它写在这里，将后面这个式子，在 到 上求和，其实就是预测误差乘以 ，所以你把这个偏导数项 放回到原来式子这里，我们就可以将梯度下降算法写作如下形式：
所以，如果你有 个特征，也就是说：，参数向量 包括 一直到 ，那么你就需要用这个式子：
来同时更新所有 的值。
现在，如果你把这个更新规则和我们之前用在线性回归上的进行比较的话，你会惊讶地发现，这个式子正是我们用来做线性回归梯度下降的。
那么，线性回归和逻辑回归是同一个算法吗？要回答这个问题，我们要观察逻辑回归看看发生了哪些变化。实际上，假设的定义发生了变化。
对于线性回归假设函数：
而现在逻辑函数假设函数：
因此，即使更新参数的规则看起来基本相同，但由于假设的定义发生了变化，所以逻辑函数的梯度下降，跟线性回归的梯度下降实际上是两个完全不同的东西。
在先前的视频中，当我们在谈论线性回归的梯度下降法时，我们谈到了如何监控梯度下降法以确保其收敛，我通常也把同样的方法用在逻辑回归中，来监测梯度下降，以确保它正常收敛。
当使用梯度下降法来实现逻辑回归时，我们有这些不同的参数 ，就是 一直到 ，我们需要用这个表达式来更新这些参数。我们还可以使用 for 循环来更新这些参数值，用 for i=1 to n，或者 for i=1 to n+1。当然，不用 for 循环也是可以的，理想情况下，我们更提倡使用向量化的实现，可以把所有这些 个参数同时更新。
最后还有一点，我们之前在谈线性回归时讲到的特征缩放，我们看到了特征缩放是如何提高梯度下降的收敛速度的，这个特征缩放的方法，也适用于逻辑回归。如果你的特征范围差距很大的话，那么应用特征缩放的方法，同样也可以让逻辑回归中，梯度下降收敛更快。
就是这样，现在你知道如何实现逻辑回归，这是一种非常强大，甚至可能世界上使用最广泛的一种分类算法。
6.6 高级优化
参考视频: 6 - 6 - Advanced Optimization (14 min).mkv
在上一个视频中，我们讨论了用梯度下降的方法最小化逻辑回归中代价函数 。在本次视频中，我会教你们一些高级优化算法和一些高级的优化概念，利用这些方法，我们就能够使通过梯度下降，进行逻辑回归的速度大大提高，而这也将使算法更加适合解决大型的机器学习问题，比如，我们有数目庞大的特征量。现在我们换个角度来看什么是梯度下降，我们有个代价函数 ，而我们想要使其最小化，那么我们需要做的是编写代码，当输入参数 时，它们会计算出两样东西： 以及 等于 0、1 直到 时的偏导数项。
假设我们已经完成了可以实现这两件事的代码，那么梯度下降所做的就是反复执行这些更新。另一种考虑梯度下降的思路是：我们需要写出代码来计算 和这些偏导数，然后把这些插入到梯度下降中，然后它就可以为我们最小化这个函数。对于梯度下降来说，我认为从技术上讲，你实际并不需要编写代码来计算代价函数 。你只需要编写代码来计算导数项，但是，如果你希望代码还要能够监控这些 的收敛性，那么我们就需要自己编写代码来计算代价函数 和偏导数项 。所以，在写完能够计算这两者的代码之后，我们就可以使用梯度下降。然而梯度下降并不是我们可以使用的唯一算法，还有其他一些算法，更高级、更复杂。如果我们能用这些方法来计算代价函数 和偏导数项 两个项的话，那么这些算法就是为我们优化代价函数的不同方法，共轭梯度法 BFGS (变尺度法) 和L-BFGS (限制变尺度法) 就是其中一些更高级的优化算法，它们需要有一种方法来计算 ，以及需要一种方法计算导数项，然后使用比梯度下降更复杂的算法来最小化代价函数。这三种算法的具体细节超出了本门课程的范畴。实际上你最后通常会花费很多天，或几周时间研究这些算法，你可以专门学一门课来提高数值计算能力，不过让我来告诉你他们的一些特性：
这三种算法有许多优点：
一个是使用这其中任何一个算法，你通常不需要手动选择学习率 ，所以对于这些算法的一种思路是，给出计算导数项和代价函数的方法，你可以认为算法有一个智能的内部循环，而且，事实上，他们确实有一个智能的内部循环，称为线性搜索(line search)算法，它可以自动尝试不同的学习速率 ，并自动选择一个好的学习速率 ，因此它甚至可以为每次迭代选择不同的学习速率，那么你就不需要自己选择。这些算法实际上在做更复杂的事情，不仅仅是选择一个好的学习速率，所以它们往往最终比梯度下降收敛得快多了，不过关于它们到底做什么的详细讨论，已经超过了本门课程的范围。
这部分略
我希望你们从这个幻灯片中学到的主要内容是：写一个函数，它能返回代价函数值、梯度值，因此要把这个应用到逻辑回归，或者甚至线性回归中，你也可以把这些优化算法用于线性回归，你需要做的就是输入合适的代码来计算这里的这些东西。
现在你已经知道如何使用这些高级的优化算法，有了这些算法，你就可以使用一个复杂的优化库，它让算法使用起来更模糊一点。因此也许稍微有点难调试，不过由于这些算法的运行速度通常远远超过梯度下降。
所以当我有一个很大的机器学习问题时，我会选择这些高级算法，而不是梯度下降。有了这些概念，你就应该能将逻辑回归和线性回归应用于更大的问题中，这就是高级优化的概念。
在下一个视频，我想要告诉你如何修改你已经知道的逻辑回归算法，然后使它在多类别分类问题中也能正常运行。
6.7 多类别分类：一对多
参考视频: 6 - 7 - Multiclass Classification_ One-vs-all (6 min).mkv
在本节视频中，我们将谈到如何使用逻辑回归 (logistic regression)来解决多类别分类问题，具体来说，我想通过一个叫做"一对多" (one-vs-all) 的分类算法。
先看这样一些例子。
第一个例子：假如说你现在需要一个学习算法能自动地将邮件归类到不同的文件夹里，或者说可以自动地加上标签，那么，你也许需要一些不同的文件夹，或者不同的标签来完成这件事，来区分开来自工作的邮件、来自朋友的邮件、来自家人的邮件或者是有关兴趣爱好的邮件，那么，我们就有了这样一个分类问题：其类别有四个，分别用 、 、 、 来代表。
第二个例子是有关药物诊断的，如果一个病人因为鼻塞来到你的诊所，他可能并没有生病，用 这个类别来代表；或者患了感冒，用 来代表；或者得了流感用 来代表。
第三个例子：如果你正在做有关天气的机器学习分类问题，那么你可能想要区分哪些天是晴天、多云、雨天、或者下雪天，对上述所有的例子， 可以取一个很小的数值，一个相对"谨慎"的数值，比如 1 到 3、1 到 4 或者其它数值，以上说的都是多类分类问题，顺便一提的是，对于下标是 0 1 2 3，还是 1 2 3 4 都不重要，我更喜欢将分类从 1 开始标而不是 0，其实怎样标注都不会影响最后的结果。
然而对于之前的一个，二元分类问题，我们的数据看起来可能是像这样：
对于一个多类分类问题，我们的数据集或许看起来像这样：
我用 3 种不同的符号来代表 3 个类别，问题就是给出 3 个类型的数据集，我们如何得到一个学习算法来进行分类呢？
我们现在已经知道如何进行二元分类，可以使用逻辑回归，对于直线或许你也知道，可以将数据集一分为二为正类和负类。用一对多的分类思想，我们可以将其用在多类分类问题上。
下面将介绍如何进行一对多的分类工作，有时这个方法也被称为"一对余"方法。
现在我们有一个训练集，好比上图表示的有 3 个类别，我们用三角形表示 ，方框表示 ，叉叉表示 。我们下面要做的就是使用一个训练集，将其分成 3 个二元分类问题。
我们先从用三角形代表的类别 1 开始，实际上我们可以创建一个，新的"伪"训练集，类型 2 和类型 3 定为负类，类型 1 设定为正类，我们创建一个新的训练集，如下图所示的那样，我们要拟合出一个合适的分类器。
这里的三角形是正样本，而圆形代表负样本。可以这样想，设置三角形的值为 1，圆形的值为 0，下面我们来训练一个标准的逻辑回归分类器，这样我们就得到一个正边界。
为了能实现这样的转变，我们将多个类中的一个类标记为正向类（ ），然后将其他所有类都标记为负向类，这个模型记作 。接着，类似地第我们选择另一个类标记为正向类（ ），再将其它类都标记为负向类，将这个模型记作 ,依此类推。最后我们得到一系列的模型简记为： 其中：
最后，在我们需要做预测时，我们将所有的分类机都运行一遍，然后对每一个输入变量，都选择最高可能性的输出变量。
总之，我们已经把要做的做完了，现在要做的就是训练这个逻辑回归分类器： ， 其中 对应每一个可能的 ，最后，为了做出预测，我们给出输入一个新的 值，用这个做预测。我们要做的就是在我们三个分类器里面输入 ，然后我们选择一个让 最大的 ，即 。
你现在知道了基本的挑选分类器的方法，选择出哪一个分类器是可信度最高效果最好的，那么就可认为得到一个正确的分类，无论 值是多少，我们都有最高的概率值，我们预测 就是那个值。这就是多类别分类问题，以及一对多的方法，通过这个小方法，你现在也可以将逻辑回归分类器用在多类分类的问题上。
七、正则化(Regularization)
7.1 过拟合的问题
参考视频: 7 - 1 - The Problem of Overfitting (10 min).mkv
到现在为止，我们已经学习了几种不同的学习算法，包括线性回归和逻辑回归，它们能够有效地解决许多问题，但是当将它们应用到某些特定的机器学习应用时，会遇到过拟合(over-fitting)的问题，可能会导致它们效果很差。
在这段视频中，我将为你解释什么是过度拟合问题，并且在此之后接下来的几个视频中，我们将谈论一种称为正则化(regularization)的技术，它可以改善或者减少过度拟合问题。
如果我们有非常多的特征，我们通过学习得到的假设可能能够非常好地适应训练集（代价函数可能几乎为 0），但是可能会不能推广到新的数据。
下图是一个回归问题的例子：
第一个模型是一个线性模型，欠拟合，不能很好地适应我们的训练集；第三个模型是一个四次方的模型，过于强调拟合原始数据，而丢失了算法的本质：预测新数据。我们可以看出，若给出一个新的值使之预测，它将表现的很差，是过拟合，虽然能非常好地适应我们的训练集但在新输入变量进行预测时可能会效果不好；而中间的模型似乎最合适。
分类问题中也存在这样的问题：
就以多项式理解， 的次数越高，拟合的越好，但相应的预测的能力就可能变差。
问题是，如果我们发现了过拟合问题，应该如何处理？
- 丢弃一些不能帮助我们正确预测的特征。可以是手工选择保留哪些特征，或者使用一些模型选择的算法来帮忙（例如PCA）
- 正则化。保留所有的特征，但是减少参数的大小（magnitude）。
7.2 代价函数
参考视频: 7 - 2 - Cost Function (10 min).mkv
上面的回归问题中如果我们的模型是： 我们可以从之前的事例中看出，正是那些高次项导致了过拟合的产生，所以如果我们能让这些高次项的系数接近于 0 的话，我们就能很好的拟合了。所以我们要做的就是在一定程度上减小这些参数 的值，这就是正则化的基本方法。我们决定要减少 和 的大小，我们要做的便是修改代价函数，在其中 和 设置一点惩罚。这样做的话，我们在尝试最小化代价时也需要将这个惩罚纳入考虑中，并最终导致选择较小一些的 和 。修改后的代价函数如下：
通过这样的代价函数选择出的 和 对预测结果的影响就比之前要小许多。假如我们有非常多的特征，我们并不知道其中哪些特征我们要惩罚，我们将对所有的特征进行惩罚，并且让代价函数最优化的软件来选择这些惩罚的程度。这样的结果是得到了一个较为简单的能防止过拟合问题的假设：
其中 又称为正则化参数（**Regularization Parameter**）。注：根据惯例，我们不对 进行惩罚。经过正则化处理的模型与原模型的可能对比如下图所示：
如果选择的正则化参数 过大，则会把所有的参数都最小化了，导致模型变成 ，也就是上图中红色直线所示的情况，造成欠拟合。那为什么增加的一项 可以使 的值减小呢？因为如果我们令 的值很大的话，为了使Cost Function 尽可能的小，所有的 的值（不包括 ）都会在一定程度上减小。但若 的值太大了，那么 （不包括 ）都会趋近于 0，这样我们所得到的只能是一条平行于 轴的直线。所以对于正则化，我们要取一个合理的 的值，这样才能更好的应用正则化。回顾一下代价函数，为了使用正则化，让我们把这些概念应用到到线性回归和逻辑回归中去，那么我们就可以让他们避免过度拟合了。
7.3 正则化线性回归
参考视频: 7 - 3 - Regularized Linear Regression (11 min).mkv
对于线性回归的求解，我们之前推导了两种学习算法：一种基于梯度下降，一种基于正规方程。
正则化线性回归的代价函数为：
如果我们要使用梯度下降法令这个代价函数最小化，因为我们未对 进行正则化，所以梯度下降算法将分两种情形：
{
}
对上面的算法中 时的更新式子进行调整可得：
可以看出，正则化线性回归的梯度下降算法的变化在于，每次都在原有算法更新规则的基础上令 值减少了一个额外的值。
我们同样也可以利用正规方程来求解正则化线性回归模型，方法如下所示：
图中的矩阵尺寸为 。
7.4 正则化的逻辑回归模型
参考视频: 7 - 4 - Regularized Logistic Regression (9 min).mkv
针对逻辑回归问题，我们在之前的课程已经学习过两种优化算法：我们首先学习了使用梯度下降法来优化代价函数 ，接下来学习了更高级的优化算法，这些高级优化算法需要你自己设计代价函数 。
自己计算导数同样对于逻辑回归，我们也给代价函数增加一个正则化的表达式，得到代价函数：
Python代码：
import numpy as np
def costReg(theta, X, y, learningRate):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
first = np.multiply(-y, np.log(sigmoid(X*theta.T)))
second = np.multiply((1 - y), np.log(1 - sigmoid(X*theta.T)))
reg = (learningRate / (2 * len(X))* np.sum(np.power(theta[:,1:theta.shape[1]],2))
return np.sum(first - second) / (len(X)) + reg
要最小化该代价函数，通过求导，得出梯度下降算法为：
{
}
注：看上去同线性回归一样，但是知道 ，所以与线性回归不同。Octave 中，我们依旧可以用 fminuc 函数来求解代价函数最小化的参数，值得注意的是参数 的更新规则与其他情况不同。注意：
- 虽然正则化的逻辑回归中的梯度下降和正则化的线性回归中的表达式看起来一样，但由于两者的 不同所以还是有很大差别。
- 不参与其中的任何一个正则化。
目前大家对机器学习算法可能还只是略懂，但是一旦你精通了线性回归、高级优化算法和正则化技术，坦率地说，你对机器学习的理解可能已经比许多工程师深入了。现在，你已经有了丰富的机器学习知识，目测比那些硅谷工程师还厉害，或者用机器学习算法来做产品。
接下来的课程中，我们将学习一个非常强大的非线性分类器，无论是线性回归问题，还是逻辑回归问题，都可以构造多项式来解决。你将逐渐发现还有更强大的非线性分类器，可以用来解决多项式回归问题。我们接下来将将学会，比现在解决问题的方法强大 N 倍的学习算法。
代码部分
机器学习练习 2 - 逻辑回归
这个笔记包含了以 Python 为编程语言的 Coursera 上机器学习的第二次编程练习。请参考 作业文件[1] 详细描述和方程。在这一次练习中，我们将要实现逻辑回归并且应用到一个分类任务。我们还将通过将正则化加入训练算法，来提高算法的鲁棒性，并用更复杂的情形来测试它。
代码修改并注释：黄海广，haiguang2000@qq.com
逻辑回归
在训练的初始阶段，我们将要构建一个逻辑回归模型来预测，某个学生是否被大学录取。设想你是大学相关部分的管理者，想通过申请学生两次测试的评分，来决定他们是否被录取。现在你拥有之前申请学生的可以用于训练逻辑回归的训练样本集。对于每一个训练样本，你有他们两次测试的评分和最后是被录取的结果。为了完成这个预测任务，我们准备构建一个可以基于两次测试评分来评估录取可能性的分类模型。
让我们从检查数据开始。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
path = 'ex2data1.txt'
data = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
data.head()
| Exam 1 | Exam 2 | Admitted | |
|---|---|---|---|
| 0 | 34.623660 | 78.024693 | 0 |
| 1 | 30.286711 | 43.894998 | 0 |
| 2 | 35.847409 | 72.902198 | 0 |
| 3 | 60.182599 | 86.308552 | 1 |
| 4 | 79.032736 | 75.344376 | 1 |
让我们创建两个分数的散点图，并使用颜色编码来可视化，如果样本是正的（被接纳）或负的（未被接纳）。
positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]
fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
plt.show()
看起来在两类间，有一个清晰的决策边界。 现在我们需要实现逻辑回归，那样就可以训练一个模型来预测结果。 方程实现在下面的代码示例在"exercises" 文件夹的 "ex2.pdf" 中。
sigmoid 函数
合起来，我们得到逻辑回归模型的假设函数：
def sigmoid(z):
return 1 / (1 + np.exp(-z))
让我们做一个快速的检查，来确保它可以工作。
nums = np.arange(-10, 10, step=1)
fig, ax = plt.subplots(figsize=(12,8))
ax.plot(nums, sigmoid(nums), 'r')
plt.show()
棒极了！现在，我们需要编写代价函数来评估结果。代价函数：
def cost(theta, X, y):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
return np.sum(first - second) / (len(X))
现在，我们要做一些设置，和我们在练习 1 在线性回归的练习很相似。
# add a ones column - this makes the matrix multiplication work out easier
data.insert(0, 'Ones', 1)
# set X (training data) and y (target variable)
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]
# convert to numpy arrays and initalize the parameter array theta
X = np.array(X.values)
y = np.array(y.values)
theta = np.zeros(3)
让我们来检查矩阵的维度来确保一切良好。
theta
array([ 0., 0., 0.])
X.shape, theta.shape, y.shape
((100, 3), (3,), (100, 1))
让我们计算初始化参数的代价函数(theta 为 0)。
cost(theta, X, y)
0.69314718055994529
看起来不错，接下来，我们需要一个函数来计算我们的训练数据、标签和一些参数 thata 的梯度。
gradient descent(梯度下降)
- 这是批量梯度下降（batch gradient descent）
- 转化为向量化计算：
def gradient(theta, X, y):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
parameters = int(theta.ravel().shape[1])
grad = np.zeros(parameters)
error = sigmoid(X * theta.T) - y
for i in range(parameters):
term = np.multiply(error, X[:,i])
grad[i] = np.sum(term) / len(X)
return grad
注意，我们实际上没有在这个函数中执行梯度下降，我们仅仅在计算一个梯度步长。在练习中，一个称为“fminunc”的 Octave 函数是用来优化函数来计算成本和梯度参数。由于我们使用 Python，我们可以用 SciPy 的“optimize”命名空间来做同样的事情。
我们看看用我们的数据和初始参数为 0 的梯度下降法的结果。
gradient(theta, X, y)
array([ -0.1 , -12.00921659, -11.26284221])
现在可以用 SciPy's truncated newton（TNC）实现寻找最优参数。
import scipy.optimize as opt
result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result
(array([-25.1613186 , 0.20623159, 0.20147149]), 36, 0)
让我们看看在这个结论下代价函数计算结果是什么个样子~
cost(result[0], X, y)
0.20349770158947464
接下来，我们需要编写一个函数，用我们所学的参数 theta 来为数据集 X 输出预测。然后，我们可以使用这个函数来给我们的分类器的训练精度打分。逻辑回归模型的假设函数：
当 大于等于 0.5 时，预测 y=1
当 小于 0.5 时，预测 y=0 。
def predict(theta, X):
probability = sigmoid(X * theta.T)
return [1 if x >= 0.5 else 0 for x in probability]
theta_min = np.matrix(result[0])
predictions = predict(theta_min, X)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))
accuracy = 89%
我们的逻辑回归分类器预测正确，如果一个学生被录取或没有录取，达到 89%的精确度。不坏！记住，这是训练集的准确性。我们没有保持住了设置或使用交叉验证得到的真实逼近，所以这个数字有可能高于其真实值（这个话题将在以后说明）。
正则化逻辑回归
在训练的第二部分，我们将要通过加入正则项提升逻辑回归算法。如果你对正则化有点眼生，或者喜欢这一节的方程的背景，请参考在"exercises"文件夹中的"ex2.pdf"。简而言之，正则化是成本函数中的一个术语，它使算法更倾向于“更简单”的模型（在这种情况下，模型将更小的系数）。这个理论助于减少过拟合，提高模型的泛化能力。这样，我们开始吧。
设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定是否芯片要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。
和第一部分很像，从数据可视化开始吧！
path = 'ex2data2.txt'
data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted'])
data2.head()
| Test 1 | Test 2 | Accepted | |
|---|---|---|---|
| 0 | 0.051267 | 0.69956 | 1 |
| 1 | -0.092742 | 0.68494 | 1 |
| 2 | -0.213710 | 0.69225 | 1 |
| 3 | -0.375000 | 0.50219 | 1 |
| 4 | -0.513250 | 0.46564 | 1 |
positive = data2[data2['Accepted'].isin([1])]
negative = data2[data2['Accepted'].isin([0])]
fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')
ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')
ax.legend()
ax.set_xlabel('Test 1 Score')
ax.set_ylabel('Test 2 Score')
plt.show()
哇，这个数据看起来可比前一次的复杂得多。特别地，你会注意到其中没有线性决策界限，来良好的分开两类数据。一个方法是用像逻辑回归这样的线性技术来构造从原始特征的多项式中得到的特征。让我们通过创建一组多项式特征入手吧。
degree = 5
x1 = data2['Test 1']
x2 = data2['Test 2']
data2.insert(3, 'Ones', 1)
for i in range(1, degree):
for j in range(0, i):
data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)
data2.drop('Test 1', axis=1, inplace=True)
data2.drop('Test 2', axis=1, inplace=True)
data2.head()
| Accepted | Ones | F10 | F20 | F21 | F30 | F31 | F32 | F40 | F41 | F42 | F43 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 1 | 0.051267 | 0.002628 | 0.035864 | 0.000135 | 0.001839 | 0.025089 | 0.000007 | 0.000094 | 0.001286 | 0.017551 |
| 1 | 1 | 1 | -0.092742 | 0.008601 | -0.063523 | -0.000798 | 0.005891 | -0.043509 | 0.000074 | -0.000546 | 0.004035 | -0.029801 |
| 2 | 1 | 1 | -0.213710 | 0.045672 | -0.147941 | -0.009761 | 0.031616 | -0.102412 | 0.002086 | -0.006757 | 0.021886 | -0.070895 |
| 3 | 1 | 1 | -0.375000 | 0.140625 | -0.188321 | -0.052734 | 0.070620 | -0.094573 | 0.019775 | -0.026483 | 0.035465 | -0.047494 |
| 4 | 1 | 1 | -0.513250 | 0.263426 | -0.238990 | -0.135203 | 0.122661 | -0.111283 | 0.069393 | -0.062956 | 0.057116 | -0.051818 |
现在，我们需要修改第 1 部分的成本和梯度函数，包括正则化项。首先是成本函数：
regularized cost（正则化代价函数）
def cost(theta, X, y, learningRate):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))
return np.sum(first - second) / len(X) + reg
请注意等式中的"reg" 项。还注意到另外的一个“学习率”参数。这是一种超参数，用来控制正则化项。现在我们需要添加正则化梯度函数：
如果我们要使用梯度下降法令这个代价函数最小化，因为我们未对 进行正则化，所以梯度下降算法将分两种情形：
对上面的算法中 j=1,2,...,n 时的更新式子进行调整可得：
def gradientReg(theta, X, y, learningRate):
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
parameters = int(theta.ravel().shape[1])
grad = np.zeros(parameters)
error = sigmoid(X * theta.T) - y
for i in range(parameters):
term = np.multiply(error, X[:,i])
if (i == 0):
grad[i] = np.sum(term) / len(X)
else:
grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])
return grad
就像在第一部分中做的一样，初始化变量。
# set X and y (remember from above that we moved the label to column 0)
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]
# convert to numpy arrays and initalize the parameter array theta
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)
让我们初始学习率到一个合理值。，果有必要的话（即如果惩罚太强或不够强）,我们可以之后再折腾这个。
learningRate = 1
现在，让我们尝试调用新的默认为0的theta的正则化函数，以确保计算工作正常。
costReg(theta2, X2, y2, learningRate)
0.6931471805599454
gradientReg(theta2, X2, y2, learningRate)
array([ 0.00847458, 0.01878809, 0.05034464, 0.01150133, 0.01835599,
0.00732393, 0.00819244, 0.03934862, 0.00223924, 0.01286005,
0.00309594])
现在我们可以使用和第一部分相同的优化函数来计算优化后的结果。
result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2
(array([ 1.22702519e-04, 7.19894617e-05, -3.74156201e-04,
-1.44256427e-04, 2.93165088e-05, -5.64160786e-05,
-1.02826485e-04, -2.83150432e-04, 6.47297947e-07,
-1.99697568e-04, -1.68479583e-05]), 96, 1)
最后，我们可以使用第1部分中的预测函数来查看我们的方案在训练数据上的准确度。
theta_min = np.matrix(result2[0])
predictions = predict(theta_min, X2)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))
accuracy = 77%
虽然我们实现了这些算法，值得注意的是，我们还可以使用高级Python库像scikit-learn来解决这个问题。
from sklearn import linear_model#调用sklearn的线性回归包
model = linear_model.LogisticRegression(penalty='l2', C=1.0)
model.fit(X2, y2.ravel())
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0, warm_start=False)
model.score(X2, y2)
0.66101694915254239
这个准确度和我们刚刚实现的差了好多，不过请记住这个结果可以使用默认参数下计算的结果。我们可能需要做一些参数的调整来获得和我们之前结果相同的精确度。
参考资料\
[1] 机器学习课程: www.coursera.org/course/ml
[2] 黄海广: github.com/fengdu78
[3] github: github.com/fengdu78/Co…
[4] 作业代码: github.com/fengdu78/Co…
[5] markdown 文件: github.com/fengdu78/Co…
[6] pdf 文件: github.com/fengdu78/Co…
关于本站
“机器学习初学者”公众号由是黄海广博士创建，黄博个人知乎粉丝23000+，github排名全球前110名（32000+）。本公众号致力于人工智能方向的科普性文章，为初学者提供学习路线和基础资料。原创作品有：吴恩达机器学习个人笔记、吴恩达深度学习笔记等。
往期精彩回顾
