---

Log

2022.08.06开始新的一章！
2022.08.07继续学习
2022.08.08继续学习
2022.08.09继续学习
2022.08.10继续学习
2022.08.11继续学习。结束这一章！

---

• 本章我们将谈论大规模机器学习，就是处理大数据集的算法。如果我们回溯一下近 5 年或 10 年机器学习历史，当下的学习算法比 5 年前运行的更好，原因之一是现在我们有极其庞大数据量用来训练我们的算法。接下来的内容我们将讲述能够处理如此海量数据的算法。

一、学习大数据集（Learning with large datasets）

1. 举例：易混淆单词分类

• 我们为什么要用这么大的数据集呢？我们已经知晓一种获取高性能的机器学习系统的途径是采用低偏差的学习算法，并用大数据进行训练。一个我们之前已经了解过的例子，这个对易混淆单词进行分类的例子，比如 For breakfast I ate two eggs，这个例子中，从下图的结果可以看出，只要我们用大量数据训练算法，它的效果看起来非常好。从类似的结果可以得出，在机器学习中，通常情况下决定因素往往不是最好的算法，而是谁的训练数据最多。如果我们想进行大数据集的学习，至少我们要能获得大数据集。
  

2. 大数据集学习的计算问题

• 不过大数据集学习有其特有的问题，具体来说，是计算问题。假定我们的训练集的大小 $m$ 为 $100,000,000$，对于许多现代数据集而言，这个数据量是很实际的，例如流行网站获取到的流量数据，我们得到的训练集会比数亿条数据还大得多。假设我们想训练一个线性回归模型或是一个逻辑回归模型，其梯度下降规则如下：
  θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i )

  θj:=θj−\blueα1m∑i=1m(hθ(x(i))−y(i))xj(i)" role="presentation" style="position: relative;">θj:=θj−\blueα1m∑i=1m(hθ(x(i))−y(i))x(i)j$$\begin{array}{r}{\theta }_j:={\theta }_j-\text{blue}\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\end{array}$$
  θj​:=θj​−αm1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​​

• 同时，我们再看看需要计算梯度的项（蓝色标注）。当 $m$ 的值为 $100,000,000$ 时，我们需要对一亿项进行求和，这是为了计算导数项以及演算单步下降。因为计算超过一亿项的代价太大了，为了计算梯度下降中的一步，接下来的几节我们将会讲述某个能够替代这个算法的算法，或是寻找更有效的计算这个导数的方法。

• 当你学完这一章，你就可以知道如何处理模型、线性回归、逻辑回归、神经网络等等，甚至是现在有一亿个样本的数据集。当然在我们把精力花在用一亿个样本训练模型之前，我们应该自问一下，为什么不只用一千个样本，也许我们可以随机选择一亿个样本中的一千个样本的子集，然后仅用这一千个样本来训练算法。所以在投入精力到实际开发软件前，需要训练大量的模型，预先检查往往是个明智的选择，如果用一千个例子的训练效果也是一样的话。
  

• 使用一个非常小的训练集的完整性检查的方法结果可能也是一样的，即如果使用一个非常小的 $m$ 的大小为 $1000$ 的训练集，效果可能相同，它也是绘制学习曲线的常用方法。如果我们要绘制学习曲线，同时如果我们的训练目标看起来像蓝线这样，即 $J_{train}(\theta )$ ，并且如果交叉验证集合目标 $J_{cv}(\theta )$ 看起来像红线这样的话，那这看起来像一个高方差学习算法（上图左），我们更能确信增加额外的训练用例能够提升效果。相反如果绘制的学习曲线像这样的话（上图右），那么这看起来像是经典的高偏差学习算法。在后一种情况中，如果取最大值到 $m=1000$，那么观察 $m=500$ 到 $m=1000$ 的图像，我们可以发现增加 $m$ 到一亿效果不太可能会更好，因此坚持将 $m$ 取值为 $1000$ 也是可以的，而不是投入了很大精力去弄清楚算法的训练集规模。

• 当然，如果我们处于图右的情况，那么自然而然会添加额外的特征项或在神经网络中添加额外的隐藏单元等等，这样我们最终会得到类似图左的情况，它的 $m$ 最大可能取到 $1000$，这也能令我们更确定应该尝试增加基础结构改变算法，使用多于一千的样本集，这样可能会充分利用我们的时间。

• 在大规模的机器学习中，我们喜欢找出合理的计算方法或高效的计算方法，用来处理庞大的数据集。在接下来的几节内容中，我们将了解两个主要方法，第一个称为随机梯度下降（Stochastic gradient descent），第二个为映射化简（Map reduce），用来处理海量的数据集。希望在了解了这些方法之后，我们能够将大数据应用到我们的学习算法之中，同时在许多不同的应用中得到更好的效果。

二、随机梯度下降（Stochastic gradient descent）

• 对于很多机器学习的算法，例如线性回归，逻辑回归和神经网络，我们推导算法的方法是提出一个代价函数，或是提出一个优化目标，然后使用梯度下降这样的算法求代价函数的最小值，但是当我们的训练集很大时，梯度下降算法的计算量会变得非常的大。
• 在这一节中我们将讨论对普通梯度下降算法的改进，称之为随机梯度下降法（Stochastic gradient descent），这将使算法能应用于更大的训练集中。

1. 批量梯度下降（Batch gradient descent）

Linear    regression    with    gradient    descent h θ ( x ) = ∑ j = 0 n θ j x j J t r a i n ( θ ) = 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2

​Linear  regression  with  gradient  descenthθ​(x)=j=0∑n​θj​xj​Jtrain​(θ)=2m1​i=1∑m​(hθ​(x(i))−y(i))2​

• 假设我们正在用梯度下降法来训练一个线性回归模型，快速回顾一下，假设函数是如上面 $h_{\theta }(x)$ 这样的，而代价函数是 $J_{train}(\theta )$ 对应的式子，它是我们的 $m$ 个训练样本的假设函数的平方误差的平均值再乘以 $\frac{1}{2}$，我们之前看到的代价函数都是这样的弓形函数（下图），因此，在图中画出参数 ${\theta }_0$、${\theta }_1$ 对应的坐标轴和代价函数 $J$，它看起来是一个弓形的函数。
  

• 而梯度下降算法是这样的：
  Repeat   {   θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) ( f o r    e v e r y    j = 0 , . . .   , n ) }

  Repeat\ { θj:=θj−α\blue1m∑i=1m(hθ(x(i))−y(i))xj(i)(for  every  j=0,... ,n)}" role="presentation" style="position: relative;">Repeat\ { θj:=θj−α\blue1m∑i=1m(hθ(x(i))−y(i))x(i)j(for  every  j=0,... ,n)}$$\begin{array}{rl}& \mathbf{\text{Repeat { }}\\ & {\theta }_j:={\theta }_j-\alpha \text{blue}\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & (foreveryj=0,...,n)\\ & \mathbf{\text{}}}\end{array}$$
  ​Repeat { θj​:=θj​−αm1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​(for  every  j=0,... ,n)}​

• 在梯度下降的内部循环中，我们要用上面的式子反复更新参数 $\theta$ 的值。接下来，我们将继续使用线性回归作为我们的例子，不过，这里的随机梯度下降的思想是一种很常见的思想，它也同时应用于其它算法，比如逻辑回归，神经网络或者其他基于梯度下降的对应特定训练集的算法。
  

• 上图表示梯度下降的做法，假设上图中最外侧的红叉表示参数的初始位置，当我们运行梯度下降时，不断地迭代，将使参数达到全局最小值。因此，它将会以类似上图中红叉的运动轨迹来达到全局最小值。

• 但是现在有一个问题是，当 $m$ 值很大的时候，计算这个微分项时（上图蓝色标注），计算量会变得非常大，因为需要对 $m$ 个样本进行求和，假设 $m$ 的值为 $3$ 亿，表示在美国大约 $3$ 亿人口，因此，美国的人口普查数据就有这种量级的数据记录。如果我们想要用这些数据去拟合一个线性回归模型的话，那么我们就需要对这 $3$ 亿的数据进行求和，计算量就太大了。

• 这种梯度下降算法有另一个名字，叫做批量梯度下降（Batch gradient descent ），批量这个词指的是我们每次都要同时考虑所有的训练样本，我们称之为一批训练样本，可能这个名字不算最恰当的，但做机器学习的人都习惯这么称呼它。想象一下，如果我们真的有 $3$ 亿人口普查的数据存在硬盘里，那么这种算法需要将这 $3$ 亿人口的数据读入计算机中，仅仅为了计算出这个微分项，我们需要不断地将这些数据传入计算机中，但计算机的内存存不下这么多数据，所以我们得慢慢读取这些数据，然后进行一次求和，再算出这个微分，做完这些以后，我们才完成了梯度下降的其中一步，我们还得重头再来一遍，遍历这 $3$ 亿个数据，然后计算和值，做完这些之后，我们依然只是完成了梯度下降的一小步，然后又要再来一遍，得到第三次迭代，一直这样下去。为了收敛计算结果，我们需要花费很长的时间。

• 对比这种批量梯度下降，我们要介绍的一种新算法就完全不同了，这种方法在每次迭代中不需要考虑全部的训练样本，仅仅只需要考虑一个训练样本。

2. 随机梯度下降（Stochastic gradient descent）

①回顾批量梯度下降算法

• 在介绍新算法之前，我们把批量梯度下降算法再次写出来：
  Batch    gradient    descent J t r a i n ( θ ) = 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 R e p e a t   { θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) ( f o r    e v e r y    j = 0 , . . .   , n ) }
  Batch\ \ gradient\ \ descentJtrain(θ)=12m∑i=1m(hθ(x(i))−y(i))2Repeat {θj:=θj−α\pink1m∑i=1m(hθ(x(i))−y(i))xj(i)(for  every  j=0,... ,n)}" role="presentation" style="position: relative;">Batch\ \ gradient\ \ descentJtrain(θ)=12m∑i=1m(hθ(x(i))−y(i))2Repeat {θj:=θj−α\pink1m∑i=1m(hθ(x(i))−y(i))x(i)j(for  every  j=0,... ,n)}$$\begin{array}{rl}& \mathbf{\text{Batch gradient descent}}\\ & J_{train}(\theta )=\frac{1}{2m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}{)}^2\\ & Repeat\{\\ & {\theta }_j:={\theta }_j-\alpha \text{pink}\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & (foreveryj=0,...,n)\\ & \}\end{array}$$
  ​Batch  gradient  descentJtrain​(θ)=2m1​i=1∑m​(hθ​(x(i))−y(i))2Repeat {θj​:=θj​−αm1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​(for  every  j=0,... ,n)}​
• $J_{train}(\theta )$ 开头的式子是代价函数，${\theta }_j$ 开头的式子是迭代更新过程，粉色那一项在梯度下降的规则中是优化目标代价函数 $J_{train}(\theta )$ 关于参数 ${\theta }_j$ 的偏微分 $\frac{\partial }{\partial {\theta }_j}{J}_{train}(\theta )$。

②随机梯度下降过程

• 下面让我们来看看更高效的算法：
  Stochastic    gradient    descent c o s t ( θ , ( x ( i ) , y ( i ) ) ) = 1 2 ( h θ ( x ( i ) ) − y ( i ) ) 2 J t r a i n ( θ ) = 1 m ∑ i = 1 m c o s t ( θ , ( x ( i ) , y ( i ) ) )
  Stochastic\ \ gradient\ \ descentcost(θ,(x(i),y(i)))=12(hθ(x(i))−y(i))2Jtrain(θ)=1m∑i=1mcost(θ,(x(i),y(i)))" role="presentation" style="position: relative;">Stochastic\ \ gradient\ \ descentcost(θ,(x(i),y(i)))=12(hθ(x(i))−y(i))2Jtrain(θ)=1m∑i=1mcost(θ,(x(i),y(i)))$$\begin{array}{rl}& \mathbf{\text{Stochastic gradient descent}}\\ & cost(\theta ,(x^{(i)},y^{(i)}))=\frac{1}{2}(h_{\theta }(x^{(i)})-y^{(i)}{)}^2\\ & J_{train}(\theta )=\frac{1}{m}\sum _{i=1}^{m}cost(\theta ,(x^{(i)},y^{(i)}))\end{array}$$
  ​Stochastic  gradient  descentcost(θ,(x(i),y(i)))=21​(hθ​(x(i))−y(i))2Jtrain​(θ)=m1​i=1∑m​cost(θ,(x(i),y(i)))​
• 它可以更好地处理大型数据集，为了更好的描述随机梯度下降算法，我们用另一种形式把代价函数写出来，我们将代价函数定义为 $cost(\theta ,(x^{(i)},y^{(i)}))$，它等于 $\frac{1}{2}$ 倍假设函数 $h_{\theta }(x^{(i)})$ 与 $y^{(i)}$ 的平方误差，因此这个代价函数实际上衡量的是我们的假设函数在某个样本 $(x^{(i)},y^{(i)})$ 上的表现，你可能已经发现，总体代价函数 $J_{train}$ 可以被写成上面二式这样的等效的形式，所以 $J_{train}$ 就等于假设函数在 $m$ 个训练样本中每一个样本 $(x^{(i)},y^{(i)})$ 上的代价函数的平均值。
• 将这种方法应用到线性回归中，我们来写出随机梯度下降的过程：

1.   R a n d o m l y    s h u f f l e    ( r e o r d e r )    t r a i n i n g    e x a m p l e s 2.   R e p e a t   {     f o r    i : = 1 , . . .   , m   {     θ j : = θ j − α ( h θ ( x ( i ) ) − y ( i ) ) x j ( i )     ( f o r    e v e r y    j = 0 , . . .   , n )     }     }

​1. Randomly  shuffle  (reorder)  training  examples2. Repeat {   for  i:=1,... ,m {   θj​:=θj​−α(hθ​(x(i))−y(i))xj(i)​   (for  every  j=0,... ,n)   }   }​

• 第一步，随机打乱所以数据，随机打乱的意思是将所有 $m$ 个训练样本重新随机排列，这是标准的数据预处理过程；
• 第二步，在 $i=1,...,m$ 中进行循环，也就是对所有的训练样本进行遍历，然后进行更新参数 ${\theta }_j$，然后我们对所有 $j$ 的值进行更新，不难发现，上面粉色标注的部分的那一项实际上就是批量梯度下降算法中求和式里面的那一部分，事实上，用微积分的知识可以证明这一项等于 $cost$ 函数关于参数 ${\theta }_j$ 的偏微分 $\frac{\partial }{\partial {\theta }_j}cost(\theta ,(x^{(i)},y^{(i)}))$ ，$cost$ 函数就是之前定义的代价函数。
• 所以，随机梯度下降实际上就是遍历所有的训练样本，首先是我们的第一组训练样本 $(x^{(1)},y^{(1)})$ ，现在我们只看第一个样本，此时我们只对第一个训练样本的代价函数进行梯度下降操作，换句话说，我们只关注第一个训练样本，然后把参数稍微修改一下，使其对第一个训练样本拟合得更好一点，完成这个内循环后，然后继续进行第二个训练样本，这里我们做的就是在参数空间中进行另外一小步，也是将参数稍微修改一下，使它对第二个样本拟合得更好一点。做完这些后，再继续进行第三个训练样本，同样还是将参数稍微修改一下，使它对第三个样本拟合得更好一点，以此类推，直到完成所有的训练集。
• 这种重复循环会遍历整个训练集，从这个角度分析随机梯度下降，我们能更好的理解为什么一开始要随机打乱数据，这保证了我们在遍历训练集时，对训练样本的访问是以随机顺序排列的，不管数据是否已经随机排列过，或是一开始就按某种奇怪的顺序排列的，实际上这一步能让随机梯度下降在收敛时能够更快一点，为了保险起见，通常情况下最好还是先把所有数据随机打乱一下，因为我们可能不知道数据是否已经随机排列过。但对于随机梯度下降的更重要的一点是，与批量梯度下降不同，随机梯度下降不需要对全部 $m$ 个样本求和来得到梯度项，而是只需要对单个训练样本求出这个梯度项（粉色标注），在这个过程中，我们已经开始优化参数了，所以就不需要把那 $3$ 亿美国人口普查的数据都遍历一遍了。也就是说，不需要对所有的数据进行扫描，就能对参数进行修改，使其达到全局最小值。对随机梯度下降来说，我们每次只需要关注一个训练样本，而在这个过程中，我们已经开始一点一点把参数朝着全局最小值的方向进行修改了。

③参数更新过程

• 下面我们来看看算法是如何更新参数的，之前已经看到，当使用批量梯度下降时，需要考虑所有的训练样本数据批量梯度下降的收敛过程，会取一条合理的直线来到达全局最小值（下图1）。与之不同的是，在随机梯度下降中，每一次迭代都会更快，因为不需要对所有训练样本进行求和，每一次迭代只需要保证能拟合某一个训练样本就行了。如果我们进行随机梯度下降，假设从这个点（下图2粉叉）开始进行随机梯度下降：

• 第一次迭代可能会让参数朝着这个方向移动（上图3），然后第二次迭代，只考虑第二个训练样本，假如偶然情况下，我们很不幸让参数走了一个错误的方向（上图4），但是在第三次迭代中，又会修改参数，使其更好的拟合第三组训练样本，可能最终会得到这个方向（上图5），然后第四组样本，然后第五第六第七等等。

• 在运行随机梯度下降的过程中我们会发现，总的来看，我们的参数是朝着全局最小值的方向移动的，虽然偶尔也有例外，不过整个过程还是以随机而迂回的路径朝着全局最小值前进（上图6）。实际上，当我们运行随机梯度下降时，和批量梯度下降相比，收敛的形式是不同的。随机梯度下降所做的就是连续不断地在某个区域中朝着全局最小值的方向徘徊，而不是直接达到全局最小值。在实际中其实完全可行，只要参数最终能移动到靠近全局最小值的区域内，所以只要参数最后能够非常接近全局最小值，我们就能得到一个很好的假设。因此，通常我们用随机梯度下降法，能得到一个很接近全局最小值的参数，对于实际应用的目的来说已经足够了。

• 最后一点细节，在随机梯度下降法中，有一个外层循环，它决定了内层循环的执行次数。所以外层循环应该执行多少次呢？这取决于训练集的大小，通常一次就够了，最多到 $10$ 次，但那是特殊情况，所以，最终内层循环次数在 $1$ 到 $10$ 次之间。如果我们有一个非常大的数据集，比如美国人口普查的数据，也就是我们讨论的那3亿个样本，很可能，当我们仅遍历一次训练集时，外层的 $i$ 就是从 $1$ 亿到 $3$ 亿了，很可能我们只遍历一次训练集就能得到一个非常好的假设，因为这是 $m$ 非常大，所以内层循环只用做一次就够了。但通常来说，循环 $1$ 到 $10$ 次，都是非常合理的，但这还是取决于我们的训练样本的大小。

• 如果我们用它与批量下降算法相比的话，批量梯度下降仅仅在其中一步梯度下降的过程中，就需要考虑全部的训练样本，并且这只是梯度下降的一个小小的步骤，但它却需要遍历整个数据集，同时也说明了为什么随机梯度下降算法要快得多。

• 这就是随机梯度下降算法，如果我们能够亲自实现它，我们将能够将这种思想应用到很多学习算法中，来适应更大的数据集，从而提高算法的性能。

三、小批量梯度下降（Mini-batch gradient descent）

• 上一节我们讨论了随机梯度下降算法，以及它比批量梯度下降算法更快的原因。本节我们会讲述另一种方法，称为小批量梯度下降（Mini-batch gradient descent），它有时甚至比随机梯度下降还要快一点。

1. 目前已有算法总结

• 总结一下迄今为止讲过的算法：
  Batch    gradient    descent:    U s e    a l l    m    e x a m p l e s    i n    e a c h    i t e r a t i o n    Stochastic    gradient    descent:    U s e    1    e x a m p l e    i n    e a c h    i t e r a t i o n    Mini–batch    gradient    descent:    U s e    b    e x a m p l e s    i n    e a c h    i t e r a t i o n   

  Batch\ \ gradient\ \ descent:  Use  all  \redm  examples  in  each  iteration  Stochastic\ \ gradient\ \ descent:  Use  \red1  example  in  each  iteration  Mini\text{\textendash}batch\ \ gradient\ \ descent:  Use  \redb  examples  in  each  iteration  " role="presentation" style="position: relative;">Batch\ \ gradient\ \ descent:  Use  all  \redm  examples  in  each  iteration  Stochastic\ \ gradient\ \ descent:  Use  \red1  example  in  each  iteration  Mini\text{\textendash}batch\ \ gradient\ \ descent:  Use  \redb  examples  in  each  iteration  $$\begin{array}{rl}& \mathbf{\text{Batch gradient descent:}}\mathrm{U}\mathrm{s}\mathrm{e}\mathrm{a}\mathrm{l}\mathrm{l}\text{red}m\mathrm{e}\mathrm{x}\mathrm{a}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{s}\mathrm{i}\mathrm{n}\mathrm{e}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\\ & \mathbf{\text{Stochastic gradient descent:}}\mathrm{U}\mathrm{s}\mathrm{e}\text{red}1\mathrm{e}\mathrm{x}\mathrm{a}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{i}\mathrm{n}\mathrm{e}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\\ & \mathbf{\text{Minitext{textendash}batch gradient descent:}}\mathrm{U}\mathrm{s}\mathrm{e}\text{red}b\mathrm{e}\mathrm{x}\mathrm{a}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{s}\mathrm{i}\mathrm{n}\mathrm{e}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\end{array}$$
  ​Batch  gradient  descent:  Use  all  m  examples  in  each  iteration  Stochastic  gradient  descent:  Use  1  example  in  each  iteration  Mini–batch  gradient  descent:  Use  b  examples  in  each  iteration  ​

• 批量梯度下降算法中，每次迭代我们都要用到所有的 $m$ 个样本，而在随机梯度下降算法中，每次迭代只需要使用一个样本。$\mathrm{Mini}\text{–}\mathrm{Batch}$ 梯度下降算法则是介于两者之间。具体来说，这个算法每次迭代会使用 $b$ 个样本（这里 $b$ 是一个称为 $\mathrm{Mini}\text{–}\mathrm{Batch}$ 大小的参数），所以，它是介于批量梯度下降算法和随机梯度下降算法之间的算法。这与批量梯度下降算法有些相似，只不过我们会用一个小得多的批量大小。通常会选择 $b$ 的值为 $b=10$，同时 $b$ 取值范围为 $b=2$ 到 $b=100$，对于 $\mathrm{Mini}\text{–}\mathrm{Batch}$ 大小的选取而言，这是一个常用的取值范围，它的思想是既不一次只用一个样本，也不一次用 $m$ 个样本，而是一次用 $b$ 个样本。
  G e t    b = 10    e x a m p l e s    ( x ( i ) , y ( i ) ) , . . .   , ( x ( i + 9 ) , y ( i + 9 ) ) θ j : = θ j − α 1 10 ∑ k = 1 i + 9 ( h θ ( x ( k ) ) − y ( k ) ) x j ( k )

  Get  \blueb=10  examples  (x(i),y(i)),... ,(x(i+9),y(i+9))θj:=θj−α1\red10∑k=1\bluei+9(hθ(x(k))−y(k))xj(k)" role="presentation" style="position: relative;">Get  \blueb=10  examples  (x(i),y(i)),... ,(x(i+9),y(i+9))θj:=θj−α1\red10∑k=1\bluei+9(hθ(x(k))−y(k))x(k)j$$\begin{array}{rl}& Get\text{blue}b=10examples(x^{(i)},y^{(i)}),...,(x^{(i+9)},y^{(i+9)})\\ & {\theta }_j:={\theta }_j-\alpha \frac{1}{\text{red}10}\sum _{k=1}^{\text{blue}i+9}(h_{\theta }(x^{(k)})-y^{(k)})x_j^{(k)}\end{array}$$
  ​Get  b=10  examples  (x(i),y(i)),... ,(x(i+9),y(i+9))θj​:=θj​−α101​k=1∑i+9​(hθ​(x(k))−y(k))xj(k)​​

• 我们会得到，比如 $b$，这个例子中假设 $b=10$，我们将得到训练集中的 $10$ 个样本，可能是某个 $(x^{(i)},y^{(i)})$ 到 $(x^{(i+9)},y^{(i+9)})$，所以这一共是 $10$ 个样本，然后我们用这 $10$ 个样本来执行梯度下降算法，以完成更新，即线性速率乘以 $\frac{1}{10}$，再乘以一个求和项为当 $k=i$ 到 $k=i+9$ 时 $h_{\theta }(x^{(k)})$ 减 $y^{(k)}$ 之差的和，再乘以 $x_j^{(k)}$。

• 在上面的式子中，是对 $10$ 个样本进行梯度求和的，分母上的 $10$ 就是 $\mathrm{Mini}\text{–}\mathrm{Batch}$ 大小的值（红色标注），并且 $i+9$ 中，$9$ 取自对参数 $b$ 的选择（蓝色标注），运算完后，我们将增大 $i$ 的值为 $10$ ，然后在使用后 $10$ 个样本，并像之前那样继续进行下去。

2. 完整小批量下降算法

①算法内容

• 写一下完整的算法：
  Mini-Batch    gradient    descent S a y    b = 10 , m = 1000 . R e p e a t   { f o r    i : = 1 , 11 , 21 , 31 , . . .   , 991 { θ j : = θ j − α 1 10 ∑ k = 1 i + 9 ( h θ ( x ( k ) ) − y ( k ) ) x j ( k ) ( f o r    e v e r y    j = 0 , . . .   , n ) } }

  Mini-Batch\ \ gradient\ \ descentSay  \blueb=10,\greenm=1000.Repeat {for  i:=1,11,21,31,... ,991{θj:=θj−α\orange1\red10∑k=1\redi+9(hθ(x(k))−y(k))xj(k)(for  every  j=0,... ,n)}}" role="presentation" style="position: relative;">Mini-Batch\ \ gradient\ \ descentSay  \blueb=10,\greenm=1000.Repeat {for  i:=1,11,21,31,... ,991{θj:=θj−α\orange1\red10∑k=1\redi+9(hθ(x(k))−y(k))x(k)j(for  every  j=0,... ,n)}}$$\begin{array}{rl}& \mathbf{\text{Mini-Batch gradient descent}}\\ & Say\text{blue}b=10,\text{green}m=1000.\\ & Repeat\{\\ & fori:=1,11,21,31,...,991\{\\ & {\theta }_j:={\theta }_j-\alpha \text{orange}\frac{1}{\text{red}10}\sum _{k=1}^{\text{red}i+9}(h_{\theta }(x^{(k)})-y^{(k)})x_j^{(k)}\\ & (foreveryj=0,...,n)\\ & \}\\ & \}\end{array}$$
  ​Mini-Batch  gradient  descentSay  b=10,m=1000.Repeat {for  i:=1,11,21,31,... ,991{θj​:=θj​−α101​k=1∑i+9​(hθ​(x(k))−y(k))xj(k)​(for  every  j=0,... ,n)}}​

• 为了简化下标，我们假设 $\mathrm{Mini}\text{–}\mathrm{Batch}$ 大小为 $10$（蓝色标注），训练样本大小为 $1000$（绿色标注），然后使用 $Repeat$ 下括号里的内容进行循环，当 $i=1,11,21,...$ 进行循环，同时步长为 $10$ ，因为我们每次使用 $10$ 个样本，然后执行梯度下降算法，一次用 $10$ 个样本进行更新，那么这个 $10$ 和 $i+9$ （红色标注）都表明 $\mathrm{Mini}\text{–}\mathrm{Batch}$ 大小选定为 $10$（蓝色标注），并且这个 $for$ 循环会在 $i=991$ 时结束，因为如果我们有 $1000$ 个训练样本，需要循环 $100$ 次，每次 $10$ 步，才能遍历我们的整个训练集。

②小批量梯度下降算法 vs. 批量梯度下降算法

• 这就是 $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法，与批量梯度下降相比，它的运行过程会更快。再举一次这个例子，有 $3$ 亿条美国人口普查数据的训练样本，接着在仅遍历前 $10$ 个样本后，我们就可以更新参数 $\theta$ 的值了，我们不需要遍历整个训练样本集，我们仅需要前 $10$ 个样本，就可以运行算法，然后用后 $10$ 个样本来更新参数，以此类推。
• 这就是 $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法比批量梯度下降算法要快的原因，即仅用前 $10$ 个样本就可以运行算法，更新参数，而不需要等我们遍历完所有的 $3$ 亿个样本后才能执行算法更新参数。

③小批量梯度下降算法 vs. 随机梯度下降算法

• 那么 $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法与随机梯度下降算法相比如何呢？为什么我们每次使用 $b$ 个样本，而不像随机梯度下降算法一样每次只使用一个样本呢？答案是，在向量化（Vectorization） 过程中，特别地， $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法可能会比随机梯度下降算法更好，仅当我们有一个好的向量化方式，那样的话，这个求和项（①中橙色标注）涵盖了 $10$ 个样本的总和能以更向量化的方式执行，这将使得我们在 $10$ 个样本中实现部分并行计算，换句话说，通过使用合适的向量化方式，计算余下的样本，有时我们可以部分使用好的数值代数库，然后对 $b$ 个样本并行进行梯度计算，不过如果像随机梯度下降算法一样，每次仅遍历一个样本，不会有太多的并行计算（至少有很少的并行计算）。
• $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法的缺点之一是，当我们有一个额外的参数 $b$ 时，需要确定 $\mathrm{Mini}\text{–}\mathrm{batch}$ 大小，这可能需要费些时间，不过，如果我们有优秀的向量化方法，有时它将比随机梯度下降运行的更快。

• 这就是 $\mathrm{Mini}\text{–}\mathrm{batch}$ 梯度下降算法，某种意义上，它是一个介于随机梯度下降算法和批量梯度下降算法之间的算法。同时，如果我们选择了合适的参数 $b$ ，我们通常使 $b=10$ ，但是其他值，比如 $2$ 到 $100$ 范围内的都将是合理的选择，所以，当我们选用好的 $b$ 值，同时如果使用一个优秀的向量化方法，那么有时它会比随机梯度下降算法和批量梯度下降算法都要快。

四、随机梯度下降收敛（Stochastic gradient descent convergence）

• 现在你已经知道了随机梯度下降算法，但当你在运行算法时，你如何确保调试过程已经完成，并且已经收敛到合适的位置呢？还有一件重要的事，你怎样调整随机梯度下降中学习速率 $\alpha$ 的值呢？本节我们会谈到一些方法来处理这些问题，确保算法能正确收敛，以及选择合适的学习速率 $\alpha$。

1. 检查收敛性（Checking for convergence）

• 回顾之前的批量梯度下降算法：
  Checking    for    convergence B a t c h    g r a d i e n t    d e s c e n t : P l o t    J t r a i n ( θ )    a s    a    f u n c t i o n    o f    t h e    n u m b e r    o f    i t e r a t i o n s    o f g r a d i e n t    d e s c e n t . J t r a i n ( θ ) = 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 S t o c h a s t i c    g r a d i e n t    d e s c e n t : c o s t ( θ , ( x ( i ) , y ( i ) ) ) = 1 2 ( h θ ( x ( i ) ) − y ( i ) ) 2 D u r i n g    l e a r n i n g ,    c o m p u t e    c o s t ( θ , ( x ( i ) , y ( i ) ) )    b e f o r e    u p d a t i n g    θ u s i n g    ( x ( i ) , y ( i ) ) . E v e r y    1000    i t e r a t i o n s    ( s a y ) ,    p l o t    c o s t ( θ , ( x ( i ) , y ( i ) ) )    a v e r a g e d o v e r    t h e    l a s t    1000    e x a m p l e s    p r o c e s s e d    b y    a l g o r i t h m .
  Checking\ \ for\ \ convergenceBatch  gradient  descent:Plot  Jtrain(θ)  as  a  function  of  the  number  of  iterations  ofgradient  descent.\blueJtrain(θ)=12m∑i=1m(hθ(x(i))−y(i))2Stochastic  gradient  descent:\greencost(θ,(x(i),y(i)))=12(hθ(x(i))−y(i))2During  learning,  compute  cost(θ,(x(i),y(i)))  before  updating  θusing  (x(i),y(i)).Every  1000  iterations  (say),  plot  cost(θ,(x(i),y(i)))  averagedover  the  last  1000  examples  processed  by  algorithm." role="presentation" style="position: relative;">Checking\ \ for\ \ convergenceBatch  gradient  descent:Plot  Jtrain(θ)  as  a  function  of  the  number  of  iterations  ofgradient  descent.\blueJtrain(θ)=12m∑i=1m(hθ(x(i))−y(i))2Stochastic  gradient  descent:\greencost(θ,(x(i),y(i)))=12(hθ(x(i))−y(i))2During  learning,  compute  cost(θ,(x(i),y(i)))  before  updating  θusing  (x(i),y(i)).Every  1000  iterations  (say),  plot  cost(θ,(x(i),y(i)))  averagedover  the  last  1000  examples  processed  by  algorithm.$$\begin{array}{rl}& \mathbf{\text{Checking for convergence}}\\ & \mathrm{B}\mathrm{a}\mathrm{t}\mathrm{c}\mathrm{h}\mathrm{g}\mathrm{r}\mathrm{a}\mathrm{d}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{d}\mathrm{e}\mathrm{s}\mathrm{c}\mathrm{e}\mathrm{n}\mathrm{t}:\\ & Plot{J}_{train}(\theta )asafunctionofthenumberofiterationsof\\ & gradientdescent.\\ & \text{blue}{J}_{train}(\theta )=\frac{1}{2m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}{)}^2\\ & \mathrm{S}\mathrm{t}\mathrm{o}\mathrm{c}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{t}\mathrm{i}\mathrm{c}\mathrm{g}\mathrm{r}\mathrm{a}\mathrm{d}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{d}\mathrm{e}\mathrm{s}\mathrm{c}\mathrm{e}\mathrm{n}\mathrm{t}:\\ & \text{green}cost(\theta ,(x^{(i)},y^{(i)}))=\frac{1}{2}(h_{\theta }(x^{(i)})-y^{(i)}{)}^2\\ & Duringlearning,computecost(\theta ,(x^{(i)},y^{(i)}))beforeupdating\theta \\ & using(x^{(i)},y^{(i)}).\\ & Every1000iterations(say),plotcost(\theta ,(x^{(i)},y^{(i)}))averaged\\ & overthelast1000examplesprocessedbyalgorithm.\end{array}$$
  ​Checking  for  convergenceBatch  gradient  descent:Plot  Jtrain​(θ)  as  a  function  of  the  number  of  iterations  ofgradient  descent.Jtrain​(θ)=2m1​i=1∑m​(hθ​(x(i))−y(i))2Stochastic  gradient  descent:cost(θ,(x(i),y(i)))=21​(hθ​(x(i))−y(i))2During  learning,  compute  cost(θ,(x(i),y(i)))  before  updating  θusing  (x(i),y(i)).Every  1000  iterations  (say),  plot  cost(θ,(x(i),y(i)))  averagedover  the  last  1000  examples  processed  by  algorithm.​
• 回顾之前的批量梯度下降算法，确保梯度下降已经收敛的一个标准方法，就是绘制优化代价函数，这是一个关于迭代次数的函数，这个就是代价函数（蓝色标注），我们要确保这个代价函数在每一次迭代中都是下降的。当训练集比较小的时候，这很容易，因为可以迅速算出和值 ${\sum }_{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}{)}^2$，但当训练集非常大的时候，我们不会希望总是暂停我们的的算法，我们不希望我们得定期地暂停随机梯度下降算法来计算这个式子，因为要求出这个式子就得遍历整个训练集。而随机梯度下降算法是每次只考虑一个单独的样本，每次都能让算法前进一点儿，而不需要时不时地在算法运行过程中扫描一遍整个训练集来计算出整个训练集的代价函数。
• 因此，对于随机梯度下降算法，为了检查算法是否收敛，我们可以进行下面的工作，让我们沿用之前定义的 $cost$ 函数（绿色标注）。当随机梯度下降法进行学习时，在我们对某一个样本进行训练前，在随机梯度下降中，我们要关注某样本 $(x^{(i)},y^{(i)})$，然后对这个样本做一次小小的更新，然后再到下一个样本 $(x^{(i+1)},y^{(i+1)})$ ，以此类推，这就是随机梯度下降的做法。所以，当这个算法刚好扫描到样本 $(x^{(i)},y^{(i)})$ ，但在更新参数 $\theta$ 之前，使用这个样本我们可以算出这个样本对应的 $cost$ 函数。
• 我们换一种表达方式再说一遍，当随机梯度下降法对训练集进行扫描时，在我们使用某个样本 $(x^{(i)},y^{(i)})$ 来更新 $\theta$ 之前，让我们来计算出这个训练样本假设的表现有多好，我们要在更新 $\theta$ 前来完成这一步，因为如果我们用这个样本更新了 $\theta$ 的话，再让它在该训练样本上进行预测，其表现就比当前样本更好了。
• 最后，为了检查随机梯度下降是否收敛，我们要做的是，每 $1000$ 次迭代，我们就画出前一步中所计算出的 $cost$ 函数，我们把这些前 $1000$ 个样本的 $cost$ 函数的平均值画出来，如果这样的话，它会有效地帮助估计出我们的算法在前 $1000$ 个样本上表现有多好，所以，比起之前需要时不时地计算 $J_{train}$，那样就得遍历所有的训练样本，而随机梯度下降法的这个步骤只用在更新 $\theta$ 之前计算这些 $cost$ 函数，并不需要太大的计算量。我们要做的就是每 $1000$ 次迭代运算中，求出前 $1000$ 个 $cost$ 函数的平均值，然后把它画出来，通过观察所画的图，我们就能检查出随机梯度下降是否在收敛。

2. 绘制优化代价函数

• 这是几幅所画的图的例子：
  

• 假设我们已经画出了前 $1000$ 组样本的 $cost$ 函数平均值，由于它们只是 $1000$ 组样本的平均值，因此看起来会有很多噪声，它可能不是每一步迭代都在下降。假如我们得到这样的图像（上图 1 蓝线），这个图有很多噪声，因为它只是对一小部分样本求平均值，在该例中，是 $1000$ 个样本。如果我们得到像这样的图像，那么这是一个很不错的下降过程，可以看出代价函数的值在下降，然后从这个点开始（上图 1 绿色标注），图像开始变得平缓。通过这副图像，可以得知，学习算法已经收敛了。

• 如果我们尝试用一个更小的学习速率，那么我们可能会看到算法的学习变得更慢了，所以代价函数下降也变缓了。但是由于使用了更小的学习速率，最后可能会让算法收敛到一个更好的结果，这条红色的曲线（上图 1）就代表用更小学习速率来进行随机梯度下降。这种情况是因为随机梯度下降算法不是直接收敛到全局最小值，而是在一个范围内反复震荡，最后逐渐接近全局最小值。如果用一个更小的学习速率，最后这种振荡就会更小，不过两种曲线的这点差别有时是可以忽略的，但也有时候用更小的学习速率可以得到更好的参数的值。
  P l o t    c o s t ( θ , ( x ( i ) , y ( i ) ) )   ,   a v e r a g e d    o v e r    t h e    l a s t    1000   ( 5000 )    e x a m p l e s .

  Plot  cost(θ,(x(i),y(i))) , averaged  over  the  last  \purple1000 (\red5000)  examples." role="presentation" style="position: relative;">Plot  cost(θ,(x(i),y(i))) , averaged  over  the  last  \purple1000 (\red5000)  examples.$$\begin{array}{rl}& Plotcost(\theta ,(x^{(i)},y^{(i)})),averagedoverthelast\text{purple}1000(\text{red}5000)examples.\end{array}$$
  ​Plot  cost(θ,(x(i),y(i))) , averaged  over  the  last  1000 (5000)  examples.​

• 接下来再看几种其它情况，假如我们运行随机梯度下降，对 $1000$ 组样本取 $cost$ 函数平均值，并且画出图像，那么这可能是另一种可能出现的情况（上图 2 蓝线），看起来算法大概已经收敛了。如果我们把这 $1000$ 组样本（上式紫色标注）提高到要去计算 $5000$ 组样本的均值（上式红色标注），那么我们可能会得到一条更平滑的曲线，像这样（上图 2 红线）。求出均值以后，我们会发现 $5000$ 组样本比起 $1000$ 组样本得到的曲线更为平滑，这就是如果我们增大训练样本的数量所得到的情形。当然它的缺点就是，每隔 $5000$ 个样本，我们才能得到一个数据点，因此，我们所得到的关于算法表现有多好的反馈，就显得有一些延迟，因为图中每一个数据点都是从 $5000$ 个样本中得到的，而不是之前的 $1000$ 个样本。

• 同样地，有时候我们运行梯度下降可能也会得到这样的图像（上图 3），如果出现这种情况，看起来我们的代价函数完全没有在减小，看起来算法没有进行学习，因为曲线整体看起来是平的，代价函数的值好像没有下降。但如果我们增加这里的数量（上式红色），来对更多的样本进行求均值，那么很可能会观察到红线所示的情况（上图 3），我们能看出，实际上代价函数是在下降的，只不过蓝线求均值的样本太少了，所以包含了太多的噪声，导致看不出函数实际上是趋向于减少的（上图 3 绿框中蓝线范围）。所以如果用 $5000$ 个样本求均值，会比用 $1000$ 个样本更好。当然，如果我们用更多的样本来求均值，可能我们会得到一条这样的学习曲线（上图 3 粉线），即使我们使用了更大数量的样本，曲线还是很平坦。如果得到这样的结果，很明显也很不幸，那就代表算法不知道出于何种原因没有进行学习，那么这时就需要调整学习速率或调整特征或者调整算法的其他东西。

• 最后，我们可能会遇到一条这样的曲线（上图 4），我们会发现曲线是这样的（上图 4 蓝线）它看起来是在上升的，这种情况就是算法发散的信号，这时要做的就是用一个更小的学习速率 $\alpha$ 。

• 通过上面的内容我们可以明白，当我们画出某个范围内样本的 $cost$ 函数均值时，各种可能出现的情况，同时也说明了，我们在遇到这些情况时应该采取怎样的措施：如果曲线的噪声太大，或者老是上下振动，我们就可以试着增加求均值样本的数量，这样就能更好地看出函数变化的趋势，如果我们发现误差在上升，或者 $cost$ 函数的值在上升，那么就用一个更小的 $\alpha$ 值。

3. 学习速率的选择

• 最后还需要说明一下关于学习速率的问题。我们已经知道，当运行随机梯度下降时，算法会从某个点开始，然后曲折地达到最小值，但它不会完全收敛，而是在最小值附近一直徘徊，因此我们最终得到的参数只是一个全局最小值的接近值，而不是真正的全局最小值。在大多数随机梯度下降法的典型应用中，学习速率 $\alpha$ 一般是一个不变的常数，因此，我们最终会得到这样的结果（参考本文第二节第 2 小节第 ③ 部分图 6）。如果我们想让随机梯度下降更好地收敛到全局最小值，我们可以做的就是让学习速率 $\alpha$ 的值随时间变化逐渐减小。所以，一种典型的方法就是设置 $\alpha$ 的值，让 $\alpha$ 等于某个常数 $1$ 除以迭代次数加某个常数 $2$ （下式）。
  L e a r n i n g    r a t e    α    i s    t y p i c a l l y    h e l d    c o n s t a n t .    C a n    s l o w l y    d e c r e a s e    α o v e r    t i m e    i f    w e    w a n t    θ    t o    c o n v e r g e .    ( E . g .    α = c o n s t 1 i t e r a t i o n N u m b e r + c o n s t 2 )
  Learning  rate  α  is  typically  held  constant.  Can  slowly  decrease  αover  time  if  we  want  θ  to  converge.  (E.g.  \blueα=const1iterationNumber+const2)" role="presentation" style="position: relative;">Learning  rate  α  is  typically  held  constant.  Can  slowly  decrease  αover  time  if  we  want  θ  to  converge.  (E.g.  \blueα=const1iterationNumber+const2)$$\begin{array}{rl}& \mathrm{L}\mathrm{e}\mathrm{a}\mathrm{r}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{r}\mathrm{a}\mathrm{t}\mathrm{e}\alpha \mathrm{i}\mathrm{s}\mathrm{t}\mathrm{y}\mathrm{p}\mathrm{i}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}\mathrm{y}\mathrm{h}\mathrm{e}\mathrm{l}\mathrm{d}\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{t}.\mathrm{C}\mathrm{a}\mathrm{n}\mathrm{s}\mathrm{l}\mathrm{o}\mathrm{w}\mathrm{l}\mathrm{y}\mathrm{d}\mathrm{e}\mathrm{c}\mathrm{r}\mathrm{e}\mathrm{a}\mathrm{s}\mathrm{e}\alpha \\ & \mathrm{o}\mathrm{v}\mathrm{e}\mathrm{r}\mathrm{t}\mathrm{i}\mathrm{m}\mathrm{e}\mathrm{i}\mathrm{f}\mathrm{w}\mathrm{e}\mathrm{w}\mathrm{a}\mathrm{n}\mathrm{t}\theta \mathrm{t}\mathrm{o}\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{v}\mathrm{e}\mathrm{r}\mathrm{g}\mathrm{e}.\left(\mathrm{E}.\mathrm{g}.\text{blue}\alpha =\frac{\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{s}\mathrm{t}1}{\mathrm{i}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{N}\mathrm{u}\mathrm{m}\mathrm{b}\mathrm{e}\mathrm{r}+\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{s}\mathrm{t}2}\right)\end{array}$$
  ​Learning  rate  α  is  typically  held  constant.  Can  slowly  decrease  αover  time  if  we  want  θ  to  converge.  (E.g.  α=iterationNumber+const2const1​)​
• 迭代次数指的是我们运行随机梯度下降的迭代次数，其实就是我们已经计算过的训练样本的数量。而常数 $1$ 和常数 $2$ 是算法的两个额外的参数，我们同样需要选择合适的值，才能得到较好的表现，但很多人不愿意用这个方法，原因是我们最后得花时间来确定这两个额外的参数（即常数 $1$ 和常数 $2$），这会让整个算法变得更复杂，也就是说我们需要调整更多的参数，来让算法运行得更好。但如果我们能很好地调整这些参数，最后得出图像，算法还是会在最小值附近振荡，但它会更加接近最小值，因为这时我们减小了学习速率，那么这个振荡也会越来越小，直到收敛到非常靠近全局最小的地方。
• 上式蓝色标注的那个公式的作用是，随着算法的运行，迭代次数会越来越大，因此学习速率 $\alpha$ 会慢慢变小，每一步就会越来越精确，直到最终收敛到全局最小值的地方。所以如果我们慢慢减小 $\alpha$ 的值一直到 $0$，最后得到一个非常好的假设，但是由于确定这两个常数需要额外的工作，并且通常情况下得到的参数值，它接近全局最小值的程度已经足够好，已经足够使我们满意了，因此，我们很少采用这种逐渐减小 $\alpha$ 的值的方法，而是让学习速率 $\alpha$ 保持一个常数。通常更多的时候，是让 $\alpha$ 为一个常数，不过两种做法都有人在用。
• 总结一下，本节我们介绍了一种方法来近似地检验随机梯度下降算法在优化代价函数中的表现。这种方法并不需要定期地扫描整个训练集来计算出整个训练集的代价函数，而是只关注像前 $1000$ 个的这些样本，我们可以用这个方法来确保随机梯度下降法运行正确并且在收敛，或者用它来调整学习速率 $\alpha$ 。

五、在线学习（Online learning）

• 本节我们将会讨论一种新的大规模的机器学习机制，叫做在线学习机制（Online learning setting）。在线学习机制可以模型化一些问题，就是我们有连续一波数据或者连续的数据流，想要用算法从中学习的这类问题。今天许多大型网站或者许多大型网络公司使用不同版本的在线学习机制算法，从大批涌入网站的用户身上进行学习，特别是，如果我们有一个由不断进入网站的用户流所产生的连续的数据流，我们就可以使用在线学习机制，从数据流中学习用户的偏好，然后使用这些信息来优化关于网站的决策。

1. 实例一：运输服务应用 - 价格优化（Application in shipping service - Price optimization）

S h i p p i n g    s e r v i c e    w e b s i t e    w h e r e    u s e r    c o m e s ,    s p e c i f i e s    o r i g i n    a n d d e s t i n a t i o n ,    y o u    o f f e r    t o    s h i p    t h e i r    p a c k a g e    f o r    s o m e    a s k i n g    p r i c e , a n d    u s e r s    s o m e t i m e s    c h o o s e    t o    u s e    y o u r    s h i p p i n g    s e r v i c e    ( y = 1 ) , s o m e t i m e s    n o t    ( y = 0 ) .

​Shipping  service  website  where  user  comes,  specifies  origin  anddestination,  you  offer  to  ship  their  package  for  some  asking  price,and  users  sometimes  choose  to  use  your  shipping  service  (y=1),sometimes  not  (y=0).​

• 假设我们提供运输服务，用户们来向我们询问把包裹从 $A$ 地运到 $B$ 地的服务，同时假定我们有一个网站，用户们登陆网站告诉我们他们想从哪里寄出包裹，以及寄到哪里去（也就是出发地与目的地），然后我们的网站开出运输包裹的服务价格，然后根据我们开给用户的这个价格，用户有时会接受这个运输服务，那么这就是个正样本，有时他们会走掉，不购买我们的运输服务。
• 我们假定我们想要一个学习算法来帮助我们优化我们想给用户开出的价格。具体来说，假设我们获取了描述用户特点的特征，例如用户的人口统计学数据，用户邮寄包裹的起始地以及目的地，以及我们提供给他们的运送包裹的价格。
  F e a t u r e s    x    c a p t u r e    p r o p e r t i e s    o f    u s e r ,    o f    o r i g i n / d e s t i n a t i o n    a n d a s k i n g    p r i c e .    W e    w a n t    t o    l e a r n    p ( y = 1 ∣ x ; θ )    t o    o p t i m i z e    p r i c e .
  Features  x  capture  properties  of  user,  of  origin/destination  andasking  price.  We  want  to  learn  p(y=1|\bluex;θ)  to  optimize  price." role="presentation" style="position: relative;">Features  x  capture  properties  of  user,  of  origin/destination  andasking  price.  We  want  to  learn  p(y=1|\bluex;θ)  to  optimize  price.$$\begin{array}{rl}& \mathrm{F}\mathrm{e}\mathrm{a}\mathrm{t}\mathrm{u}\mathrm{r}\mathrm{e}\mathrm{s}x\mathrm{c}\mathrm{a}\mathrm{p}\mathrm{t}\mathrm{u}\mathrm{r}\mathrm{e}\mathrm{p}\mathrm{r}\mathrm{o}\mathrm{p}\mathrm{e}\mathrm{r}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}\mathrm{o}\mathrm{f}\mathrm{u}\mathrm{s}\mathrm{e}\mathrm{r},\mathrm{o}\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{g}\mathrm{i}\mathrm{n}/\mathrm{d}\mathrm{e}\mathrm{s}\mathrm{t}\mathrm{i}\mathrm{n}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{a}\mathrm{n}\mathrm{d}\\ & \mathrm{a}\mathrm{s}\mathrm{k}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}.\mathrm{W}\mathrm{e}\mathrm{w}\mathrm{a}\mathrm{n}\mathrm{t}\mathrm{t}\mathrm{o}\mathrm{l}\mathrm{e}\mathrm{a}\mathrm{r}\mathrm{n}p(y=1|\text{blue}x;\theta )\mathrm{t}\mathrm{o}\mathrm{o}\mathrm{p}\mathrm{t}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e}\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}.\end{array}$$
  ​Features  x  capture  properties  of  user,  of  origin/destination  andasking  price.  We  want  to  learn  p(y=1∣x;θ)  to  optimize  price.​
• 我们想要做的就是用这些特征学习，他们将会选择我们的服务来运输包裹的几率，并且再次指出，这些特征中包含了开出的价格（蓝色标注），所以如果我们可以估计出在每种价格下用户选择使用我们的服务的概率，那么我们就可以选择一个价格，使得用户有很大的可能性选择我们的网站，而且同时能保证一个合适的回报，保证我们能获得合适的利润。所以，如果我们可以学习在任何给定价格和其它特征下 $y=1$ 的概率，我们就可以利用这一信息在新用户来的时候选择合适的价格，所以为了获得 $y=1$ 的概率的模型，我们能做的就是用 $logistic$ 回归或者神经网络，或者其它一些类似的算法，但现在我们先来考虑 $logistic$ 回归，现在假定我们有一个连续运行的网站，以下就是在线学习算法所做的：
  R e p e a t    f e a t u r e    { G e t    ( x , y )    c o r r e s p o n d i n g    t o    u s e r . U p d a t e    θ    u s i n g    ( x , y ) : t h e t a j : = θ j − α ( h θ ( x ) − y ) x j ( j = 0 , . . .   , n ) }   C a n    a d a p t    t o    c h a n g l y    u s e r    p r e f e r e n c e .
  Repeat  feature  {Get  \red(x,y)  corresponding  to  user.Update  θ  using  \orange(x,y):\pinkthetaj:=θj−α(hθ(x)−y)xj(j=0,... ,n)} Can  adapt  to  changly  user  preference." role="presentation" style="position: relative;"> Repeat  feature  {Get  \red(x,y)  corresponding  to  user.Update  θ  using  \orange(x,y):\pinkthetaj:=θj−α(hθ(x)−y)xj(j=0,... ,n)}Can  adapt  to  changly  user  preference.$$\begin{array}{rl}& Repeatfeature\{\\ & Get\text{red}(x,y)correspondingtouser.\\ & Update\theta using\text{orange}(x,y):\\ & \text{pink}thet{a}_j:={\theta }_j-\alpha (h_{\theta }(x)-y)x_j(j=0,...,n)\\ & \}\\ \\ & \mathrm{C}\mathrm{a}\mathrm{n}\mathrm{a}\mathrm{d}\mathrm{a}\mathrm{p}\mathrm{t}\mathrm{t}\mathrm{o}\mathrm{c}\mathrm{h}\mathrm{a}\mathrm{n}\mathrm{g}\mathrm{l}\mathrm{y}\mathrm{u}\mathrm{s}\mathrm{e}\mathrm{r}\mathrm{p}\mathrm{r}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{r}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{e}.\end{array}$$
   ​Repeat  feature  {Get  (x,y)  corresponding  to  user.Update  θ  using  (x,y):thetaj​:=θj​−α(hθ​(x)−y)xj​(j=0,... ,n)}Can  adapt  to  changly  user  preference.​
• 首先一直重复（代表我们的网站将会一直在线），在某个时候，一个用户访问了这个网站，然后我们将会得到与其相对应的一个 $(x,y)$ 对，它对应一个客户，或者是网站用户，所以特征 $x$ 包括客户所指定的起始地与目的地，以及我们这一次提供给客户的价格，而 $y$ 则取 $1$ 或 $0$，$y$ 值取决于客户是否选择了使用我们的运输服务。现在我们获得了这个 $(x,y)$ 数据对，在线学习算法就会更新参数 $\theta$，利用得到的 $(x,y)$ 数据对来更新 $\theta$，具体来说，我们将这样更新参数 $\theta$（上式粉色标注） ，我们常用的逻辑回归的梯度下降规则。对于其他的学习算法，不是写 $(x,y)$ 对（红色标注），我们之前写的是 $(x^{(i)},y^{(i)})$，但在这个在线学习机制中，我们实际上丢弃了固定的数据集这一概念，取而代之的是一个算法，现在我们获取一个样本（红色标注），然后利用那个样本以这种方式学习（橙色标注），然后丢弃这个样本，不会再使用它。这就是为什么一次只处理一个样本，从样本中学习，再丢弃它，这也就是为什么我们放弃了这种用 $i$ 索引的固定数据集的表示方法。
• 如果我们真的运行一个大型网站，网站有连续的用户流，那么这种在线学习算法就非常适用，因为我们相当于可以免费获取数据，如果我们有如此多的数据，可以获取的数据可以说是无限的，那么或许就真的没必要多次使用一个样本。
• 当然，如果我们只有少量的用户，那么就最好不要用这种在线学习算法，而是把所有的数据保存在一个固定的数据集里，然后对这个数据集使用某种算法，但是如果我们有连续的数据流，那么在线学习算法会非常有效。我也必须要提到，这种在线学习算法会带来一个有趣的效果，就是它可以适应变化的用户偏好。举个具体的例子，如果随着时间变化，经济环境发生变化，用户们可能会对价格更敏感，不那么愿意支付高的费用，也有可能变得对价格不那么敏感，然后愿意支付更高的价格。又或者其它因素，变得对用户的影响更大了，如果一类新的用户开始涌入我们的网站，这种在线学习算法也可以根据变化着的用户偏好进行调适，它可以跟进变化着的用户群体所愿意支付的价格，能做到这一点是因为如果用户群变化了，那么参数 $\theta$ 的变化与更新会逐渐调适到最新的用户群所体现出来的特点。

2. 实例二：CRT 预测 - 点击率预测学习问题（Learning the predicted click-through rate）

• 这里有另一个你可能想要使用在线学习的例子，这是一个产品搜索的应用（Application in product search），我们想要使用一种学习算法来学习如何反馈给用户好的搜索列表。
  P r o d u c t    s e a r c h    ( l e a r n i n g    t o    s e a r c h ) U s e r    s e a r c h e s    f o r   “ A n d r o i d    p h o n e    1080 p    c a m e r a " H a v e    100    p h o n e s    i n    s t o r e .    W i l l    r e t u r n    10    r e s u l t s . x = f e a t u r e s    o f    p h o n e ,    h o w    m a n y    w o r d s    i n    u s e r    q u e r y    m a t c h n a m e    o f    p h o n e ,    h o w    m a n y    w o r d s    i n    q u e r y    m a t c h    d e s c r i p t i o n o f    p h o n e ,    e t c . y = 1    i f    u s e r    c l i c k s    o n    l i n k .    y = 0    o t h e r w i s e . L e a r n    p ( y = 1 ∣ x ; θ ) U s e    t o    s h o w    u s e r    t h e    10    p h o n e s    t h e y ’ r e    m o s t    l i k e l y    t o    c l i c k    o n .
  Product  search  (learning  to  search)User  searches  for  “Android  phone  1080p  camera"Have  100  phones  in  store.  Will  return  10  results.x=features  of  phone,  how  many  words  in  user  query  matchname  of  phone,  how  many  words  in  query  match  descriptionof  phone,  etc.y=1  if  user  clicks  on  link.  y=0  otherwise.Learn  p(y=1|x;θ)Use  to  show  user  the  10  phones  they′re  most  likely  to  click  on." role="presentation" style="position: relative;">Product  search  (learning  to  search)User  searches  for  “Android  phone  1080p  camera"Have  100  phones  in  store.  Will  return  10  results.x=features  of  phone,  how  many  words  in  user  query  matchname  of  phone,  how  many  words  in  query  match  descriptionof  phone,  etc.y=1  if  user  clicks  on  link.  y=0  otherwise.Learn  p(y=1|x;θ)Use  to  show  user  the  10  phones  they′re  most  likely  to  click  on.$$\begin{array}{rl}& Productsearch(learningtosearch)\\ & Usersearchesfor“Androidphone1080pcamera"\\ & Have100phonesinstore.Willreturn10results.\\ & x=featuresofphone,howmanywordsinuserquerymatch\\ & nameofphone,howmanywordsinquerymatchdescription\\ & ofphone,etc.\\ & y=1ifuserclicksonlink.y=0otherwise.\\ & Learnp(y=1|x;\theta )\\ & Usetoshowuserthe10phonesthe{y}^{\prime }remostlikelytoclickon.\end{array}$$
  ​Product  search  (learning  to  search)User  searches  for  “Android  phone  1080p  camera"Have  100  phones  in  store.  Will  return  10  results.x=features  of  phone,  how  many  words  in  user  query  matchname  of  phone,  how  many  words  in  query  match  descriptionof  phone,  etc.y=1  if  user  clicks  on  link.  y=0  otherwise.Learn  p(y=1∣x;θ)Use  to  show  user  the  10  phones  they’re  most  likely  to  click  on.​
• 举个例子，我们有一个在线卖电话的商铺，一个卖手机的商铺，我们有一个用户界面，可以让用户登陆网站，键入一个搜索条目，例如，安卓手机 $1080p$ 摄像头。假定商铺中有 $100$ 种手机，而且由于我们的网站设计，当一个用户键入一个命令，如果这是一个搜索命令，我们就会找出合适的 $10$ 部手机，供用户选择。
• 我们希望有一个学习算法来帮助找到在这 $100$ 部手机中哪 $10$ 部手机是应该反馈给用户的，是对用户搜索的最佳回应，接下来是一种解决问题的思路，对于每一个手机，以及一个给定的用户搜索命令，我们可以构建一个特征向量 $x$，这个特征向量 $x$ 可能会表示手机的各种特点，它可能会体现用户的搜索与这部手机的类似程度有多高，还可能体现这个用户搜索命令中有多少个词可以与这部手机的名字相匹配，或者这个搜索命令中有多少词与这部手机的描述相匹配等等，所以特征向量 $x$ 体现手机的特点，还体现这部手机与搜索命令在各个维度的匹配程度。
• 我们想要做的就是，估测用户点击某一个手机的链接的概率，因为想要给用户展示他们可能想要买的手机，我们想要给用户提供那些他们很可能在浏览器中点进去查看的手机，所以我们将 $y=1$ 定义为用户点击了手机的链接，而 $y=0$ 是指用户没有点击链接，然后我们想要做的就是根据特征 $x$，即手机的特征以及搜索指令的匹配程度，来预测用户点击特定链接的概率。如果要给这个问题命名，用一种运行这类网站的人所使用的语言来命名，这类学习问题其实被称作点击率预测学习问题（learning the predicted click-through rate），即 $CTR$ 预测，意思是学习用户点击某一个我们提供给他们的链接的概率，$CTR$ 是点击率的缩写，如果我们能够估计任意一个手机的点击率，我们可以利用这个来给用户展示 $10$ 个他们最有可能点击的手机，因为从这 $100$ 个手机中，我们可以计算出每一步手机的概率，然后选择 $10$ 部用户最有可能点击的手机，这就是一个非常合理的决定展示给用户的 $10$ 个搜索结果的方法。
• 更明确地说，假定每次用户进行一次搜索，我们回馈给用户 $10$ 个结果，这样一来，我们就会得到 $10$ 个 $(x,y)$ 数据对。实际上每当一个用户访问我们的网站，我们就得到 $10$ 个数据样本，因为对于这 $10$ 部我们选择要展示给用户的手机，我们从每一部得到一个特征矢量 $x$，对于这 $10$ 部手机中的每一个，我们还会得到对应的 $y$ 的取值，我们会观察 $y$ 的取值，这些取值是根据用户有没有点击那个链接来决定的。
• 因此运行此类网站的一种方法就是不停地给用户展示你对他们可能会喜欢的 $10$ 个手机的预测，那么，每次一个用户访问，我们将会得到 $10$ 个样本，即 $10$ 个 $(x,y)$ 数据对，然后利用一个在线学习算法来更新我们的参数，对这 $10$ 个样本利用 $10$ 步梯度下降法来更新参数，然后，我们可以丢弃掉这些数据，如果我们真的拥有一个连续的用户流进入网站，这就是一个非常合理的方法来学习我们的算法中的参数，来给用户展示 $10$ 部他们最有可能点击查看的手机。所以，这是一个产品搜索问题，或者说是一个学习将手机排序，学习搜索手机的样例。

3. 其他例子

O t h e r    e x a m p l e s :    C h o o s i n g    s p e c i a l    o f f e r s    t o    s h o w    u s e r ;    c u s t o m i z e d s e l e c t i o n    o f    n e w s    a r t i c l e s ;    p r o d u c t    r e c o m m e n d a t i o n ;    …

​Other  examples:  Choosing  special  offers  to  show  user;  customizedselection  of  news  articles;  product  recommendation;  …​

• 我们还有一些其他的例子，其中一个例子是，如果我们有一个网站，我们想要决定给用户展示什么样的特别优惠，这与手机那个例子非常类似；或者我们有一个网站，我们给不同的用户展示不同的新闻文章，如果我们是一个新闻抓取网站，那么我们同样可以使用一个一个类似的系统来选择，来展示给用户他们最优可能感兴趣的新闻文章，以及那些他们最有可能点击的新闻文章；与特别优惠类似的还有商品推荐。而且实际上，如果我们有一个协作过滤系统（Collaborative filtering system），它可以给你更多的特征输入到逻辑回归分类器以此预测可能推荐给用户的不同产品的点击率。

• 当然我们需要说明的是，这些问题中的任何一个都可以被转变为标准的、拥有一个固定的样本集的机器学习问题，或许我们可以让网站先运行几天，然后保存一个数据集，一个固定的数据集，然后对其运行一个学习算法，但是这些问题在实际中，我们会看到大公司会获取如此多的数据，所以真的没有必要来保存一个固定的数据集，你可以使用一个在线学习算法来连续的学习，从这些用户不断产生的数据中来学习。

• 这就是在线学习机制，与随机梯度下降算法非常类似，唯一的区别是，我们不会使用一个固定的数据集，而是获取一个用户样本，从那个样本中学习，然后丢弃那个样本，继续处理下一个，而且如果我们的某一种应用有一个连续的数据流，这样的算法可能会非常值得考虑。当然，在线学习的一个优点就是，如果我们有一个变化的用户群，又或者我们在尝试预测的事情在缓慢变化，例如用户的品味在缓慢变化，在线学习算法可以慢慢地调试我们所学习到的假设，将其调节更新到最新的用户行为。

六、映射归约与数据并行（Map-reduce and data parallelism）

• 在前几节中我们讨论了随机梯度下降以及随机梯度下降算法的几个变种，例如在线学习。这些算法可以在单个机器或者单个电脑上运行，但是很多机器学习问题过于庞大以至于不能单机运行，有时候可能数据太多了，我们不想把所有数据都在电脑上跑一遍，无论我们在这台电脑上用了什么算法。所以本节我们将介绍一个不同方法，可以应用在大规模机器学习上，这个方法叫做 $\mathrm{MapReduce}$。虽然我们用了好几节来讲解随机梯度下降，在讲解 $\mathrm{MapReduce}$ 方法上用的时间相对较少，但这并不代表 $\mathrm{MapReduce}$ 比随机梯度下降不重要，花的时间少不表示不重要。有些人说 $\mathrm{MapReduce}$ 至少和随机梯度下降一样重要，还有人认为 $\mathrm{MapReduce}$ 是一种比随机梯度下降更重要的思想，只是因为它更容易解释，所以我们才会在这上面花费更少的时间。不过有了这个概念，我们就可以将学习算法应用于随机梯度下降不能解决的规模更大的问题。

1. 采用 MapReduce 的批量梯度下降模型

• 比如我们想要拟合一个线性回归模型，或者逻辑回归模型亦或其它的，我们先从批量梯度下降开始，这是批量梯度下降的学习规则（下式行一）：
  Map-reduce B a t c h    g r a d i e n t    d e s c e n t : θ j : = θ j − α 1 400 ∑ i = 1 400 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) M a c h i n e   1 : U s e    ( x ( 1 ) , y ( 1 ) ) , . . .   , ( x ( 100 ) , y ( 100 ) ) t e m p j ( 1 ) = ∑ i = 1 100 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) M a c h i n e   2 : U s e    ( x ( 101 ) , y ( 101 ) ) , . . .   , ( x ( 200 ) , y ( 200 ) ) t e m p j ( 2 ) = ∑ i = 101 200 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) M a c h i n e   3 : U s e    ( x ( 201 ) , y ( 201 ) ) , . . .   , ( x ( 300 ) , y ( 300 ) ) t e m p j ( 3 ) = ∑ i = 201 300 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) M a c h i n e   4 : U s e    ( x ( 301 ) , y ( 301 ) ) , . . .   , ( x ( 400 ) , y ( 400 ) ) t e m p j ( 4 ) = ∑ i = 301 400 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) C o m b i n e : θ j : = θ j − α 1 400 ∑ i = 1 400 ( t e m p j ( 1 ) + t e m p j ( 2 ) + t e m p j ( 3 ) + t e m p j ( 4 ) ) ( j = 0 , . . .   , n )
  Map-reduceBatch  gradient  descent:θj:=θj−α1400\blue∑i=1400(hθ(x(i))−y(i))xj(i)Machine 1:Use  (x(1),y(1)),... ,(x(100),y(100))tempj(1)=∑i=1100(hθ(x(i))−y(i))xj(i)Machine 2:Use  (x(101),y(101)),... ,(x(200),y(200))tempj(2)=∑i=\red101\red200(hθ(x(i))−y(i))xj(i)Machine 3:Use  (x(201),y(201)),... ,(x(300),y(300))tempj(3)=∑i=201300(hθ(x(i))−y(i))xj(i)Machine 4:Use  (x(301),y(301)),... ,(x(400),y(400))tempj(4)=∑i=301400(hθ(x(i))−y(i))xj(i)Combine:\greenθj:=θj−α1400∑i=1400(tempj(1)+tempj(2)+tempj(3)+tempj(4))(j=0,... ,n)" role="presentation" style="position: relative;">Map-reduceBatch  gradient  descent:θj:=θj−α1400\blue∑i=1400(hθ(x(i))−y(i))x(i)jMachine 1:Use  (x(1),y(1)),... ,(x(100),y(100))temp(1)j=∑i=1100(hθ(x(i))−y(i))x(i)jMachine 2:Use  (x(101),y(101)),... ,(x(200),y(200))temp(2)j=∑i=\red101\red200(hθ(x(i))−y(i))x(i)jMachine 3:Use  (x(201),y(201)),... ,(x(300),y(300))temp(3)j=∑i=201300(hθ(x(i))−y(i))x(i)jMachine 4:Use  (x(301),y(301)),... ,(x(400),y(400))temp(4)j=∑i=301400(hθ(x(i))−y(i))x(i)jCombine:\greenθj:=θj−α1400∑i=1400(temp(1)j+temp(2)j+temp(3)j+temp(4)j)(j=0,... ,n)$$\begin{array}{rl}& \mathbf{\text{Map-reduce}}\\ & \mathrm{B}\mathrm{a}\mathrm{t}\mathrm{c}\mathrm{h}\mathrm{g}\mathrm{r}\mathrm{a}\mathrm{d}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{d}\mathrm{e}\mathrm{s}\mathrm{c}\mathrm{e}\mathrm{n}\mathrm{t}:{\theta }_j:={\theta }_j-\alpha \frac{1}{400}\text{blue}\sum _{i=1}^{400}(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & \mathrm{M}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{n}\mathrm{e}1:\mathrm{U}\mathrm{s}\mathrm{e}(x^{(1)},y^{(1)}),...,(x^{(100)},y^{(100)})\\ & tem{p}_j^{(1)}=\sum _{i=1}^{100}(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & \mathrm{M}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{n}\mathrm{e}2:\mathrm{U}\mathrm{s}\mathrm{e}(x^{(101)},y^{(101)}),...,(x^{(200)},y^{(200)})\\ & tem{p}_j^{(2)}=\sum _{i=\text{red}101}^{\text{red}200}(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & \mathrm{M}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{n}\mathrm{e}3:\mathrm{U}\mathrm{s}\mathrm{e}(x^{(201)},y^{(201)}),...,(x^{(300)},y^{(300)})\\ & tem{p}_j^{(3)}=\sum _{i=201}^{300}(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & \mathrm{M}\mathrm{a}\mathrm{c}\mathrm{h}\mathrm{i}\mathrm{n}\mathrm{e}4:\mathrm{U}\mathrm{s}\mathrm{e}(x^{(301)},y^{(301)}),...,(x^{(400)},y^{(400)})\\ & tem{p}_j^{(4)}=\sum _{i=301}^{400}(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\\ & \mathrm{C}\mathrm{o}\mathrm{m}\mathrm{b}\mathrm{i}\mathrm{n}\mathrm{e}:\\ & \text{green}{\theta }_j:={\theta }_j-\alpha \frac{1}{400}\sum _{i=1}^{400}(tem{p}_j^{(1)}+tem{p}_j^{(2)}+tem{p}_j^{(3)}+tem{p}_j^{(4)})\\ & (j=0,...,n)\end{array}$$
  ​Map-reduceBatch  gradient  descent:θj​:=θj​−α4001​i=1∑400​(hθ​(x(i))−y(i))xj(i)​Machine 1:Use  (x(1),y(1)),... ,(x(100),y(100))tempj(1)​=i=1∑100​(hθ​(x(i))−y(i))xj(i)​Machine 2:Use  (x(101),y(101)),... ,(x(200),y(200))tempj(2)​=i=101∑200​(hθ​(x(i))−y(i))xj(i)​Machine 3:Use  (x(201),y(201)),... ,(x(300),y(300))tempj(3)​=i=201∑300​(hθ​(x(i))−y(i))xj(i)​Machine 4:Use  (x(301),y(301)),... ,(x(400),y(400))tempj(4)​=i=301∑400​(hθ​(x(i))−y(i))xj(i)​Combine:θj​:=θj​−α4001​i=1∑400​(tempj(1)​+tempj(2)​+tempj(3)​+tempj(4)​)(j=0,... ,n)​
• 为了书写方便，我们在这里假定样本数量 $m$ 等于 $400$，当然根据我们的标准，对于大规模学习问题，这个 $m$ 确实是有点小，我们更有可能会把这个算法应用在一个规模巨大的问题上，比如说有 $4$ 亿样本或者更大，但是为了书写上的方便就先假装我们只有 $400$ 个样本，在这种情况下，批量梯度下降的学习规则中就有 $\frac{1}{400}$ ，求和也是从 $i=1$ 到 $400$ ，即有 $400$ 个样本，如果 $m$ 非常大，那么这一步的计算量将会非常大，下面讲解 $\mathrm{MapReduce}$ 的原理。
• 假定我们有训练集，即 $(x,y)$ 数据对，它从 $(x^{(1)},y^{(1)})$ 开始，一直到 $400$ 即 $(x^{(m)},y^{(m)})$，于是我们的训练集有 $400$ 个样本，根据 $\mathrm{MapReduce}$ 思想，我们把训练集分割成不同的子集，这个例子中，我们假定有 $4$ 台电脑，或者 $4$ 台机器并行处理训练集数据，因此我们把数据分成 $4$ 份，如果我们有 $10$ 台或者 $100$ 台机器，我们可以把训练集分成 $10$ 份或 $100$ 份。$4$ 台机器中的第一台要做的就是用前 $\frac{1}{4}$ 的训练集，也就是前 $100$ 个训练样本。具体来说，就是对前 $100$ 个训练样本，计算这个求和式子（蓝色标注），也就是计算 $tem{p}_j^{(1)}$，这个上标 $1$ 表示第一台机器，它等于 $i=1$ 到 $100$ 求和，然后再把上面的求和项放进去，得到对应的表达式，这就是梯度下降。相同的，把第二部分的数据发给第二个机器，会使用样本 $101$ 到 $200$，计算 $tem{p}_j^{(1)}$ 是一样的求和，只是样本从 $101$ 到 $200$（红色标注）。相似的，对于第三第四个机器会使用第三第四部分的训练集。现在每个机器要对 $100$ 个样本，而不是 $400$ 个样本求和，都只需要做 $\frac{1}{4}$ 的工作，这使得它们将运算速度提高到原来的四倍。
• 最后，完成这些计算后，我们将这些 $temp$ 变量重新放在一起，就是把这些变量发送给一个中心服务器，中心服务器会整合这些结果，尤其是它将更新参数 ${\theta }_j$ ，更新后的 ${\theta }_j$ 等于原先的 ${\theta }_j$ 减去学习率 $\alpha$ 乘以 $\frac{1}{400}$ 乘以 $tem{p}_j^{(1)}$ 加到 $tem{p}_j^{(4)}$，当然 $j=0$ 至 $n$ 要分别计算，$n$ 是特征总数，这个等式（绿色标注），它做的事情和中心服务器相同，就是把所有的 $temp$ 结果相加，就等于最上面的求和（蓝色标注），即我们最初计算的批量梯度下降，然后其余部分也是相同的，因此这个公式完全等同于批量梯度下降算法，只是不需要在一台机器上对 $400$ 个训练样本进行计算了，而是可以把工作分给四个机器。

2. 形象化 MapReduce

• 这就是 $\mathrm{MapReduce}$ 技巧的示意图（上图），我们有训练集，如果我们想要在四台机器上进行并行计算，我们可以把训练集均分，或者尽量均匀地分成四个子集，然后我们将这些训练数据的子集发送给四个不同的电脑，每一台电脑都可以只计算 $\frac{1}{4}$ 训练集的总和，最终每个电脑把结果发送给一个中心服务器，把结果汇总，正如上一小节那样，梯度下降的主要工作是从 $i=1$ 到 $400$ 求和，更概括的表示是，从 $i=1$ 到 $m$ 对梯度下降公式求和。现在因为四台机器各自承担 $\frac{1}{4}$ 的计算量，我们可以加速到四倍速，特别是，如果没有网络延迟，也不考虑通过网络来回传输数据所用的时间，那么我们就可以有 $4$ 倍的计算效率。当然实际上因为网络延迟、结果汇总也需要额外的时间，以及其它因素，实际上速度会比 $4$ 倍要小。尽管这样， $\mathrm{MapReduce}$ 也提供了一种方式来处理一台电脑无法处理的大规模数据。

3. 在多台电脑上使用 MapReduce

• 如果我们想把 $\mathrm{MapReduce}$ 应用在某种学习算法上，通过多台电脑并行计算来实现加速，我们需要思考一个关键问题，我们的学习算法是否可以表示成对训练集的一种求和，实际上很多学习算法都可以表示成对训练集的函数求和，而在大数据集上运行所消耗的计算量就在于需要对非常大的训练集进行求和，所以只要我们的学习算法可以表示为对训练集的求和，或者学习算法的主要工作可以表示成对训练集的求和，那么就可以用 $MapReduce$ 将学习算法的适用范围扩大到非常大的数据集。
  M a n y    l e a r n i n g    a l g o r i t h m s    c a n    b e    e x p r e s s e d    a s    c o m p u t i n g    s u m s    o f    f u n c t i o n s    o v e r    t h e    t r a i n i n g    s e t .
  Many  learning  algorithms  can  be  expressed  as  computing  sums  of  functions  over  the  training  set." role="presentation" style="position: relative;">Many  learning  algorithms  can  be  expressed  as  computing  sums  of  functions  over  the  training  set.$$\begin{array}{rl}& \mathrm{M}\mathrm{a}\mathrm{n}\mathrm{y}\mathrm{l}\mathrm{e}\mathrm{a}\mathrm{r}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{a}\mathrm{l}\mathrm{g}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{h}\mathrm{m}\mathrm{s}\mathrm{c}\mathrm{a}\mathrm{n}\mathrm{b}\mathrm{e}\mathrm{e}\mathrm{x}\mathrm{p}\mathrm{r}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{e}\mathrm{d}\mathrm{a}\mathrm{s}\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{u}\mathrm{t}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{s}\mathrm{u}\mathrm{m}\mathrm{s}\\ & \mathrm{o}\mathrm{f}\mathrm{f}\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{s}\mathrm{o}\mathrm{v}\mathrm{e}\mathrm{r}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{t}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{s}\mathrm{e}\mathrm{t}.\end{array}$$
  ​Many  learning  algorithms  can  be  expressed  as  computing  sums  of  functions  over  the  training  set.​
• 让我们再看最后一个例子：
  E . g .    f o r    a d v a n c e d    o p t i m i z a t i o n ,    w i t h    l o g i s t i c    r e g r e s s i o n ,    n e e d : J t r a i n ( θ ) = − 1 m ∑ i = 1 m y ( i ) l o g h θ ( x ( i ) ) − ( 1 − y ( i ) ) l o g ( 1 − h θ ( x ( i ) ) ) ∂ ∂ θ j J t r a i n ( θ ) = 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i )
  E.g.  for  advanced  optimization,  with  logistic  regression,  need:Jtrain(θ)=−1m∑i=1my(i)loghθ(x(i))−(1−y(i))log(1−hθ(x(i)))∂∂θjJtrain(θ)=1m∑i=1m(hθ(x(i))−y(i))xj(i)" role="presentation" style="position: relative;">E.g.  for  advanced  optimization,  with  logistic  regression,  need:Jtrain(θ)=−1m∑i=1my(i)loghθ(x(i))−(1−y(i))log(1−hθ(x(i)))∂∂θjJtrain(θ)=1m∑i=1m(hθ(x(i))−y(i))x(i)j$$\begin{array}{rl}& \mathrm{E}.\mathrm{g}.\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{d}\mathrm{v}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{d}\mathrm{o}\mathrm{p}\mathrm{t}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n},\mathrm{w}\mathrm{i}\mathrm{t}\mathrm{h}\mathrm{l}\mathrm{o}\mathrm{g}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{i}\mathrm{c}\mathrm{r}\mathrm{e}\mathrm{g}\mathrm{r}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n},\mathrm{n}\mathrm{e}\mathrm{e}\mathrm{d}:\\ & J_{train}(\theta )=-\frac{1}{m}\sum _{i=1}^m{y}^{(i)}\mathrm{l}\mathrm{o}\mathrm{g}{h}_{\theta }(x^{(i)})-(1-y^{(i)})\mathrm{l}\mathrm{o}\mathrm{g}(1-h_{\theta }(x^{(i)}))\\ & \frac{\mathrm{\partial }}{\mathrm{\partial }{\theta }_j}{J}_{train}(\theta )=\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\end{array}$$
  ​E.g.  for  advanced  optimization,  with  logistic  regression,  need:Jtrain​(θ)=−m1​i=1∑m​y(i)loghθ​(x(i))−(1−y(i))log(1−hθ​(x(i)))∂θj​∂​Jtrain​(θ)=m1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​​
• 假设我们想要用一个高级的优化算法，比如 $\mathrm{L}\text{–}\mathrm{BFGS}$ 或者共轭梯度算法等等。假定我们要训练一个逻辑回归学习算法，我们需要去计算两个重要的量，一个是对于高级学习算法（比如 $\mathrm{L}\text{–}\mathrm{BFGS}$ 和共轭梯度），我们需要提供一个过程来计算优化目标的代价函数。对于逻辑回归，你应该还记得它的代价函数（上面一式），包括对训练集的求和，因此如果我们想要并行 $10$ 个机器，我们就要把训练集分给 $10$ 个机器，让它们各自对 $\frac{1}{10}$ 的训练样本计算这个量的总和。
• 另外，高级优化算法还需要这些偏导项的计算过程（上面二式）。同样的，逻辑回归的偏导项可以被表示成对训练集的求和，那么与前面的同理，我们让每一个机器对训练集的一小部分进行求和。最终，计算得到这些后，电脑把它们发送给中心服务器，然后将各部分和加起来，也就是对 $tem{p}^{(i)}$ 或者说 $tem{p}_j^{(i)}$ 进行求和，这些值是第 $i$ 台计算机算出来的。中心服务器会把这些值相加，获得总的代价函数，获得总的偏导项，接着将这两个值交给高级优化算法。推广一下，只要学习算法可以表示成一系列的求和形式，或者表示成在训练集上对函数的求和形式，我们就可以使用 $\mathrm{MapReduce}$ 技巧来并行化学习算法，使得其可以应用于非常大的数据集。

4. 在多核电脑上使用 MapReduce

• 最后再提一点，目前只讨论了运用 $\mathrm{MapReduce}$ 算法在多台电脑上并行计算，可能是计算机集群中的多台电脑，或者是数据中心的多台电脑，但是有时也可以在单机上进行 $\mathrm{MapReduce}$ 计算，因为现在很多电脑可以有多个处理核心（processing cores） 有多个 $\mathrm{CPU}$ ， $\mathrm{CPU}$ 又有多个核心。
  

• 如果我们有一个很大的数据集，然后比如我们有一个四核的电脑（就是四个计算核心），那么即使在单机上，我们也可以把训练集分成多份，然后把训练集发送给多个核心，在一台机器中完成，只用一个台式机或者一个服务器，用 $\mathrm{MapReduce}$ 方法分摊工作，然后每个核心计算 $\frac{1}{4}$ 训练样本的总和，再把每一部分之和加起来，最终得到整个训练集之和。把 $\mathrm{MapReduce}$ 看成是一台机器中不同核心的并行，而不是多台机器并行，这样的好处是我们可以不用担心网络延迟问题了。因为通信传输收发变量 $tem{p}_j$ 都在同一台机器里，网络延迟是很小的，相比较于我们在数据中心的不同机器上进行并行计算。

• 最后关于多核机器并行计算还需要提到一点，取决于不同的实现，如果我们有一个多核机器，然后我们有某些线性代数的库，实际上，有些线性代数库可以自动在一台机器的不同核心上进行并行代数运算，如果我们幸运地用到这样的线性代数库（当然并不是每一个库都适用），并且如果我们的学习算法有非常好的向量化表示，我们就可以直接以向量化的形式应用标准学习算法，不用担心并行，因为我们的线性代数库会帮我们处理好，所以我们可以不应用 $\mathrm{MapReduce}$ 。但是对于其它学习问题，利用 $\mathrm{MapReduce}$ 的实现，或者使用 $\mathrm{MapReduce}$ 的形式用不同核心并行计算，可能是个好办法，可以加速我们的学习算法。

• 本节中我们介绍了 $\mathrm{MapReduce}$ 方法来并行化计算机器学习问题，例如通过将数据发送到数据中心的多台电脑，这种方法也适用于同一台计算机上的多核并行计算，现在也有很好的开源的 $\mathrm{MapReduce}$ 实现，有个开源的系统叫做 $\mathrm{Hadoop}$，不管是用我们自己的实现或者用其他人的开源实现，我们都可以并行化学习算法，并让它运行在比单机可以承载的更大的数据集上

---

总结

• 本篇文章主要介绍了大规模的机器学习，我们喜欢找出合理的计算方法或高效的计算方法，用来处理庞大的数据集，同时也了解了两个主要方法，随机梯度下降和映射归约（Map reduce），用来处理海量的数据集。
• 随机梯度下降算法在每次迭代中不需要考虑全部的训练样本，仅仅只需要考虑一个训练样本，因此要快得多，我们将能够将这种思想应用到很多学习算法中，来适应更大的数据集，从而提高算法的性能。
• 小批量梯度下降算法某种意义上是一个介于随机梯度下降算法和批量梯度下降算法之间的算法，当我们选用好的小批量值，同时如果使用一个优秀的向量化方法，那么有时它会比随机梯度下降算法和批量梯度下降算法都要快。
• 在随机梯度下降收敛中，我们介绍了一种方法来近似地检验随机梯度下降算法在优化代价函数中的表现。这种方法并不需要定期地扫描整个训练集来计算出整个训练集的代价函数，而是只关注像前 $1000$ 个的这些样本，我们可以用这个方法来确保随机梯度下降法运行正确并且在收敛，或者用它来调整学习速率 $\alpha$ 。
• 在线学习机制与随机梯度下降算法非常类似，唯一的区别是，我们不会使用一个固定的数据集，而是获取一个用户样本，从那个样本中学习，然后丢弃那个样本，继续处理下一个，而且如果我们的某一种应用有一个连续的数据流，这样的算法可能会非常值得考虑。当然，在线学习的一个优点就是，如果我们有一个变化的用户群，又或者我们在尝试预测的事情在缓慢变化，例如用户的品味在缓慢变化，在线学习算法可以慢慢地调试我们所学习到的假设，将其调节更新到最新的用户行为。
• 在映射归约与数据并行中我们介绍了 $\mathrm{MapReduce}$ 方法来并行化计算机器学习问题，例如通过将数据发送到数据中心的多台电脑，这种方法也适用于同一台计算机上的多核并行计算，现在也有很好的开源的 $\mathrm{MapReduce}$ 实现，有个开源的系统叫做 $\mathrm{Hadoop}$，不管是用我们自己的实现或者用其他人的开源实现，我们都可以并行化学习算法，并让它运行在比单机可以承载的更大的数据集上。