wed-机器学习笔记

课堂笔记 + 一些题目 + 编程题

第1章-初识机器学习

1.1 欢迎参加《机器学习》课程

Machine Learning(机器学习) 是研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演译。

机器学习的例子：

1. 搜索网页，搜索引擎使用的学习算法学会了给网页排序
2. Facebook或苹果的相片分类功能
3. 垃圾邮件过滤器过滤垃圾邮件

采用学习算法尝试模拟人类大脑的学习方式
深度学习是AI人工智能发展出来的一个领域
让机器学会如何去做

其他例子

1. 数据挖掘：网页点击的数据，医疗数据，生物，工程
2. 应用不能够手动编程：自动驾驶直升机，手写体识别，NLP，计算机视觉
3. 私人定制化程序：各种网站的个性化推荐
4. 理解人类的学习：大脑，真正的AI

   1.2 机器学习是什么？

   机器学习的定义：
   Arthur Samue的定义：在没有明确设置的情况下，使计算机具有学习能力的研究领域。
   他编写了一个跳棋游戏程序，使程序与自己对弈几万次，通过观察哪些布局容易赢，哪些布局容易输，一段时间后，跳棋游戏程序就学到了什么使好的布局，什么是不好的布局，最终学会了玩跳棋。计算机有耐心。
   Tom Mitchell的定义：一个程序被认为能从经验 E 中学习，解决任务 T，达到性能度量值 P，当且仅当，有了经验 E 后，经过 P 评判，程序在处理 T 时的性能有所提升。
   这个定义和上一个定义的联系之处就在于：其实经验 E 就是程序上万次的自我练习的经验，而任务 T 就是下棋，性能度量值 P 就是它在与一些新的对手比赛时，赢得比赛的概率。

最主要的两类机器学习算法：

• 监督学习和无监督学习
  • 监督学习就是我们教会计算机做某件事情，给计算机训练集和对应的参考答案，让其学习
  • 无监督学习中让计算机自己学习，事先并没有告诉它什么样的东西对应什么样的结果

课程将会花大量时间介绍应用学习算法时的实际建议（这是其他大学没有教的）

本课程的目标：

• 传授机器学习和AI中那些最好的实践经验，以及如何做这件事情，我们是怎么做的，其他优秀的人是怎么做的。
• 学会知道如何设计和建立各种机器学习及AI系统。

  1.3 监督学习

  监督学习基本思想：数据集中的每个样本都有相应的“正确答案”，再根据这些样本作出预测，就像房子和肿瘤的例子中做的那样。
  回归问题：即通过回归来推出一个连续的输出。
  分类问题：其目标是推出一组离散的结果。
  支持向量机：里面有一个巧妙的数学技巧，能让计算机处理无限多个特征。

  1.4 无监督学习

  无监督学习中没有任何的标签或者是有相同的标签或者就是没标签。

无监督学习算法可能会把这些数据分成不同的簇，所以叫做聚类算法。

• 聚类应用的一个例子就是在谷歌新闻中。谷歌新闻每天都在收集非常多的网络的新闻内容。它再将这些新闻分组，组成有关联的新闻。所以谷歌新闻做的就是搜索非常多的新闻事件，自动地把它们聚类到一起。这些新闻事件全是同一主题的，所以显示到一起。

无监督学习，没有提前告知算法一些信息，仅仅是一堆数据，并不知道数据里面有什么，是什么类型。
但你能自动地找到数据中的结构吗？就是说你要自动地聚类那些个体到各个类，没法提前知道哪些是哪些。
因为我们没有给算法正确答案来回应数据集中的数据，所以这就是无监督学习。

无监督学习或聚集有着大量的应用 —— 组织大型计算机集群、社交网络的分析、市场分割、天文数据分析。

聚类只是无监督学习中的一种。
无监督学习，它是学习策略，交给算法大量的数据，并让算法为我们从数据中找出某种结构。

第2章-单变量线性回归

2.1 模型表示

监督学习算法的工作方式

2.2 代价函数 cost function

在线性回归中假设有一个像这样的训练集，代表了训练样本的数量，比如 m = 47 。而我们的假设函数，也就是用来进行预测的函数，是这样的线性函数形式：

为我们的模型选择合适的参数（parameters） ，我们选择的参数决定了我们得到的直线相对于我们的训练集的准确程度，模型所预测的值与训练集中实际值之间的差距（下图中蓝线所指）就是建模误差（modeling error）。

我们的目标便是选择出可以使得建模误差的平方和能够最小的模型参数。 即使得代价函数
最小。⭐⭐

为什么是除以2m，不是除以m呢？ 答：主要是为了方便后面求导的时候，没有1/2。首先无论这里除以2m还是除以m，代价函数最优化的结果\theta 都是相同的。但是利用梯度下降对J求导时，如果时2m，J的那个平方会和前面的系数1/2约掉，最终留下1/m。

代价函数也被称作平方误差函数和损失函数，有时也被称为平方误差代价函数。
之所以要求出误差的平方和，是因为误差平方代价函数，对于大多数问题，特别是回归问题，都是一个合理的选择。还有其他的代价函数也能很好地发挥作用，但是平方误差代价函数可能是解决回归问题最常用的手段了。

2.3 代价函数的直观理解 I

2.4 代价函数的直观理解II

通过这些图形，能更好地理解这些代价函数所表达的值是什么样的，它们对应的假设是什么样的，以及什么样的假设对应的点，更接近于代价函数的最小值。
当然，我们真正需要的是一种有效的算法，能够自动地找出这些使代价函数取最小值的参数和来。因此我们真正需要的是编写程序来找出这些最小化代价函数的和的值，在下一节视频中，将介绍一种算法，能够自动地找出能使代价函数最小化的参数和的值。

2.5 梯度下降

梯度下降是一个用来求函数最小值的算法，我们将使用梯度下降算法来求出代价函数 的最小值，从而推导出对应的一组 。
梯度下降背后的思想是：开始时我们随机选择一个参数的组合 ，计算代价函数，然后我们寻找下一个能让代价函数值下降最多的参数组合。我们持续这么做直到找到一个局部最小值（local minimum），因为我们并没有尝试完所有的参数组合，所以不能确定我们得到的局部最小值是否便是全局最小值（global minimum），选择不同的初始参数组合，可能会找到不同的局部最小值。

批量梯度下降（batch gradient descent）算法的公式为：
⭐⭐
其中 是学习率（learning rate），它决定了我们沿着能让代价函数下降程度最大的方向向下迈出的步子有多大，在批量梯度下降中，我们每一次都同时让所有的参数减去学习速率乘以代价函数的导数。

需要注意：需要同时更新 和 ，也就是要这样更新：
，并更新 。
实现方法是：先计算公式右边的部分，通过那一部分计算出 和 的值，然后同时更新 和 。
在梯度下降算法中，这是正确实现同时更新的方法。同时更新是梯度下降中的一种常用方法。

2.6 梯度下降的直观理解

梯度下降算法
描述：对 赋值，使得 按梯度下降最快方向进行，一直迭代下去，最终得到局部**最小值。其中 是学习率（learning rate），它决定了我们沿着能让代价函数下降程度最大的方向向下迈出的步子有多大。
对于这个问题，求导的目的，也就是取红点的切线**，与函数相切于这一点。
如果斜率是正的，也就是说它有正导数，因此，我得到的新的 ， 更新后等于 减去一个正数乘以 。

• 如果 太小的话，可能会很慢，因为它会一点点挪动，它会需要很多步才能到达全局最低点。
• 如果 太大，它会导致无法收敛，甚至发散

  因为如果 太大，那么梯度下降法可能会越过最低点，甚至可能无法收敛，下一次迭代又移动了一大步，越过一次，又越过一次，一次次越过最低点，直到实际上离最低点越来越远。

假设你将初始化在局部最低点，即它已经在一个局部的最优处或局部最低点。结果是局部最优点的导数将等于零，因为它是那条切线的斜率。这意味着你已经在局部最优点，它使得不再改变，也就是新的等于原来的，因此，如果你的参数已经处于局部最低点，那么梯度下降法更新其实什么都没做，它不会改变参数的值。这也解释了为什么即使学习速率保持不变时，梯度下降也可以收敛到局部最低点。

在梯度下降法中，当我们接近局部最低点时，梯度下降法会自动采取更小的幅度。
这是因为当我们接近局部最低点时，很显然在局部最低时导数等于零，所以当我们接近局部最低时，导数值会自动变得越来越小，所以梯度下降将自动采取较小的幅度，这就是梯度下降的做法。所以实际上没有必要再另外减小 。

这就是梯度下降算法，你可以用它来最小化任何代价函数 ，不只是线性回归中的代价函数 。

2.7 梯度下降的线性回归

梯度下降算法和线性回归算法比较如图：

对我们之前的线性回归问题运用梯度下降法，关键在于求出代价函数的导数，即：
其中对 求导的推导如下：（自己推导也可以）

则算法改写成：
⭐⭐
在线性回归里的梯度下降所求的局部最小值就是全局最小值。

刚刚使用的算法，有时也称为批量梯度下降。实际上，在机器学习中，通常不太会给算法起名字，但这个名字”批量梯度下降”，指的是在梯度下降的每一步中，我们都用到了所有的训练样本。在梯度下降中，在计算微分求导项时，需要进行求和运算，所以，在每一个单独的梯度下降中，最终都要计算这样一个东西，这个项需要对所有个训练样本求和。
因此，批量梯度下降法这个名字说明了需要考虑所有这一”批”训练样本，而事实上，有时也有其他类型的梯度下降法，不是这种”批量”型的，不考虑整个的训练集，而是每次只关注训练集中的一些小的子集。

另外还有一种计算代价函数最小值的数值解法，不需要梯度下降这种迭代算法，它可以在不需要多步梯度下降的情况下，也能解出代价函数的最小值，这是另一种称为正规方程(normal equations)的方法。实际上在数据量较大的情况下，梯度下降法比正规方程要更适用一些。

第3章-线性函数回顾

3.1 矩阵和向量
3.2 加法和标量乘法
3.3 矩阵向量乘法
3.4 矩阵乘法
3.5 矩阵乘法的性质
3.6 逆、转置

第4章-多变量线性回归 Linear Regression with Multiple Variables

4.1 多维特征 Multiple Features

目前为止，我们探讨了单变量/特征的回归模型，现在我们对房价模型增加更多的特征，例如房间数楼层等，构成一个含有多个变量的模型，模型中的特征为 。

增添更多特征后，我们引入一系列新的注释：
代表特征的数量
代表第 i 个训练实例，是特征矩阵中的第 i 行，是一个向量（vector）。
比方说，上图的
代表特征矩阵中第 i 行的第 j 个特征，也就是第 i 个训练实例的第 j 个特征。
如上图的 ， ，
支持多变量的假设 h 表示为： ，
这个公式中有个 参数和 个变量，为了使得公式能够简化一些，引入 ，则公式转化为：
此时模型中的参数是一个 维的向量，任何一个训练实例也都是 维的向量，特征矩阵 的维度是 。 因此公式可以简化为： ，其中上标 代表矩阵转置。

4.2 多变量梯度下降 Gradient Descent for Multiple Variables

与单变量线性回归类似，在多变量线性回归中，我们也构建一个代价函数，则这个代价函数是所有建模误差的平方和，即：

其中
我们的目标和单变量线性回归问题中一样，是要找出使得代价函数最小的一系列参数。
多变量线性回归的批量梯度下降算法为：

⭐⭐
我们开始随机选择一系列的参数值，计算所有的预测结果后，再给所有的参数一个新的值，如此循环直到收敛。

4.3 梯度下降法实践1-特征缩放 Gradient Descent in Practice I - Feature Scaling

在我们面对多维特征问题的时候，我们要保证这些特征都具有相近的尺度，这将帮助梯度下降算法更快地收敛。

以房价问题为例，假设使用两个特征，房屋的尺寸和房间的数量，尺寸的值为 0-2000平方英尺，而房间数量的值则是0-5，以两个参数分别为横纵坐标，绘制代价函数的等高线图能，看出图像会显得很扁，梯度下降算法需要非常多次的迭代才能收敛。

解决的方法是尝试将所有特征的尺度都尽量缩放到-1到1之间。如图：

最简单的方法是令： ，其中 是平均值， 或者标准偏差。 ⭐⭐

4.4 梯度下降法实践2-学习率 Gradient Descent in Practice II - Learning Rate

梯度下降算法收敛所需要的迭代次数根据模型的不同而不同，不能提前预知，但可以绘制迭代次数和代价函数的图表来观测算法在何时趋于收敛。

也有一些自动测试是否收敛的方法，例如将代价函数的变化值与某个阀值（例如0.001）进行比较，但通常看上面这样的图表更好。

梯度下降算法的每次迭代受到学习率的影响，如果学习率 过小，则达到收敛所需的迭代次数会非常高；
如果学习率 过大，每次迭代可能不会减小代价函数，可能会越过局部最小值导致无法收敛。

通常可以考虑尝试些学习率：

4.5 特征和多项式回归 Features and Polynomial Regression

线性回归并不适用于所有数据，有时我们需要曲线来适应我们的数据，比如一个二次方模型：
或者三次方模型：：

通常需要先观察数据然后再决定准备尝试怎样的模型。
另外，我们可以令：，，从而将模型转化为线性回归模型。

注：如果我们采用多项式回归模型，在运行梯度下降算法前，特征缩放非常有必要。

4.6 正规方程 Normal Equation

到目前为止，之前都在使用梯度下降算法，但是对于某些线性回归问题，正规方程方法是更好的解决方案。
如：

正规方程是通过求解下面的方程来找出使得代价函数最小的参数的： 。
假设我们的训练集特征矩阵为 (包含了 ) 并且我们的训练集结果为向量 ，
则利用正规方程解出向量 ⭐⭐。

推导过程

设矩阵 ，则

以下表示数据为例：

注：对于那些不可逆的矩阵（通常是因为特征之间不独立，如同时包含英尺为单位的尺寸和米为单位的尺寸两个特征，也有可能是特征数量大于训练集的数量），正规方程方法是不能用的。

梯度下降与正规方程的比较：⭐⭐

梯度下降	正规方程
需要选择学习率	不需要
需要多次迭代	一次运算得出
当特征数量大时也能较好适用	需要计算，如果特征数量n较大则运算代价大，因为矩阵逆的计算时间复杂度为 ，通常来说当小于10000 时还是可以接受的
适用于各种类型的模型	只适用于线性模型，不适合逻辑回归模型等其他模型

总结一下，只要特征变量的数目并不大，标准方程是一个很好的计算参数的替代方法。
具体地说，只要特征变量数量小于一万，我通常使用标准方程法，而不使用梯度下降法。

随着学习算法越来越复杂，如分类算法里的逻辑回归算法，并不能使用正规方程法。
对于那些更复杂的学习算法，我们将不得不仍然使用梯度下降法。
因此，梯度下降法是一个非常有用的算法，可以用在有大量特征变量的线性回归问题。
但对于这个特定的线性回归模型，正规方程法是一个比梯度下降法更快的替代算法。
所以，根据具体的问题，以及特征变量的数量，这两种算法都是值得学习的。

4.7 正规方程及不可逆性 Normal Equation Noninvertibility

当计算 ，那对于矩阵 的结果是不可逆的情况咋办呢?
线性代数里，称那些不可逆矩阵为奇异或退化矩阵。问题的重点在于 的不可逆的问题很少发生，

如何使用小数据样本以得到较多的特征参数？
通常，我们会使用一种叫做正则化的线性代数方法，通过删除某些特征或者是使用某些技术，来解决样本数比特征值少的问题。

• 首先，看特征值里是否有一些多余的特征，像这些 x1 和 x2 是线性相关的，互为线性函数。
• 同时，当有一些多余的特征时，可以删除这两个重复特征里的其中一个，无须两个特征同时保留，将解决不可逆性的问题。
• 如果特征数量实在太多，删除些用得较少的特征来反映尽可能多内容，否则我会考虑使用正规化方法。

如果矩阵是不可逆的（通常来说，不会出现这种情况），在Octave里，可以用伪逆函数pinv() 来实现，也就是说矩阵是不可逆的，但算法执行的流程是正确的。
总之，出现不可逆矩阵的情况极少发生，所以在大多数实现线性回归中，出现不可逆的问题不应该过多的关注是不可逆的。

第5章-Octave/Matlab教程

第6章-Logistic 回归 (Logistic Regression)

6.1 分类问题 Classification

线性回归算法并不适用于分类问题。原因如下：

• 因为数据集的原因可能得到不同的模型（拟合函数），可能偏离我们期望的分类的边界。
• 假设函数的输出值可能远大于 1，或者远小于0，不利于代价函数的计算。

逻辑回归算法是分类算法，这个算法的一个性质是：它的输出值永远在 0 到 1 之间。
在分类问题中，我们尝试预测的是结果是否属于某一个类（例如正确或错误）。

二元的分类问题：将因变量(dependent variable)可能属于的两个类分别称为负向类（negative class）和正向类（positive class），则因变量 ，其中 0 表示负向类，1 表示正向类。

6.2 假设表示 Hypothesis Representation

线性回归模型，因为其预测的值可以超越 [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 决策边界 Decision Boundary

现在假设我们有一个模型：

并且参数 是向量[-3 1 1]。 则当 ，即 时，模型将预测 。
我们可以绘制直线 ，这条线便是我们模型的分界线，将预测为1的区域和预测为 0 的区域分隔开。
决策边界是分隔 y = 0和 y = 1区域的线。它是由我们的假设函数创建的。

假使数据呈现这样的分布情况，怎样的模型才能适合呢？

因为需要用曲线才能分隔 的区域和 的区域，需要二次方特征： 是 [-1 0 0 1 1]，则得到的判定边界恰好是圆点在原点且半径为1的圆形。
可以用非常复杂的模型来适应非常复杂形状的判定边界。

6.4 代价函数 Cost Function

用来拟合参数的优化目标叫代价函数，它就是监督学习问题中的逻辑回归模型的拟合问题。

对于线性回归模型，我们定义的代价函数是所有模型误差的平方和。理论上来说，我们也可以对逻辑回归模型沿用这个定义，但是问题在于，当我们将 带入到这样定义了的代价函数中时，我们得到的代价函数将是一个非凸函数（non-convexfunction）。

这意味着我们的代价函数有许多局部最小值，这将影响梯度下降算法寻找全局最小值。
线性回归的代价函数为：
。
重新定义逻辑回归的代价函数为：
，
其中

与 之间的关系如下图所示：

横坐标 ，纵坐标
这样构建的 函数的特点是：

• 当实际的 且 也为 1 时误差为 0，当 但 不为 1 时误差随着 变小而变大

• 当实际的 且 也为 0 时误差为 0，当 但 不为 0 时误差随着 的变大而变大

• 当 ，则 （当 和 ）

即：

6.5 简化的代价函数和梯度下降 Simplified Cost Function and Gradient Descent

逻辑回归的代价函数：

将构建的 简化如下：

                ![](https://cdn.nlark.com/yuque/__latex/aa2617e1ba7a547f973400daa1218b91.svg#card=math&code=Cost%5Cleft%28%20%7Bh_%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%2Cy%20%5Cright%29%3D-y%5Ctimes%20log%5Cleft%28%20%7Bh_%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%20%5Cright%29-%281-y%29%5Ctimes%20log%5Cleft%28%201-%7Bh_%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%20%5Cright%29&height=20&id=xFak4)

带入代价函数得到：

即逻辑回归的代价函数 ：

⭐⭐
向量化：

⭐⭐

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 {
#card=math&code=%5Ctheta_j%20%3A%3D%20%5Ctheta_j%20-%20%5Calpha%20%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial%5Ctheta_j%7D%20J%28%5Ctheta%29&id=LxtpN)
(simultaneously update all )
}

求导后得到：
Repeat {
%7D%20%5Cright)-%5Cmathop%7By%7D%5E%7B%5Cleft(%20i%20%5Cright)%7D%20%5Cright)%7D%7D%5Cmathop%7Bx%7D%7Bj%7D%5E%7B(i)%7D#card=math&code=%5Ctheta_j%20%3A%3D%20%5Ctheta_j%20-%20%5Calpha%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%7B%5Cleft%28%20%7Bh%5Ctheta%7D%5Cleft%28%20%5Cmathop%7Bx%7D%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%20%5Cright%29-%5Cmathop%7By%7D%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%20%5Cright%29%7D%7D%5Cmathop%7Bx%7D%7Bj%7D%5E%7B%28i%29%7D&id=pv1Cb) ⭐⭐
(simultaneously update all )
}

向量化的实现如下：
⭐⭐

在这个视频中，我们定义了单训练样本的代价函数，凸性分析的内容是超出这门课的范围的，但是可以证明我们所选的代价函数会给我们一个凸优化问题。代价函数#card=math&code=J%28%5Ctheta%29&id=bpK6Q)会是一个凸函数，并且没有局部最优值。❓❓

和线性回归梯度下降相比，即使更新参数的规则看起来基本相同，但由于假设的定义发生了变化，所以逻辑函数的梯度下降，跟线性回归的梯度下降实际上是两个完全不同的东西。
对于线性回归的梯度下降法，我们谈到了如何监控梯度下降法以确保其收敛，我通常也把同样的方法用在逻辑回归中，来监测梯度下降，以确保它正常收敛。
如果你的特征范围差距很大的话，那么应用特征缩放的方法，同样也可以让逻辑回归中，梯度下降收敛更快。

推导过程：
%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B%7B%7By%7D%5E%7B(i)%7D%7D%5Clog%20%5Cleft(%20%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)%2B%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201-%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)%5D%7D#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%20%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29%2B%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201-%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29%5D%7D&id=JPlIs)
考虑：
%7D%7D%20%5Cright)%3D%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D#card=math&code=%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%3D%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D&id=Rn5iZ)
则：
%7D%7D%5Clog%20%5Cleft(%20%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)%2B%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201-%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)#card=math&code=%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%20%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29%2B%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201-%7Bh_%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29&id=h2wRe)

%7D%7D%5Clog%20%5Cleft(%20%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%20%5Cright)%2B%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201-%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%20%5Cright)#card=math&code=%3D%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%20%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%20%5Cright%29%2B%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201-%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%20%5Cright%29&id=gZkZN)

%7D%7D%5Clog%20%5Cleft(%201%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%20%5Cright)-%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%20%5Cright)#card=math&code=%3D-%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%201%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%20%5Cright%29-%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%20%5Cright%29&id=Cytii)

所以：
%3D%5Cfrac%7B%5Cpartial%20%7D%7B%5Cpartial%20%7B%5Ctheta%7Bj%7D%7D%7D%5B-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B-%7B%7By%7D%5E%7B(i)%7D%7D%5Clog%20%5Cleft(%201%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%20%5Cright)-%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%20%5Cright)%5D%7D%5D#card=math&code=%5Cfrac%7B%5Cpartial%20%7D%7B%5Cpartial%20%7B%5Ctheta%7Bj%7D%7D%7DJ%5Cleft%28%20%5Ctheta%20%20%5Cright%29%3D%5Cfrac%7B%5Cpartial%20%7D%7B%5Cpartial%20%7B%5Ctheta%7Bj%7D%7D%7D%5B-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B%5B-%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%201%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%20%5Cright%29-%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%20%5Cright%29%5D%7D%5D&id=y06pr)

%7D%7D%5Cfrac%7B-x%7Bj%7D%5E%7B(i)%7D%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D-%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Cfrac%7Bx_j%5E%7B(i)%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7D%5D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B-%7B%7By%7D%5E%7B%28i%29%7D%7D%5Cfrac%7B-x_%7Bj%7D%5E%7B%28i%29%7D%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5E%7BT%7D%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D-%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Cfrac%7Bx_j%5E%7B%28i%29%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7D%5D&id=grwEG)

%7D%7D%5Cfrac%7Bxj%5E%7B(i)%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D-%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Cfrac%7Bx_j%5E%7B(i)%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%5D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%7By%7D%5E%7B%28i%29%7D%7D%5Cfrac%7Bx_j%5E%7B%28i%29%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D-%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Cfrac%7Bx_j%5E%7B%28i%29%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%5D&id=wm2Ek)

%7D%7Dxj%5E%7B(i)%7D-x_j%5E%7B(i)%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%2B%7B%7By%7D%5E%7B(i)%7D%7Dx_j%5E%7B(i)%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5Cfrac%7B%7B%7By%7D%5E%7B%28i%29%7D%7Dx_j%5E%7B%28i%29%7D-x_j%5E%7B%28i%29%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%2B%7B%7By%7D%5E%7B%28i%29%7D%7Dx_j%5E%7B%28i%29%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7D&id=yql0J)

%7D%7D%5Cleft(%201%5Ctext%7B%2B%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%20%5Cright)-%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7Dxj%5E%7B(i)%7D%7D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5Cfrac%7B%7B%7By%7D%5E%7B%28i%29%7D%7D%5Cleft%28%201%5Ctext%7B%2B%7D%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%20%5Cright%29-%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7Dx_j%5E%7B%28i%29%7D%7D&id=oad5b)

%7D%7D-%5Cfrac%7B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D)xj%5E%7B(i)%7D%7D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%28%7B%7By%7D%5E%7B%28i%29%7D%7D-%5Cfrac%7B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%7B1%2B%7B%7Be%7D%5E%7B%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%29x_j%5E%7B%28i%29%7D%7D&id=zArUK)

%7D%7D-%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B(i)%7D%7D%7D%7D%7D)xj%5E%7B(i)%7D%7D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%28%7B%7By%7D%5E%7B%28i%29%7D%7D-%5Cfrac%7B1%7D%7B1%2B%7B%7Be%7D%5E%7B-%7B%5Ctheta%5ET%7D%7B%7Bx%7D%5E%7B%28i%29%7D%7D%7D%7D%7D%29x_j%5E%7B%28i%29%7D%7D&id=f0waw)

%7D%7D-%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%5Dx_j%5E%7B(i)%7D%7D#card=math&code=%3D-%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B%7B%7By%7D%5E%7B%28i%29%7D%7D-%7Bh_%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Dx_j%5E%7B%28i%29%7D%7D&id=ygYXp)

%7D%7D%20%5Cright)-%7B%7By%7D%5E%7B(i)%7D%7D%5Dxj%5E%7B(i)%7D%7D#card=math&code=%3D%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B%7Bh_%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%5Dx_j%5E%7B%28i%29%7D%7D&id=tCacc)

课堂试题：
Suppose you are running gradient descent to fit a logistic regression model with parameter θ∈Rn+1. Which of the following is a reasonable way to make sure the learning rate α is set properly and that gradient descent is running correctly?

• Plot as a function of the number of iterations and make sure J(θ) is decreasing on every iteration.

6.6 高级优化 Advanced Optimization

更高级、更复杂的优化代价函数方法有：共轭梯度法 、BFGS (变尺度法) 和 L-BFGS (限制变尺度法)。
这三种算法有许多优点：

• 不需要手动选择学习率

  他们确实有一个智能的内部循环，称为线性搜索(line search)算法，它可以自动尝试不同的学习速率 ，并自动选择一个好的学习速率 ，因此它甚至可以为每次迭代选择不同的学习速率，那么你就不需要自己选择。这些算法实际上在做更复杂的事情，不仅仅是选择一个好的学习速率，所以它们往往最终比梯度下降收敛得快多了。

目前不需要真正理解这些算法的内环间在做什么，只需要会用。如果说这些算法有缺点的话，那么我想说主要缺点是它们比梯度下降法复杂多了。

例子：比方说，你有一个含两个参数的问题，这两个参数是和，因此，通过这个代价函数，你可以得到和 的值，如果你将#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29&id=RxFa8) 最小化的话，那么它的最小值将是 ，。代价函数#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29&id=ggS6n)的导数推出来就是这两个表达式：
%3D2(%7B%7B%5Ctheta%20%7D%7B1%7D%7D-5)#card=math&code=%5Cfrac%7B%5Cpartial%20%7D%7B%5Cpartial%20%7B%7B%5Ctheta%20%7D%7B1%7D%7D%7DJ%28%5Ctheta%29%3D2%28%7B%7B%5Ctheta%20%7D_%7B1%7D%7D-5%29&id=hELIB)

%3D2(%7B%7B%5Ctheta%20%7D%7B2%7D%7D-5)#card=math&code=%5Cfrac%7B%5Cpartial%20%7D%7B%5Cpartial%20%7B%7B%5Ctheta%20%7D%7B2%7D%7D%7DJ%28%5Ctheta%29%3D2%28%7B%7B%5Ctheta%20%7D_%7B2%7D%7D-5%29&id=WPb2Y)

如果我们不知道最小值，但你想要代价函数找到这个最小值，是用比如梯度下降这些算法，但最好是用比它更高级的算法，你要做的就是运行一个像这样的Octave 函数：

function [jVal, gradient]=costFunction(theta)
　　jVal=(theta(1)-5)^2+(theta(2)-5)^2;
　　gradient=zeros(2,1);
　　gradient(1)=2*(theta(1)-5);
　　gradient(2)=2*(theta(2)-5);
end

这样就计算出这个代价函数，函数返回的第二个值是梯度值，梯度值应该是一个2×1的向量，梯度向量的两个元素对应这里的两个偏导数项，运行这个costFunction 函数后，你就可以调用高级的优化函数，这个函数叫
fminunc，它表示Octave 里无约束最小化函数。调用它的方式如下：

options=optimset('GradObj','on','MaxIter',100);
initialTheta=zeros(2,1);
[optTheta, functionVal, exitFlag]=fminunc(@costFunction, initialTheta, options);

你要设置几个options，这个 options 变量作为一个数据结构可以存储你想要的options，所以 GradObj 和On，这里设置梯度目标参数为打开(on)，这意味着你现在确实要给这个算法提供一个梯度，然后设置最大迭代次数，比方说100，我们给出一个 的猜测初始值，它是一个2×1的向量，那么这个命令就调用fminunc，这个@符号表示指向我们刚刚定义的costFunction 函数的指针。如果你调用它，它就会使用众多高级优化算法中的一个，当然你也可以把它当成梯度下降，只不过它能自动选择学习速率，你不需要自己来做。然后它会尝试使用这些高级的优化算法，就像加强版的梯度下降法，为你找到最佳的值。
它在 Octave 里是这样：

6.7 多类别分类：一对多 Multiclass Classification_ One-vs-all

进行二元分类，可以使用逻辑回归，对于直线，可以将数据集一分为二为正类和负类。
用一对多的分类思想，我们可以将其用在多类分类问题上。
下面将介绍如何进行一对多的分类工作，有时这个方法也被称为”一对余“方法。

现在我们有一个训练集，好比上图表示的有3个类别，我们用三角形表示 ，方框表示 ，叉叉表示 。我们下面要做的就是使用一个训练集，将其分成3个二元分类问题。
我们先从用三角形代表的类别1开始，实际上我们可以创建一个，新的”伪”训练集，类型2和类型3定为负类，类型1设定为正类，我们创建一个新的训练集，如下图所示的那样，我们要拟合出一个合适的分类器。

这里的三角形是正样本，而圆形代表负样本。可以这样想，设置三角形的值为1，圆形的值为0，下面我们来训练一个标准的逻辑回归分类器，这样我们就得到一个正边界。

重点！ 为了能实现这样的转变，我们将多个类中的一个类标记为正向类（），然后将其他所有类都标记为负向类，这个模型记作%7D%5Cleft(%20x%20%5Cright)#card=math&code=h%5Ctheta%5E%7B%5Cleft%28%201%20%5Cright%29%7D%5Cleft%28%20x%20%5Cright%29&id=rGmpi)。接着，类似地第我们选择另一个类标记为正向类（），再将其它类都标记为负向类，将这个模型记作 %7D%5Cleft(%20x%20%5Cright)#card=math&code=h%5Ctheta%5E%7B%5Cleft%28%202%20%5Cright%29%7D%5Cleft%28%20x%20%5Cright%29&id=TezPV)，依此类推。
最后我们得到一系列的模型简记为： %7D%5Cleft(%20x%20%5Cright)%3Dp%5Cleft(%20y%3Di%7Cx%3B%5Ctheta%20%20%5Cright)#card=math&code=h_%5Ctheta%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%5Cleft%28%20x%20%5Cright%29%3Dp%5Cleft%28%20y%3Di%7Cx%3B%5Ctheta%20%20%5Cright%29&id=UG5r9) 其中：#card=math&code=i%3D%5Cleft%28%201%2C2%2C3….k%20%5Cright%29&id=yvjGp)

最后，在我们需要做预测时，我们将所有的分类机都运行一遍，然后对每一个输入变量，都选择最高可能性的输出变量。

总之，我们已经把要做的做完了，现在要做的就是训练这个逻辑回归分类器：%7D%5Cleft(%20x%20%5Cright)#card=math&code=h%5Ctheta%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%5Cleft%28%20x%20%5Cright%29&id=rI0TR)， 其中 对应每一个可能的 。最后，为了做出预测，我们给出输入一个新的 值，用这个做预测。我们要做的就是在我们三个分类器里面输入 ，然后我们选择一个让 %7D%5Cleft(%20x%20%5Cright)#card=math&code=h%5Ctheta%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%5Cleft%28%20x%20%5Cright%29&id=F2gxu) 最大的 ，也就是可能性最大的一个，即。

你现在知道了基本的挑选分类器的方法，选择出哪一个分类器是可信度最高效果最好的，那么就可认为得到一个正确的分类，无论 值是多少，我们都有最高的概率值，我们预测 就是那个值。
这就是多类别分类问题，以及一对多的方法，通过这个小方法，你现在也可以将逻辑回归分类器用在多类分类的问题上。

第7章-正则化 Regularization

7.1 过拟合的问题 The Problem of Overfitting

几种不同的学习算法，包括线性回归和逻辑回归，它们能够有效地解决许多问题，但是当将它们应用到某些特定的机器学习应用时，会遇到过拟合(over-fitting)的问题，可能会导致它们效果很差。

过拟合(over-fitting)就是：如果我们有非常多的特征，我们通过学习得到的假设函数可能能够非常好地适应训练集（代价函数可能几乎为0），但是可能会不能推广到新的数据。也就是若给出一个新的值使之预测，它将表现的很差，是过拟合，虽然能非常好地适应我们的训练集，但在新输入变量进行预测时可能会效果不好。

回归问题的例子：

分类问题中也存在这样的问题：

就以多项式理解， x 的次数越高，拟合的越好，但相应的预测的能力就可能变差。
如何解决过拟合？

1. 丢弃一些不能帮助我们正确预测的特征。
   1. 可以是手工选择保留哪些特征
   2. 使用一些模型选择的算法来帮忙（例如 PCA）保留或丢弃哪些特征
2. 正则化。 保留所有的特征，但是减少参数的大小（magnitude）。

7.2 代价函数 Cost Function

上面的回归问题中如果我们的模型是：
%3D%7B%5Ctheta%7B0%7D%7D%2B%7B%5Ctheta%7B1%7D%7D%7Bx%7B1%7D%7D%2B%7B%5Ctheta%7B2%7D%7D%7Bx%7B2%7D%5E2%7D%2B%7B%5Ctheta%7B3%7D%7D%7Bx%7B3%7D%5E3%7D%2B%7B%5Ctheta%7B4%7D%7D%7Bx%7B4%7D%5E4%7D#card=math&code=%7Bh%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%3D%7B%5Ctheta%7B0%7D%7D%2B%7B%5Ctheta%7B1%7D%7D%7Bx%7B1%7D%7D%2B%7B%5Ctheta%7B2%7D%7D%7Bx%7B2%7D%5E2%7D%2B%7B%5Ctheta%7B3%7D%7D%7Bx%7B3%7D%5E3%7D%2B%7B%5Ctheta%7B4%7D%7D%7Bx%7B4%7D%5E4%7D&id=cXUWM)
我们可以从之前的事例中看出，正是那些高次项导致了过拟合的产生，所以如果我们能让这些高次项的系数接近于0的话，我们就能很好的拟合了。
所以我们要做的就是在一定程度上减小这些参数 的值，这就是正则化的基本方法。
要减少  和  的大小，要做的便是修改代价函数，在其中  和  设置一点惩罚。
这样做的话，在尝试最小化代价时也需要将这个惩罚纳入考虑中，并最终导致选择较小一些的和。
修改后的代价函数如下： %7D%7D%20%5Cright)-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%7D%5E%7B2%7D%7D%2B1000%5Ctheta%20%7B3%7D%5E%7B2%7D%2B10000%5Ctheta%20%7B4%7D%5E%7B2%7D%5D%7D#card=math&code=%5Cunderset%7B%5Ctheta%20%7D%7B%5Cmathop%7B%5Cmin%20%7D%7D%5C%2C%5Cfrac%7B1%7D%7B2m%7D%5B%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%7B%7B%5Cleft%28%20%7B%7Bh%7D%7B%5Ctheta%20%7D%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%7D%5E%7B2%7D%7D%2B1000%5Ctheta%20%7B3%7D%5E%7B2%7D%2B10000%5Ctheta%20_%7B4%7D%5E%7B2%7D%5D%7D&id=njhAL)

通过这样的代价函数选择出的 和 对预测结果的影响就比之前要小许多。
假如有非常多的特征，并不知道其中哪些特征需要要惩罚，则可以将对所有的特征进行惩罚，并且让代价函数最优化的软件来选择这些惩罚的程度。
这样的结果是得到了一个较为简单的能防止过拟合问题的假设：

%3D%5Cfrac%7B1%7D%7B2m%7D%5B%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%7B%7B(%7Bh%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)%7D%5E%7B2%7D%7D%2B%5Clambda%20%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%7Bj%7D%5E%7B2%7D%7D%5D%7D#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29%3D%5Cfrac%7B1%7D%7B2m%7D%5B%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%7B%7B%28%7Bh%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29%7D%5E%7B2%7D%7D%2B%5Clambda%20%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%7Bj%7D%5E%7B2%7D%7D%5D%7D&id=b4wow)

其中 又称为正则化参数（Regularization Parameter）。
注：根据惯例，我们不对 进行惩罚。
经过正则化处理的模型与原模型的可能对比如下图所示：

如果选择的正则化参数 过大，则会把所有的参数都最小化了，导致模型变成 %3D%7B%5Ctheta%7B0%7D%7D#card=math&code=%7Bh%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%3D%7B%5Ctheta%7B0%7D%7D&id=eSxSU)，也就是上图中红色直线所示的情况，造成欠拟合。
那为什么增加的一项  可以使 的值减小呢？
因为如果我们令 的值很大的话，为了使 Cost Function 尽可能的小，所有的 的值（不包括 ）都会在一定程度上减小。
但若 的值太大了，那么 （不包括）都会趋近于0，这样我们所得到的只能是一条平行于 x 轴的直线。
所以对于正则化，我们要取一个合理的 的值，这样才能更好的应用正则化。
回顾一下代价函数，为了使用正则化，让我们把这些概念应用到到线性回归和逻辑回归中去，那么我们就可以让他们避免过度拟合了。

7.3 正则化线性回归 Regularized Linear Regression

对于线性回归的求解，我们之前推导了两种学习算法：一种基于梯度下降，一种基于正规方程。

正则化线性回归的代价函数为：

%3D%5Cfrac%7B1%7D%7B2m%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B(%7B%7B(%7Bh%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)%7D%5E%7B2%7D%7D%2B%5Clambda%20%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%20%7Bj%7D%5E%7B2%7D%7D)%5D%7D#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29%3D%5Cfrac%7B1%7D%7B2m%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B%28%7B%7B%28%7Bh%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29%7D%5E%7B2%7D%7D%2B%5Clambda%20%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%20%7Bj%7D%5E%7B2%7D%7D%29%5D%7D&id=AuZDD)

如果我们要使用梯度下降法令这个代价函数最小化，因为我们未对 进行正则化，所以梯度下降算法将分两种情形：

{

                                              ![](https://g.yuque.com/gr/latex?%7B%5Ctheta_0%7D%3A%3D%7B%5Ctheta_0%7D-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B((%7Bh_%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)x_%7B0%7D%5E%7B(i)%7D%7D)#card=math&code=%7B%5Ctheta_0%7D%3A%3D%7B%5Ctheta_0%7D-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B%28%28%7Bh_%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29x_%7B0%7D%5E%7B%28i%29%7D%7D%29&id=H3mmR)
                                              ![](https://g.yuque.com/gr/latex?%7B%5Ctheta_j%7D%3A%3D%7B%5Ctheta_j%7D-a%5B%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B((%7Bh_%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)x_%7Bj%7D%5E%7B%5Cleft(%20i%20%5Cright)%7D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7Bm%7D%7B%5Ctheta_j%7D%5D#card=math&code=%7B%5Ctheta_j%7D%3A%3D%7B%5Ctheta_j%7D-a%5B%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B%28%28%7Bh_%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29x_%7Bj%7D%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7Bm%7D%7B%5Ctheta_j%7D%5D&id=mb4zH)
                                                        ![](https://g.yuque.com/gr/latex?for#card=math&code=for&id=BIgp3) ![](https://g.yuque.com/gr/latex?j%3D1%2C2%2C...n#card=math&code=j%3D1%2C2%2C...n&id=SRJTZ)
                                               }

对上面的算法中 时的更新式子进行调整可得：

-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B(%7Bh%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)x%7Bj%7D%5E%7B%5Cleft(%20i%20%5Cright)%7D%7D#card=math&code=%7B%5Ctheta_j%7D%3A%3D%7B%5Ctheta_j%7D%281-a%5Cfrac%7B%5Clambda%20%7D%7Bm%7D%29-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%28%7Bh%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29x%7Bj%7D%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%7D&id=Gt9Iz)
可以看出，正则化线性回归的梯度下降算法的变化在于，每次都在原有算法更新规则的基础上令 值**减少了一个额外的值**。

我们同样也可以利用正规方程来求解正则化线性回归模型，方法如下所示：

图中的矩阵尺寸为 *(n%2B1)#card=math&code=%28n%2B1%29%2A%28n%2B1%29&id=yeS7D)。
其中X为m行n+1列矩阵（m为样本个数，n为特征个数）

矩阵不可逆问题
假设 样本总数m <= 特征数量 n
如果样本数量比特征数量小的话, 那么这个矩阵 X 转置乘以 X 将是不可逆或奇异的(singluar) 或者用另一种说法是这个矩阵是退化(degenerate)的
幸运的是正规化也为我们解决了这个问题。
具体地说 ，只要正则参数是严格大于0的 。
实际上可以证明该矩阵 X 转置乘以 X 加上 λ 乘以这里这个矩阵将不是奇异的 ，即该矩阵将是可逆的。
因此，使用正则化还可以照顾一些 X 转置乘以 X 不可逆的问题。

正则化线性回归利用它就可以避免过度拟合 ，即使你在一个相对较小的训练集里有很多特征。

7.4 正则化的逻辑回归模型 Regularized Logistic Regression

针对逻辑回归问题，我们在之前的课程已经学习过两种优化算法：我们首先学习了使用梯度下降法来优化代价函数#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29&id=nSbya)，接下来学习了更高级的优化算法，这些高级优化算法需要你自己设计代价函数#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29&id=xv4E7)。

自己计算导数同样对于逻辑回归，我们也给代价函数增加一个正则化的表达式，得到代价函数：

%3D%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B-%7B%7By%7D%5E%7B(i)%7D%7D%5Clog%20%5Cleft(%20%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)-%5Cleft(%201-%7B%7By%7D%5E%7B(i)%7D%7D%20%5Cright)%5Clog%20%5Cleft(%201-%7Bh%5Ctheta%7D%5Cleft(%20%7B%7Bx%7D%5E%7B(i)%7D%7D%20%5Cright)%20%5Cright)%5D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7B2m%7D%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%20%7Bj%7D%5E%7B2%7D%7D#card=math&code=J%5Cleft%28%20%5Ctheta%20%20%5Cright%29%3D%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits%7Bi%3D1%7D%5E%7Bm%7D%7B%5B-%7B%7By%7D%5E%7B%28i%29%7D%7D%5Clog%20%5Cleft%28%20%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29-%5Cleft%28%201-%7B%7By%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%5Clog%20%5Cleft%28%201-%7Bh%5Ctheta%7D%5Cleft%28%20%7B%7Bx%7D%5E%7B%28i%29%7D%7D%20%5Cright%29%20%5Cright%29%5D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7B2m%7D%5Csum%5Climits%7Bj%3D1%7D%5E%7Bn%7D%7B%5Ctheta%20%7Bj%7D%5E%7B2%7D%7D&id=N6buz)

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

要最小化该代价函数，通过求导，得出梯度下降算法为：

{

                                              ![](https://g.yuque.com/gr/latex?%7B%5Ctheta_0%7D%3A%3D%7B%5Ctheta_0%7D-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B((%7Bh_%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)x_%7B0%7D%5E%7B(i)%7D%7D)#card=math&code=%7B%5Ctheta_0%7D%3A%3D%7B%5Ctheta_0%7D-a%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B%28%28%7Bh_%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29x_%7B0%7D%5E%7B%28i%29%7D%7D%29&id=C2gUU)
                                             ![](https://g.yuque.com/gr/latex?%7B%5Ctheta_j%7D%3A%3D%7B%5Ctheta_j%7D-a%5B%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B(%7Bh_%5Ctheta%7D(%7B%7Bx%7D%5E%7B(i)%7D%7D)-%7B%7By%7D%5E%7B(i)%7D%7D)x_%7Bj%7D%5E%7B%5Cleft(%20i%20%5Cright)%7D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7Bm%7D%7B%5Ctheta_j%7D%5D#card=math&code=%7B%5Ctheta_j%7D%3A%3D%7B%5Ctheta_j%7D-a%5B%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%3D1%7D%5E%7Bm%7D%7B%28%7Bh_%5Ctheta%7D%28%7B%7Bx%7D%5E%7B%28i%29%7D%7D%29-%7B%7By%7D%5E%7B%28i%29%7D%7D%29x_%7Bj%7D%5E%7B%5Cleft%28%20i%20%5Cright%29%7D%7D%2B%5Cfrac%7B%5Clambda%20%7D%7Bm%7D%7B%5Ctheta_j%7D%5D&id=fyiU7)
                                            ![](https://g.yuque.com/gr/latex?for#card=math&code=for&id=YHzCD) ![](https://g.yuque.com/gr/latex?j%3D1%2C2%2C...n#card=math&code=j%3D1%2C2%2C...n&id=uaRPI)
                                             }

注：看上去同线性回归一样，但是知道 %3Dg%5Cleft(%20%7B%5Ctheta%5ET%7DX%20%5Cright)#card=math&code=%7Bh%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29%3Dg%5Cleft%28%20%7B%5Ctheta%5ET%7DX%20%5Cright%29&id=RgLqK)，所以与线性回归不同。
Octave 中，我们依旧可以用 fminuc 函数来求解代价函数最小化的参数，值得注意的是参数的更新规则与其他情况不同。
注意：

1. 虽然正则化的逻辑回归中的梯度下降和正则化的线性回归中的表达式看起来一样，但由于两者的#card=math&code=%7Bh_%5Ctheta%7D%5Cleft%28%20x%20%5Cright%29&id=mkF7k)不同所以还是有很大差别。
2. 不参与其中的任何一个正则化。

   第8章-神经网络：表述(Neural Networks: Representation)

   非线性假设 Non-linear Hypotheses

   无论是线性回归还是逻辑回归都有这样一个缺点，即：当特征太多时，计算的负荷会非常大。

假设我们有非常多的特征，例如大于100个变量，我们希望用这100个特征来构建一个非线性的多项式模型，结果将是数量非常惊人的特征组合，即便我们只采用两两特征的组合，我们也会有接近5000个组合而成的特征。这对于一般的逻辑回归来说需要计算的特征太多了。

视觉处理里，特征数量可以达到百万个，普通的逻辑回归模型，不能有效地处理这么多的特征，这时候我们需要神经网络。

模型表示

大脑中的神经网络
每一个神经元都可以被认为是一个处理单元/神经核（processing unit/Nucleus），
它含有许多输入/树突（input/Dendrite），并且有一个输出/轴突（output/Axon）。
神经网络是大量神经元相互链接并通过电脉冲来交流的一个网络。

神经网络模型建立在很多神经元之上，每一个神经元又是一个个学习模型。
这些神经元（也叫激活单元，activation unit）采纳一些特征作为输出，并且根据本身的模型提供一个输出。
下图是一个以逻辑回归模型作为自身学习模型的神经元示例，在神经网络中，参数又可被成为权重（weight）。

我们设计出了类似于神经元的神经网络，效果如下：

• 是输入单元（input units），我们将原始数据输入给它们。
• 是中间单元，它们负责将数据进行处理，然后呈递到下一层。
• 最后是输出单元，它负责计算 。

神经网络模型是许多逻辑单元按照不同层级组织起来的网络，每一层的输出变量都是下一层的输入变量。
下图为一个3层的神经网络，第一层成为输入层（Input Layer），最后一层称为输出层（Output Layer），中间一层成为隐藏层（Hidden Layers）。我们为每一层都增加一个偏差单位（bias unit）：

下面引入一些标记法来帮助描述模型：

• 代表第 层的第 个激活单元。

• 代表从第 层映射到第 层时的权重的矩阵

对于上图所示的模型，激活单元和输出分别表达为：

我们可以知道：每一个 都是由上一层所有的 和每一个 所对应的 决定的。
我们把这样从左到右的算法称为前向传播算法( FORWARD PROPAGATION )

向量化表示
相对于使用循环来编码，利用向量化的方法会使得计算更为简便。
以上面的神经网络为例，试着计算第二层的值：


我们令 ，则 ，计算后添加 。 计算输出的值为：

我们令
，则 。

上面只是针对训练集中一个训练实例所进行的计算。
如果我们要对整个训练集进行计算，我们需要将训练集特征矩阵进行转置，使得同一个实例的特征都在同一列里。即：

为了更好了了解Neuron Networks的工作原理，这里先把左半部分遮住：

右半部分其实就是以 ，按照Logistic Regression的方式输出 ：

其实神经网络就像是logistic regression，只不过我们把logistic regression中的输入向量 变成了中间层的 ,
即:

我们可以把 看成更为高级的特征值，也就是 的进化体，并且它们是由 与 决定的，因为是梯度下降的，所以 是变化的，并且变得越来越厉害，所以这些更高级的特征值远比仅仅将 次方厉害，也能更好的预测新数据。
这就是神经网络相比于逻辑回归和线性回归的优势。

例子和直观理解

从本质上讲，神经网络能够通过学习得出其自身的一系列特征。
在普通的逻辑回归中，我们被限制为使用数据中的原始特征 ，我们虽然可以使用一些二项式项来组合这些特征，但是我们仍然受到这些原始特征的限制。
在神经网络中，原始特征只是输入层，在我们上面三层的神经网络例子中，第三层也就是输出层做出的预测利用的是第二层的特征，而非输入层中的原始特征，我们可以认为第二层中的特征是神经网络通过学习后自己得出的一系列用于预测输出变量的新特征。

神经网络来表示一元运算符
神经网络中，单层神经元（无中间层）的计算可用来表示逻辑运算，比如逻辑与(AND)、逻辑或(OR)。
举例说明：逻辑与(AND)；下图中左半部分是神经网络的设计与output层表达式，右边上部分是sigmod函数，下半部分是真值表。
我们可以用这样的一个神经网络表示 AND 函数：

其中
我们的输出函数 即为：

我们知道的图像是：

所以我们有：
所以我们的： 这就是AND函数。

OR函数：

OR与AND整体一样，区别只在于的取值不同。

二元逻辑运算符
二元逻辑运算符（BINARY LOGICAL OPERATORS）当输入特征为布尔值（0 或 1）时，我们可以用一个单一的激活层可以作为二元逻辑运算符，为了表示不同的运算符，我们只需要选择不同的权重即可。

下图的神经元（三个权重分别为-30，20，20）可以被视为作用同于逻辑与（AND）：

下图的神经元（三个权重分别为-10，20，20）可以被视为作用等同于逻辑或（OR）：

下图的神经元（两个权重分别为 10，-20）可以被视为作用等同于逻辑非（NOT）：

我们可以利用神经元来组合成更为复杂的神经网络以实现更复杂的运算。
例如我们要实现 XNOR 功能（输入的两个值均为1或均为0时输出为1，不一样时输出为0）

XOR 是异或，XNOR 是同或，它们都不能简单的用两层神经网络解决，至少需要三层。

首先构造一个能表达 部分的神经元：

然后将表示 的神经元以及表示 的神经用用 OR 进行组合：

我们就得到了一个能实现 运算符功能的神经网络。
按这种方法我们可以逐渐构造出越来越复杂的函数，也能得到更加厉害的特征值。
这就是神经网络的厉害之处。

多类分类 Multiclass Classification

当我们有不止两种分类时（也就是 ），比如以下这种情况，该怎么办？
如果我们要训练一个神经网络算法来识别路人、汽车、摩托车和卡车，在输出层我们应该有4个值。
例如，第一个值为1或0用于预测是否是行人，第二个值用于判断是否为汽车。
输入向量有三个维度，两个中间层，输出层4个神经元分别用来表示4类，也就是每一个数据在输出层都会出现，且其中仅有一个为1，表示当前类。
下面是该神经网络的可能结构示例：


神经网络算法的输出结果为四种可能情形之一：

第四周测试题

B错，XOR 是非线性分类，至少需要3层神经网络来表示
D 错，多个分类的神经网络的每一个输出是概率，要么为0要么为1。但是每个输出之间并无关系，要看你是怎么编码解释的。
选 A C

第9章-?⭐⭐ 神经网络的学习

9.1 代价函数 Cost Function

约定标记方法：
假设神经网络的训练样本有 m 个，每个包含一组输入 x 和一组输出信号 y ，
L 表示神经网络层数， 表示每层的neuron个数（ 表示输出层神经元个数）， 代表最后一层中处理单元的个数。
将神经网络的分类定义为两种情况：二类分类和多类分类，
二类分类： 表示哪一类；
K 类分类： 表示分到 k 类；

回顾逻辑回归问题中我们的代价函数为：

在逻辑回归中，只有一个输出变量，又称标量（scalar），也只有一个因变量 。
但是在神经网络中，我们可以有很多输出变量，我们的 是一个维度为 的向量，并且我们训练集中的因变量也是同样维度的一个向量，因此我们的代价函数会比逻辑回归更加复杂一些，为：

这个看起来复杂很多的代价函数背后的思想还是一样的，我们希望通过代价函数来观察算法预测的结果与真实情况的误差有多大，唯一不同的是，对于每一行特征，我们都会给出 个预测，基本上我们可以利用循环，对每一行特征都预测 个不同结果，然后再利用循环在 个预测中选择可能性最高的一个，将其与中的实际数据进行比较。

正则化的那一项只是排除了每一层 后，每一层的 矩阵的和。

代价函数就是 ：每个类每个样本得到的 与真实值之间的距离的累加和，对参数进行regularization的bias项处理所有参数的平方和。

9.2 反向传播算法 Backpropagation Algorithm

之前我们在计算神经网络预测结果的时候我们采用了一种正向传播方法，我们从第一层开始正向一层一层进行计算，直到最后一层的 。
现在，为了计算代价函数的偏导数 ，我们采用一种更高效的算法：反向传播算法。
反向传播算法是首先计算最后一层的误差，然后再一层一层反向求出各层的误差，直到倒数第二层。

这篇博客讲反向传播算法讲得挺好的 深度学习系列（2）：前向传播和后向传播算法

以一个例子来说明反向传播算法。
假设训练集只有一个样本 ，我们的神经网络是一个四层的神经网络，其中
前向传播算法：

反向传播算法：
从最后一层的误差开始计算

最后一层的误差值是激活单元的预测值 与实际值 之间的误差，（）
我们用 来表示误差，则：
我们利用这个误差值来计算前一层的误差：

• 其中 是 形函数的导数，。

• 而 则是权重导致的误差的和。

下一步是继续计算第二层的误差：

因为第一层是输入变量，不存在误差。我们有了所有的误差的表达式后，便可以计算代价函数的偏导数了。
假设 ，在不做任何正则化处理时有：

• 代表目前所计算的是第几层。
• 代表目前计算层中的激活单元的下标，也将是下一层的第 个输入变量的下标。
• 代表下一层中误差单元的下标，是受到权重矩阵中第 行影响的下一层中的误差单元的下标。

如果考虑正则化处理，并且训练集是一个特征矩阵而非向量。
在上面的特殊情况中，需要计算每一层的误差单元来计算代价函数的偏导数。
在更为一般的情况中，同样需要计算每一层的误差单元，但是需要为整个训练集计算误差单元，此时的误差单元也是一个矩阵，用 来表示这个误差矩阵。

• 第 层的第 个激活单元受到第 个参数影响而导致的误差。

反向传播算法表示为：⭐⭐

即首先用正向传播方法计算出每一层的激活单元，利用训练集的结果与神经网络预测的结果求出最后一层的误差，
然后利用该误差运用反向传播法计算出直至第二层的所有误差。

在求出了 之后，我们便可以计算代价函数的偏导数了，计算方法如下：

⭐⭐

9.3 反向传播算法的直观理解 Backpropagation Intuition

前向传播算法：

反向传播算法：


误差从后往前算，每一个误差等于从它发出去的箭头指向的下一个误差乘上箭头上对应的参数的累加和。

9.4 实现的注意事项：展开参数 Implementation Note_ Unrolling Parameters

怎样把参数从矩阵展开成向量（即 n × 1），以便在高级最优化步骤中的使用


thetaVec 是 231 × 1 的向量
之所以要把 矩阵展开为向量，是因为一些内置的高级优化算法（如 fminunc 等）的参数要求是向量

9.5 梯度检验 Gradient Checking

当我们对一个较为复杂的模型（例如神经网络）使用梯度下降算法时，可能会存在一些不容易察觉的错误，意味着，虽然代价看上去在不断减小，但最终的结果可能并不是最优解。

为了避免这样的问题，我们采取一种叫做数值梯度检查（Numerical Gradient Checking）方法。
这种方法的思想是通过估计梯度值来检验我们计算的导数值是否真的是我们要求的。

具体做法是在代价函数上沿着切线的方向选择离两个非常近的点然后计算两个点的平均值用以估计梯度。
即对于某个特定的 ，我们计算出在 处和 的代价值（ 是一个非常小的值，通常选取 0.001），
然后求两个代价的平均数，用以估计在 处的代价值。

Octave 中代码如下：
gradApprox = (J(theta + eps) – J(theta - eps)) / (2*eps)

当 是一个向量时，我们则需要用偏导数进行检验。
因为代价函数的偏导数检验只针对一个参数的改变进行检验，下面是一个只针对 进行检验的示例：

最后我们还需要对通过反向传播方法计算出的偏导数进行检验。

根据上面的算法，计算出的偏导数存储在矩阵 中。
检验时，我们要将该矩阵展开成为向量，同时我们也将 矩阵展开为向量，
使用数据梯度检查法，我们针对每一个 都计算一个近似的梯度值，将这些值存储于一个近似梯度矩阵中，最终将得出的这个矩阵同 进行比较。

实现步骤：

1. 使用反向传播算法计算出 DVec (展开的 ）
2. 使用数值梯度检查法计算 gradApprox
3. 比较 DVec 和 gradApprox，确保两者值相近
4. 关掉梯度检查法。使用反向传播代码来训练神经网络

之所以用反向传播算法来训练神经网络，而不用梯度检查法，是因为梯度检查法的计算量非常大，非常慢。
相对地，反向传播算法是一个高性能计算导数的方法。

9.6 随机初始化 Random Initialization

任何优化算法都需要一些初始的参数。到目前为止我们都是初始所有参数为 0，这样的初始方法对于逻辑回归来说是可行的，但是对于神经网络来说是不可行的。
如果我们令所有的初始参数都为0，这将意味着我们第二层的所有激活单元都会有相同的值。
同理，如果我们初始所有的参数都为一个非0的数（所有 相等也称为对称权重），结果也是一样的。

初始 如果相等，则计算得到的第二层 也都相等，此时更新的 也都相等，这样下去，会导致中间的隐藏层每一层的各个单元计算出来的值都是相等的，都在计算相同的特征，高度冗余，最后的逻辑回归单元只能得到一个特征，因为前面一层所有的单元的值都一样，这种情况阻止了神经网络学习到更有用的东西。

我们通常初始参数为正负 ε 之间的随机值，假设我们要随机初始一个尺寸为10×11的参数矩阵，代码如下：
Theta1 = rand(10, 11) * (2*eps) – eps
随机矩阵的值都在 [0,1]，这样得到的 Theta1 范围就会在 [-eps,eps]

9.7 小总结

小结一下使用神经网络时的步骤：
网络结构：第一件要做的事是选择网络结构，即决定选择多少层以及决定每层分别有多少个单元。
第一层的单元数即我们训练集的特征数量。
最后一层的单元数是我们训练集的结果的类的数量。
如果隐藏层数大于1，确保每个隐藏层的单元个数相同，通常情况下隐藏层单元的个数越多越好。
我们真正要决定的是隐藏层的层数和每个中间层的单元数。

训练神经网络的步骤：

1. 参数的随机初始化
2. 利用正向传播方法计算所有的
3. 编写计算代价函数 的代码
4. 利用反向传播方法计算所有偏导数
5. 利用数值梯度检验方法检验这些偏导数，确认相似后，关掉数值梯度检验方法

6. 使用优化算法来最小化代价函数

   对于神经网络，其代价函数 J(θ)是一个非凸函数，就是说不是凸函数。因此理论上是能够停留在局部最小值的位置。
   实际上，梯度下降算法和其他一些高级优化方法，理论上都能收敛于局部最小值。

因此梯度下降算法的原理是从某个随机的初始点开始，它将会不停的往下下降。
那么反向传播算法的目的就是算出梯度下降的方向，而梯度下降的过程就是沿着这个方向一点点的下降，一直到我们希望得到的点，在这里我们希望找到的就是局部最优点。
所以当在执行反向传播算法，并且使用梯度下降或者更高级的优化方法时，这幅图片很好地帮你解释了基本的原理 。
也就是试图找到某个最优的参数值，这个值使得我们神经网络的输出值与 y(i) 的实际值，也就是训练集的输出观测值尽可能的接近

9.8 自动驾驶 Autonomous Driving

神经网络学习的重要例子：使用神经网络来实现自动驾驶，也就是说使汽车通过学习来自己驾驶。

ALVINN (Autonomous Land Vehicle In a Neural Network)是一个基于神经网络的智能系统，通过观察人类的驾驶来学习驾驶，ALVINN能够控制NavLab，装在一辆改装版军用悍马，这辆悍马装载了传感器、计算机和驱动器用来进行自动驾驶的导航试验。

实现ALVINN功能的第一步，是对它进行训练，也就是训练一个人驾驶汽车。

ALVINN每两秒将前方的路况图生成一张数字化图片，并且记录驾驶者的驾驶方向，得到的训练集图片被压缩为30x32像素，并且作为输入提供给ALVINN的三层神经网络，通过使用反向传播学习算法，ALVINN会训练得到一个与人类驾驶员操纵方向基本相近的结果。
一开始，我们的网络选择出的方向是随机的，大约经过两分钟的训练后，我们的神经网络便能够准确地模拟人类驾驶者的驾驶方向，对其他道路类型，也重复进行这个训练过程，当网络被训练完成后，操作者就可按下运行按钮，车辆便开始行驶了。

每秒钟ALVINN生成12次数字化图片，并且将图像传送给神经网络进行训练，多个神经网络同时工作，每一个网络都生成一个行驶方向，以及一个预测自信度的参数，预测自信度最高的那个神经网络得到的行驶方向。
比如这里，在这条单行道上训练出的网络将被最终用于控制车辆方向，车辆前方突然出现了一个交叉十字路口，当车辆到达这个十字路口时，我们单行道网络对应的自信度骤减，当它穿过这个十字路口时，前方的双车道将进入其视线，双车道网络的自信度便开始上升，当它的自信度上升时，双车道的网络，将被选择来控制行驶方向，车辆将被安全地引导进入双车道路。

第10章-应用机器学习的建议

10.3 评估假设 — 交叉验证集

在选择模型时，我们会有多个假设，这就需要评估这些假设。可以用代价函数的大小来衡量假设的好坏。
将数据划分为训练集和测试集：

• 而如果选择一个在训练集上表现好的模型，但不一定在测试集上表现好，可能会有过拟合的问题。
• 而如果选择一个在测试集上表现好的模型，选择出来的这个模型可能只是刚好在这个测试集上代价函数最小，如果往新的数据推广，不一定效果好。

所以目前通常更好的办法，是将数据划分为三个部分，【训练集：验证集：测试集】
模型的选择办法为：

1. 使用训练集训练出10个模型
2. 用10个模型分别对交叉验证集计算得出交叉验证误差（代价函数的值）
3. 选取代价函数值最小的模型
4. 用步骤3中选出的模型对测试集计算得出推广误差（代价函数的值）

10.4 诊断偏差和方差

High bias 是 欠拟合，而 high variance 是 过拟合
High bias (underfitting): both and will be high. Also,
High variance (overfitting): will be low and will be much greater than

10.5 正则化

• 当 λ 很大时，θ -> 0 ， 欠拟合
• 当 λ 很小时，θ ->∞ ， 过拟合

为了选择模型和正则化参数 λ，应按照以下步骤：

1. 创建一个 λ 集合，如 λ∈{0,0.01,0.02,0.04,0.08,0.16,0.32,0.64,1.28,2.56,5.12,10.24}
2. 创建一组具有不同degree或任何其他变体的模型
3. 遍历 λ 并为每个 λ 遍历所有模型以学习一些 Θ
4. 选择在交叉验证集上产生最低错误的最佳组合
5. 使用最佳组合 Θ 和 λ，将其应用于 看它是否对问题有很好的泛化

10.6 学习曲线

学习曲线可以用来判断某一个学习算法是否处于偏差、方差问题。是一个很好的合理检验（sanity check）。
学习曲线是将训练集误差和交叉验证集误差作为训练集样本数量（m）的函数绘制的图表。

high bias:
小规模训练集： 低，而 高
大规模训练集： 和 都很高，且

可以看出，无论训练集大小多少，对于误差都不会有太大改观。也就是说在高偏差/欠拟合的情况下，增加数据到训练集不一定能有帮助。

high variance：
小规模训练集： 低，而 高
大规模训练集： 随着训练集大小的增加而增加，而 则是继续下降而不趋于平稳， 但它们之间的差异仍然很大。

假设我们使用一个非常高次的多项式模型，并且正则化非常小，可以看出，当交叉验证集误差远大于训练集误差时，往训练集增加更多数据可以提高模型的效果。也就是说在高方差/过拟合的情况下，增加更多数据到训练集可能可以提高算法效果。

10.6 本章总结

1. 获得更多的训练样本——解决高方差
2. 尝试减少特征的数量——解决高方差
3. 尝试获得更多的特征——解决高偏差
4. 尝试增加多项式特征——解决高偏差
5. 尝试减少正则化程度λ——解决高偏差
6. 尝试增加正则化程度λ——解决高方差

神经网络模型选择：

• 使用较小的神经网络，类似于参数较少的情况，容易导致高偏差和欠拟合，但计算代价较小
• 使用较大的神经网络，类似于参数较多的情况，容易导致高方差和过拟合，虽然计算代价比较大，但是可以通过正则化手段来调整而更加适应数据。

通常选择较大的神经网络并采用正则化处理会比采用较小的神经网络效果要好。
对于神经网络中的隐藏层的层数的选择，通常从一层开始逐渐增加层数。
为了更好地作选择，可以把数据分为训练集、交叉验证集和测试集，针对不同隐藏层层数的神经网络训练神经网络， 然后选择交叉验证集代价最小的神经网络。

第11章-机器学习系统设计

误差分析（Error Analysis）

构建一个学习算法的推荐方法为：

1. 从一个简单的能快速实现的算法开始，实现该算法并用交叉验证集数据测试这个算法

2.绘制学习曲线，决定是增加更多数据，或者添加更多特征，还是其他选择
3.进行误差分析：人工检查交叉验证集中我们算法中产生预测误差的样本，看看这些样本是否有某种系统化的趋势

类偏斜的误差度量 Error Metrics for Skewed Classes

类偏斜情况表现为我们的训练集中有非常多的同一种类的样本，只有很少或没有其他类的样本。
查准率/准确率（Precision）和 查全率/召回率（Recall）
我们将算法预测的结果分成四种情况：

1. 正确肯定（True Positive,TP）：预测为真，实际为真
2. 正确否定（True Negative,TN）：预测为假，实际为假
3. 错误肯定（False Positive,FP）：预测为真，实际为假
4. 错误否定（False Negative,FN）：预测为假，实际为真

查准率/准确率 = TP/(TP+FP) ：度量的是被预测为正例的样本中有多少是真正的正例的比率

例，在所有我们预测有恶性肿瘤的病人中，实际上有恶性肿瘤的病人的百分比，越高越好。

查全率/召回率 = TP/(TP+FN)：度量的是正类样本中有多少被预测为正类的比率

例，在所有实际上有恶性肿瘤的病人中，成功预测有恶性肿瘤的病人的百分比，越高越好。

|


| |

实际值 | | | —- | —- | —- | —- | | | Positive | Negtive | | 预测值 | Positive | TP | FP | | | Negtive | FN | TN |

查准率和查全率之间的权衡 - 阈值选择

预测肿瘤性质的例子。假使，我们的算法输出的结果在0-1 之间，我们使用阀值0.5 来预测真和假。

• 如果我们希望只在非常确信的情况下预测为真（肿瘤为恶性），即我们希望更高的查准率，我们可以使用比0.5更大的阀值，如0.7，0.9。这样做我们会减少错误预测病人为恶性肿瘤的情况，同时却会增加未能成功预测肿瘤为恶性的情况。
• 如果我们希望提高查全率，尽可能地让所有有可能是恶性肿瘤的病人都得到进一步地检查、诊断，我们可以使用比0.5更小的阀值，如0.3。 我们可以将不同阀值情况下，查全率与查准率的关系绘制成图表，曲线的形状根据数据的不同而不同。

有一个帮助选择这个阀值的方法：计算F1 值（F1 Score），其计算公式为：

我们选择使得F1值最高的阀值。

第12章-支持向量机

目标函数/代价函数

支持向量机的目标函数/代价函数：

有别于逻辑回归的假设函数输出的是概率。SVM的代价函数，直接预测的值等于1，还是等于0。

其和逻辑回归的代价函数的联系：

大边界分类

人们有时将支持向量机看作是大间距分类器。

• 如果你有一个正样本 y= 1，则只有在 z >=1 时，代价函数 cost1(z) 才等于0。换句话说，如果你有一个正样本，我们会希望θ^Tx >= 1。
• 反之，如果 y= 0，它只有在 z <= -1 的区间函数值为0。

事实上，相比逻辑回归，支持向量机的要求更高，不仅仅要能正确分开输入的样本，即不仅仅要求>0，我们需要的是比0值大很多，比如大于等于1，我也想这个比0小很多，比如我希望它小于等于-1，这就相当于在支持向量机中嵌入了一个额外的安全因子，或者说安全的间距因子。

直观理解大间距分类器

考虑一个特例。将这个参数C设置成一个非常大的值。比如我们假设的值为100000或者其它非常大的数，然后来观察支持向量机会给出什么结果？
如果 C 非常大，则最小化代价函数的时候，我们将会很希望找到一个使第一项为0的最优解。
如果你考察这样一个数据集，其中有正样本，也有负样本，可以看到这个数据集是线性可分的。

下图中有很多条决策界（黑线，粉线，绿线）可以将正样本和负样本分开。
支持向量机将会选择这个黑色的决策边界，相较于之前我用粉色或者绿色的决策边界，它看起来好得多，更稳健。在分离正样本和负样本上它显得的更好。
这条黑线有更大的距离，这个距离叫做间距(margin)。

当画出这两条额外的蓝线，我们看到黑色的决策界和训练样本之间有更大的最短距离。
这个距离叫做支持向量机的间距，而这是支持向量机具有鲁棒性的原因，因为它努力用一个最大间距来分离样本。因此支持向量机有时被称为大间距分类器。

正则化因子常数C设置
前面的例子里将这个大间距分类器中的正则化因子常数设置的非常大，如100000。但是这会受到异常点(outlier) 的影响。比如我们加入一个额外的正样本。

加入了这样一个样本之后，SVM为了将正负样本用最大间距分开，也许会得到类似粉色这条线这样的决策边界。这十分不明智的。
但是所以如果将C设置得小一点，则会最终得到黑色这条线。
C = 1 / λ，因此：

• C 较大时，相当于 λ 较小，可能会导致过拟合，高方差。
• C 较小时，相当于λ 较大，可能会导致低拟合，高偏差。

数学理解大间距分类器

核函数

一个多项式的模型可以解决无法用直线进行分隔的分类问题

用一些列新的特征 f 来替换上述模型中的每一项，即

得到

除了对原有特征进行组合以外，还可以利用核函数来计算出新的特征，构造
给定一个训练样本 x ，利用 x 的各个特征与我们预先选定的地标(landmarks) 的近似程度来选取新的特征 。
例如，
similarity就是核函数。这里的核函数是一个高斯核函数。当然其他形式的核函数。

• 如果一个训练样本 x 与 地标 l 之间的距离非常近，则新的特征就近似于1；
• 如果一个训练样本 x 与 地标 l 之间的距离非常远，则新的特征就近似于0

如何选择地标？
我们通常是根据训练集的数量选择地标的数量，即如果训练集中有 m 个样本，则我们选取 m 个地标，并且令
这样做的好处在于：现在我们得到的新特征是建立在原有特征与训练集中所有其他特征之间距离的基础之上的。

我们通常需要编写核函数，并且如果我们使用高斯核函数，那么在使用之前进行特征缩放是非常必要的。
另外，支持向量机也可以不使用核函数，不使用核函数又称为线性核函数(linear kernel)，当我们不采用非常复杂的函数，或者我们的训练集特征非常多而样本非常少的时候，可以采用这种不带核函数的支持向量机。

下面是支持向量机的两个参数 和 的影响：
C 较大时，相当于 λ 较小，可能会导致过拟合，高方差；
C 较小时，相当于 λ 较大，可能会导致低拟合，高偏差；
较大时，可能会导致低方差，高偏差；
较小时，可能会导致低偏差，高方差。

使用支持向量机

在高斯核函数之外我们还有其他一些选择，如：
多项式核函数（Polynomial Kernel）
字符串核函数（String kernel）
卡方核函数（ chi-square kernel）
直方图交集核函数（histogram intersection kernel）
等等…
这些核函数的目标也都是根据训练集和地标之间的距离来构建新特征，这些核函数需要满足Mercer’s定理，才能被支持向量机的优化软件正确处理。

多类分类问题
假设我们利用之前介绍的一对多方法来解决一个多类分类问题。如果一共有 k 个类，则我们需要 k 个模型，以及 k 个参数向量 θ。我们同样也可以训练 k 个支持向量机来解决多类分类问题。但是大多数支持向量机软件包都有内置的多类分类功能，我们只要直接使用即可。

从逻辑回归模型，我们得到了支持向量机模型，在两者之间，我们应该如何选择呢？
下面是一些普遍使用的准则：
n 为特征数，m 为训练样本数。
(1)如果相较于 m 而言，n 要大许多，即训练集数据量不够支持我们训练一个复杂的非线性模型，我们选用逻辑回归模型或者不带核函数的支持向量机。
(2)如果 n 较小，而且 m 大小中等，例如在 1-1000 之间，而在10-10000之间，使用高斯核函数的支持向量机。
(3)如果n 较小，而 m 较大，例如 n 在1-1000之间，而 m 大于50000，则使用支持向量机会非常慢，解决方案是创造、增加更多的特征，然后使用逻辑回归或不带核函数的支持向量机。

值得一提的是，神经网络在以上三种情况下都可能会有较好的表现，但是训练神经网络可能非常慢，选择支持向量机的原因主要在于它的代价函数是凸函数，不存在局部最小值。

第13章-无监督学习-聚类

在一个典型的监督学习中，我们有一个有标签的训练集，目标是找到能够区分正样本和负样本的决策边界，据此拟合一个假设函数。
与此不同的是，在非监督学习中，我们的数据没有附带任何标签，我们拿到的数据就是这样的：

在非监督学习中，我们需要将一系列无标签的训练数据，输入到一个算法中，然后我们告诉这个算法，为我们找找这个数据的内在结构给定数据。我们可能需要某种算法帮助我们寻找一种结构。图上的数据看起来可以分成两个分开的点集（称为簇），一个能够找到我圈出的这些点集的算法，就被称为聚类算法。

K-均值K-Means 算法

K-均值是最普及的聚类算法，算法接受一个未标记的数据集，然后将数据聚类成不同的组。

K-均值是一个迭代算法，假设我们想要将数据聚类成n个组，其方法为:

1. 首先选择 K 个随机的点，称为聚类中心（cluster centroids）；
2. 对于数据集中的每一个数据，按照距离 K 个中心点的距离，将其与距离最近的中心点关联起来，与同一个中心点关联的所有点聚成一类。
3. 计算每一个组的平均值，将该组所关联的中心点移动到平均值的位置。
4. 重复步骤2-4直至中心点不再变化。

下面是一个聚类示例：
首先，随机生成两个点，这两个点就叫聚类中心，如图中蓝色和红色的×

然后遍历每个样本点（图中绿点），然后根据每一个点是与红色聚类中心更近还是与蓝色聚类中心更近来将每个数据点分配给这两个聚类中心之一（即将每个点染成红色或者蓝色）

接下来是移动聚类中心，将聚类中心移动到同色的点的均值处

再次检查所有点，然后根据这些点与红色还是蓝色的聚类中心更近将其涂成红色或是蓝色

然后再次移动聚类中心

再进行一次簇分配，根据它们离哪个聚类中心更近涂颜色，完成后再移动聚类中心

到这里就完成了，因为之后你就算继续运行K均值算法的迭代聚类中心也不会再改变了，并且点的颜色也不会再改变了。此时我们可以说K均值已经聚合了。

K-mean 算法还可以用在一些不是能够明确分配为K簇的场景中，如右图。K-mean 算法还是能够将这些数据分成几个簇

优化目标

K-mean 算法实际上第一步最小化J关于变量c，第二步最小化J关于变量μ，然后保持迭代

随机初始化

如何初始化K均值聚类算法？
如何使得K均值算法避开局部最优？

如果担心K均值算法落入到局部最优，为了让K均值算法找到最有可能的聚类。可以尝试多次随机初始化，以此来保证我们能得到一个足够好的结果，一个尽可能全局最优值。

选择聚类数

如何去选择聚类数量，即如何选择参数K的值？
这个问题其实没有什么好的答案，也没有能自动处理的方法。目前为止，用来决定聚类数量最常用的方法仍然是通过观察可视化的图人工手动的去选择。

一种选择 K 的方法如下图“肘部法则”

第14章-降维

降维的好处

降维的一个好处是可以用来数据压缩。

降维的另外一个好处是可以用来数据可视化。

主成分分析(PCA)算法

PCA - pricipal components analysis
PCA做的是：它会找一个降维平面（在这个例子中就是这条红色直线），然后将数据投影到上面，使得每个数据点到投影直线的距离的平方（投影误差）最小。

PCA并不是线性回归

做PCA之前，先做一些数据处理，如特征放缩和均值化

实际操作PCA的过程

1. 计算协方差矩阵
2. 计算协方差矩阵的特征向量
3. 计算新的映射值Z（新的特征）

将压缩的数据恢复到原始高维数据近似值

如何选择主成分的个数K

应用PCA

最好不要用PCA来做防止过拟合，因为PCA的过程只用到了X，会丢失一些与y有关的重要的特征信息。

第15章-异常检测

异常检测

异常检测：给定数据集 假使数据集是正常的，我们希望知道新的数据是不是异常的，即这个测试数据不属于该组数据的几率如何。我们所构建的模型应该能根据该测试数据的位置告诉我们其属于一组数据的可能性 。

上图中，在蓝色圈内的数据属于该组数据的可能性较高，而越是偏远的数据，其属于该组数据的可能性就越低。
这种方法称为密度估计，表达如下：

用高斯分布开发异常检测算法

高斯分布

应用高斯分布开发异常检测算法

下图是一个由两个特征的训练集，以及特征的分布情况：

下面的三维图表表示的是密度估计函数，z轴为根据两个特征的值所估计p(x)值：

我们选择一个 ε，将 p(x) = ε 作为我们的判定边界，当p(x) > ε 时预测数据为正常数据，否则为异常。

开发和评价一个异常检测系统

异常检测算法是一个非监督学习算法，意味着我们无法根据结果变量 y 的值来告诉我们数据是否真的是异常的。我们需要另一种方法来帮助检验算法是否有效。
当我们开发一个异常检测系统时，我们从带标记（异常或正常）的数据着手，我们从其中选择一部分正常数据用于构建训练集，然后用剩下的正常数据和异常数据混合的数据构成交叉检验集和测试集。

例如：我们有10000台正常引擎的数据，有20台异常引擎的数据。 我们这样分配数据： 6000台正常引擎的数据作为训练集 2000台正常引擎和10台异常引擎的数据作为交叉检验集 2000台正常引擎和10台异常引擎的数据作为测试集

具体的评价方法如下：

1. 根据测试集数据，我们估计特征的平均值和方差并构建p(x)函数
2. 对交叉检验集，我们尝试使用不同的 ε 值作为阀值，并预测数据是否异常，根据F1值或者查准率与查全率的比例来选择 ε
3. 选出 ε 后，针对测试集进行预测，计算异常检验系统的F1值，或者查准率与查全率之比。

异常检测和监督学习的区别

两者比较：

选择特征

对于异常检测算法，我们使用的特征是至关重要的，下面谈谈如何选择特征：
异常检测假设特征符合高斯分布，如果数据的分布不是高斯分布，异常检测算法也能够工作，但是最好还是将数据转换成高斯分布。
例如使用对数函数 ，或者

误差分析：
一个常见的问题是一些异常的数据可能也会有较高的p(x)值，因而被算法认为是正常的。
这种情况下误差分析能够帮助我们，我们可以分析那些被算法错误预测为正常的数据，观察能否找出一些问题。我们可能能从问题中发现我们需要增加一些新的特征，增加这些新特征后获得的新算法能够帮助我们更好地进行异常检测。
我们通常可以通过将一些相关的特征进行组合，来获得一些新的更好的特征（异常数据的该特征值异常地大或小）。

多元高斯分布

假使我们有两个相关的特征，而且这两个特征的值域范围比较宽，这种情况下，一般的高斯分布模型可能不能很好地识别异常数据。其原因在于，一般的高斯分布模型尝试的是去同时抓住两个特征的偏差，因此创造出一个比较大的判定边界。

下图中是两个相关特征，洋红色的线（根据ε的不同其范围可大可小）是一般的高斯分布模型获得的判定边界，很明显绿色的X所代表的数据点很可能是异常值，但是其p(x)值却仍然在正常范围内。多元高斯分布将创建像图中蓝色曲线所示的判定边界。

在一般的高斯分布模型中，我们计算p(x) 的方法是： 通过分别计算每个特征对应的几率然后将其累乘起来，在多元高斯分布模型中，我们将构建特征的协方差矩阵，用所有的特征一起来计算 p(x)。


下面我们来看看协方差矩阵是如何影响模型的：

上图是5个不同的模型，从左往右依次分析：

1. 是一个一般的高斯分布模型
2. 通过协方差矩阵，令特征1拥有较小的偏差，同时保持特征2的偏差
3. 通过协方差矩阵，令特征2拥有较大的偏差，同时保持特征1的偏差
4. 通过协方差矩阵，在不改变两个特征的原有偏差的基础上，增加两者之间的正相关性
5. 通过协方差矩阵，在不改变两个特征的原有偏差的基础上，增加两者之间的负相关性

原高斯分布模型和多元高斯分布模型的比较：
可以证明的是，原本的高斯分布模型是多元高斯分布模型的一个子集。

原高斯分布模型被广泛使用着，如果特征之间在某种程度上存在相互关联的情况，我们可以通过构造新新特征的方法来捕捉这些相关性。
如果训练集不是太大，并且没有太多的特征，我们可以使用多元高斯分布模型。

使用多元高斯分布进行异常检测

首先，我们把我们的训练集，和我们的拟合模型，我们计算 p(x)，设定μ和协方差矩阵。

如图，该分布在中央最多，越到外面的圈的范围越小。

原始模型与多元高斯模型的关系

第16章-推荐系统

一个推荐系统问题的例子：
假使我们是一个电影供应商，我们有 5 部电影和 4 个用户，我们要求用户为电影打分。

前三部电影是爱情片，后两部则是动作片，我们可以看出Alice和Bob似乎更倾向与爱情片， 而 Carol 和 Dave 似乎更倾向与动作片。并且没有一个用户给所有的电影都打过分。我们希望构建一个算法来预测他们每个人可能会给他们没看过的电影打多少分，并以此作为推荐的依据。

基于内容的推荐系统

在一个基于内容的推荐系统算法中，我们假设对于我们希望推荐的东西有一些数据，这些数据是有关这些东西的特征。
在我们的例子中，我们可以假设每部电影都有两个特征，如 代表电影的浪漫程度， 代表电影的动作程度。

则每部电影都有一个特征向量，如 是第一部电影的特征向量为[0.9 0]。

协同过滤

给定参数，去学习特征值

给定特征值估计参数
给定参数估计特征值
那到底是鸡生蛋还是蛋生鸡？ ——> 一般来说初始猜测参数，然后学习到特征值，再进行不断迭代

协同过滤算法

实际上有一种算法将两者结合了，不再需要再这样不停地计算x和θ，而是能够将x和θ同时计算出来

向量化：低秩矩阵分解

协同过滤算法的向量化实现

寻找到相关影片：

均值归一化

sometimes可以让算法运行得更好一些
如果我们新增一个用户 Eve，并且 Eve 没有为任何电影评分，那么我们以什么为依据为Eve推荐电影呢？
我们首先需要对结果 Y 矩阵进行均值归一化处理，将每一个用户对某一部电影的评分减去所有用户对该电影评分的平均值。
然后我们利用这个新的 Y 矩阵来训练算法。
如果我们要用新训练出的算法来预测评分，则需要将平均值重新加回去，预测
对于Eve，我们的新模型会认为她给每部电影的评分都是该电影的平均分。

第17章-大规模机器学习

如果我们有一个低方差的模型，增加数据集的规模可以帮助你获得更好的结果。
怎样应对一个大规模（如有100万条记录）的训练集？
以线性回归模型为例，每一次梯度下降迭代，都需要计算训练集的误差的平方和，如果我们的学习算法需要有20次迭代，在大规模训练集上便是非常大的计算代价。

计算代价大：用求100万条记录总和的计算量来计算仅仅一步的梯度下降

所以，首先应该做的事是去检查一个这么大规模的训练集是否真的必要，也许我们只用1000个训练集也能获得较好的效果，我们可以绘制学习曲线来帮助判断。

随机梯度下降法

如果我们一定需要一个大规模的训练集，我们可以尝试使用随机梯度下降法来代替批量梯度下降法。

批量梯度下降和随机梯度下降的对比
梯度下降法的问题是，当m值很大时，需要对所有m个训练样本求和，计算量就变得很大。并且，为了计算一个微分项，这种算法需要把所有m个数据读入计算机，而计算机内存并没有那么大，则就需要连续将数据不断传入。而随机梯度下降算法，每次迭代不用考虑全部的训练样本，只需要考虑一个样本。

随机梯度下降算法
随机梯度下降算法过程：

1. 随机将m个训练样本打乱，重新排列
2. 对m个训练样本进行遍历，依次进行参数θ的更新
3. 最外面的循环会多次遍历整个训练集

随机梯度下降的做法实际上是扫描了所有的训练样本，每一次扫面都是针对一个训练样本，对它的代价函数计算一小步的梯度下降，然后把参数θ稍微修改一点，使其对这个训练样本的拟合变得好一点。
跟批量梯度下降不同的是，随机梯度下降不需要等到对所有m个训练样本求和来得到梯度项，而是只需要对单个训练样本求出这个梯度项，已经在这个过程中开始优化参数了。

收敛性：
批量梯度下降的收敛过程会倾向于一条近似的直线，一直找到全局最小值。
而随机梯度下降中，每一次迭代会更块。一般来说，参数是朝着全局最小值的方向被更新的，但也不一定。有时候看起来它是以某个比较随机、迂回的路径在朝全局最小值逼近。最终会在某个靠近全局最小值的区域内徘徊，而不是直接逼近全局最小值并停留在那点。

小批量梯度下降

随机梯度下降收敛

在批量梯度下降中，我们可以令代价函数 J 为迭代次数的函数，绘制图表，根据图表来判断梯度下降是否收敛。但是，在大规模的训练集的情况下，这是不现实的，因为计算代价太大了。

在随机梯度下降中，我们在每一次更新 θ 之前都计算一次代价，然后每 x 次（如每1000次）迭代后，求出这 x 次对训练实例计算代价的平均值，然后绘制这些平均值与 x 次迭代的次数之间的函数图表。
应用这种方法，既可以保证随机梯度下降法正在正常运转和收敛，也可以用它来调整学习速率 α 的大小。

分析图表

当我们绘制这样的图表时，可能会得到一个颠簸不平但是不会明显减少的函数图像（如上面左下图中蓝线所示）。我们可以增加 α 来使得函数更加平缓，也许便能看出下降的趋势了（如上面左下图中红线所示）；或者可能函数图表仍然是颠簸不平且不下降的（如洋红色线所示），那么我们的模型本身可能存在一些错误。
如果我们得到的曲线如上面右下方所示，不断地上升，那么我们可能会需要选择一个较小的学习率 α 。
我们也可以令学习率随着迭代次数的增加而减小，例如令：

随着我们不断地靠近全局最小值，通过减小学习率，我们迫使算法收敛而非在最小值附近徘徊。 但是通常我们不需要这样做便能有非常好的效果了，对进行调整所耗费的计算通常不值得。

在线学习

在线学习机制是一种新的大规模的机器学习机制，其可以模型化问题。
在线学习算法指的是对数据流而非离线的静态数据集的学习。

许多在线网站都有持续不断的用户流，对于每一个用户，网站希望能在不将数据存储到数据库中便顺利地进行算法学习。

假使我们正在经营一家物流公司，每当一个用户询问从地点A至地点B的快递费用时，我们给用户一个报价，该用户可能选择接受（y=1）或不接受（y=0）。
现在，我们希望构建一个模型，来预测用户接受报价使用我们的物流服务的可能性。因此报价是我们的一个特征，其他特征为距离，起始地点，目标地点以及特定的用户数据等。模型的输出是: p(y=1)。
在线学习的算法与随机梯度下降算法有些类似，我们对单一的实例进行学习，而非对一个提前定义的训练集进行循环。
一旦对一个数据的学习完成了，我们便可以丢弃该数据，不需要再存储它了。这种方式的好处在于，我们的算法可以很好的适应用户的倾向性，算法可以针对用户的当前行为不断地更新模型以适应该用户。

映射化简和数据并行

如果我们能够将我们的数据集分配给不多台计算机，让每一台计算机处理数据集的一个子集，然后我们将计所的结果汇总在求和。这样的方法叫做映射简化。
具体而言，如果任何学习算法能够表达为，对训练集的函数的求和，那么便能将这个任务分配给多台计算机（或者同一台计算机的不同CPU 核心），以达到加速处理的目的。
例如，我们有400个训练实例，我们可以将批量梯度下降的求和任务分配给4台计算机进行处理：

很多高级的线性代数函数库已经能够利用多核CPU的多个核心来并行地处理矩阵运算，这也是算法的向量化实现如此重要的缘故（比调用循环快）。

第18章-应用举例：图片文字识别OCR

图像文字识别应用所作的事是，从一张给定的图片中识别文字。这比从一份扫描文档中识别文字要复杂的多。

为了完成这样的工作，需要采取如下步骤：

1. 文字侦测（Text detection）——将图片上的文字与其他环境对象分离开来
2. 字符切分（Character segmentation）——将文字分割成一个个单一的字符
3. 字符分类（Character classification）——确定每一个字符是什么

滑动窗口

滑动窗口是一项用来从图像中抽取对象的技术。

• 例如我们需要在一张图片中识别行人，首先要做的是用许多固定尺寸的图片来训练一个能够准确识别行人的模型。
• 然后我们用之前训练识别行人的模型时所采用的图片尺寸在我们要进行的行人识别的图片上进行剪裁，将剪裁得到的切片交给模型，让模型判断是否为行人
• 然后在图片上滑动剪裁区域重新进行剪裁，将新剪裁的切片也交给模型进行判断，如此循环直至将图片全部检测完。
• 一旦完成后，我们按比例放大剪裁的区域，再以新的尺寸对图片进行剪裁，将新剪裁的切片按比例缩小至模型所采纳的尺寸，交给模型进行判断，如此循环。

1. 文字侦测阶段

滑动窗口技术也被用于文字识别，首先训练模型能够区分字符与非字符，然后，运用滑动窗口技术识别字符，一旦完成了字符的识别，我们将识别得出的区域进行一些扩展，然后将重叠的区域进行合并。接着我们以宽高比作为过滤条件，过滤掉高度比宽度更大的区域（认为单词的长度通常比高度要大）。
下图中绿色的区域是经过这些步骤后被认为是文字的区域，而红色的区域是被忽略的。

1. 字符切分阶段

下一步是训练一个模型来完成将文字分割成一个个字符的任务，需要的训练集由单个字符的图片和两个相连字符之间的图片来训练模型。

模型训练完后，我们仍然是使用滑动窗口技术来进行字符识别。

1. 字符分类阶段

利用神经网络、支持向量机或者逻辑回归算法训练一个分类器即可。

获取大量数据和人工数据

如果我们的模型是低方差的，那么获得更多的数据用于训练模型，是能够有更好的效果的。
问题在于，我们怎样获得数据，数据不总是可以直接获得的，我们有可能需要人工地创造一些数据。
以我们的文字识别应用为例，我们可以字体网站下载各种字体，然后利用这些不同的字体配上各种不同的随机背景图片创造出一些用于训练的实例，这让我们能够获得一个无限大的训练集。这是从零开始创造实例。
另一种方法是，利用已有的数据，然后对其进行修改，例如将已有的字符图片进行一些扭曲、旋转、模糊处理。只要我们认为实际数据有可能和经过这样处理后的数据类似，我们便可以用这样的方法来创造大量的数据。

有关获得更多数据的几种方法：

1. 人工数据合成
2. 手动收集、标记数据
3. 众包