吴恩达机器学习（二十二）—— 大规模机器学习
-
- 1. 大型数据集的学习
- 2. 随机梯度下降
- 3. 小批量梯度下降
- 4. 随机梯度下降收敛
- 5. 在线学习
- 6. 映射化简和数据并行
1. 大型数据集的学习
" It’s not who has the best algorithm that wins. It’s who has the most data. " 所以说，要想得到一个高效的机器学习系统的最好方式之一，就是用一个低偏差的学习算法，然后用很多数据来训练它。
但是用很大的数据集也有自己的问题，特别是计算量的问题。假设训练集大小为 m = 100 , 000 , 000 m=100,000,000 m=100,000,000，要训练一个线性回归模型或逻辑回归模型，根据梯度下降公式计算仅仅下一步的梯度下降，计算量就已经是巨大的，所以我们首先应该做的事是去检查一下这么大规模的训练集是否真的必要。在我们用算法训练大数据的模型前，可以先随机从上亿条的数据集里选一个1000条的子集，看是否值得扩大数据集的引入。也许我们只用1000个训练集也能获得较好的效果，这可以通过绘制学习曲线来帮助判断，如下图所示。
左图的高方差情况可以通过增加训练集的大小来提高算法性能，右图的高偏差情况就没有必要再增加数据集的规模了。
有两种方法可以用来处理海量的数据集：第一种为随机梯度下降；第二种为减少映射。
2. 随机梯度下降
批量梯度下降的代价函数为 J t r a i n ( θ ) = 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 J_{train}(\theta)=\frac{1}{2m}\sum ^{m}_{i=1}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )^{2} Jtrain(θ)=2m1i=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 ) } Repeat \left \{ \theta_{j}:= \theta_{j}-\alpha\frac{1}{m}\sum ^{m}_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})x_{j}^{(i)}(for\ _{}every\ _{} j =0,...,n) \right \} Repeat{ θj:=θj−αm1i=1∑m(hθ(x(i))−y(i))xj(i)(for every j=0,...,n)} 随机梯度下降的代价函数为 c o s t ( θ , ( x ( i ) , y ( i ) ) ) = 1 2 ( h θ ( x ( i ) ) − y ( i ) ) 2 cost\left ( \theta ,(x^{(i)},y^{(i)}) \right )=\frac{1}{2}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )^{2} cost(θ,(x(i),y(i)))=21(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 ) ) ) J_{train}(\theta)=\frac{1}{m}\sum ^{m}_{i=1}cost\left ( \theta ,(x^{(i)},y^{(i)}) \right ) Jtrain(θ)=m1i=1∑mcost(θ,(x(i),y(i))) 随机梯度下降的过程如下：
1. 随机打乱所有数据，即将所有 m m m个训练样本重新随机排列，以保证我们在遍历训练集时对训练样本的访问是以随机顺序排列的；
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 j = 0 , . . . , n ) } } \begin{matrix} Repeat \left \{ for\ _{}i=1,...,m \right.\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \left \{ \theta_{j}:= \theta_{j}-\alpha(h_{\theta}(x^{(i)})-y^{(i)})x_{j}^{(i)}\right. \\(for\ _{} j =0,...,n)\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \} \ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \end{matrix} Repeat{ for i=1,...,m { θj:=θj−α(hθ(x(i))−y(i))xj(i)(for j=0,...,n) } } 依次遍历整个训练集。
随机梯度下降跟批量梯度下降不同之处在于，随机梯度下降不需要对全部 m m m个样本求和来得到梯度项，而是只需要对单个训练样本求出 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) \left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )x_{j}^{(i)} (hθ(x(i))−y(i))xj(i)这个梯度项。在这个过程中，已经开始优化参数了，所以不需要对所有 m m m个训练集都遍历一遍。
当使用批量梯度下降时，需要同时考虑所有训练样本数量，其收敛过程会倾向于一条近似的直线，直到找到全局最小点，如下图中的绿色点走过的迭代过程轨迹。
随机梯度下降算法在每一次计算之后便更新参数 θ \theta θ ，而不需要首先将所有的训练集求和。在梯度下降算法还没有完成一次迭代时，随机梯度下降算法便已经走出了很远。但是这样的算法存在的问题是，不是每一步都是朝着”正确”的方向迈出的。因此算法是在某个靠近全局最小值得区域内徘徊，而不是直接逼近全局最小值点并停留在那里，这样的话可能永远也无法找到最小值点。但实际上这并没有多大问题，只要参数最终移动到某个非常靠近全局最小值的区域内，也会得到一个较为不错的假设函数，如下图中的红色点走过的迭代过程轨迹。
3. 小批量梯度下降
批量梯度下降：每次迭代中，使用所有 m m m个样本；
随机梯度下降：每次迭代中，使用1个样本；
小批量梯度下降：每次迭代中，使用 b b b个样本（一般 b = 10 b=10 b=10，取值范围为2-100）。
小批量梯度下降算法是介于批量梯度下降算法和随机梯度下降算法之间的算法，每计算常数 b b b次训练样本，便更新一次参数 。 小批量梯度下降算法如下：假设 b = 10 b=10 b=10， m = 1000 m=1000 m=1000，
R e p e a t { f o r i = 1 , 11 , 21 , . . . , 991 { θ j : = θ j − α 1 10 ∑ k = i i + 9 ( h θ ( x ( k ) ) − y ( k ) ) x j ( k ) f o r e v e r y j = 0 , . . . , n ) } } \begin{matrix} Repeat \left \{ for\ _{}i=1,11,21,...,991 \right.\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\left \{ \theta_{j}:= \theta_{j}-\alpha\frac{1}{10}\sum ^{i+9}_{k=i}(h_{\theta}(x^{(k)})-y^{(k)})x_{j}^{(k)}\right. \\for\ _{}every\ _{} j =0,...,n) \ _{}\ _{} \\ \}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \} \ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \end{matrix} Repeat{ for i=1,11,21,...,991 { θj:=θj−α101∑k=ii+9(hθ(x(k))−y(k))xj(k)for every j=0,...,n) } } 通常我们会令 b b b在2-100之间。这样做的好处在于，我们可以用向量化的方式来循环 b b b个训练样本，如果我们用的线性代数函数库比较好，能够支持并行处理，那么算法的总体表现将不受影响（与随机梯度下降相同）。
小批量梯度下降和随机梯度下降的比较：
在向量化的过程中，小批量梯度下降可能会比随机梯度下降算法更好，仅当我们有一个好的向量化方式。原因在于拥有好的向量计算库，此时小批量 b = 10 b=10 b=10个样本求和可以用一种更向量化的方法来实现，即允许部分并行计算10个样本的和，换句话说，使用好的数值代数库来部分的并行计算 b b b个样本。
小批量梯度下降的一个缺点是存在一个额外的参数 b b b，所以需要花费时间调试 b b b的大小，通常 b b b的取值在2-100之间都合理。因此，我们选的 b b b的值如果在有一个好的向量化实现条件下，有时它可以比随机梯度下降和批量梯度下降更快。
4. 随机梯度下降收敛
检查梯度下降是否收敛：
对于批量梯度下降而言，画出最优的代价函数 J J J关于迭代次数的变化图表，保证在每一次的迭代中，代价函数都是下降的，进而根据图表来判断梯度下降是否收敛。但是，在大规模的训练集的情况下，这是不现实的，因为计算代价太大了。
对于随机梯度下降而言，我们在每一次更新 θ \theta θ之前都计算一次代价 c o s t ( θ , ( x ( i ) , y ( i ) ) ) cost\left ( \theta,(x^{(i)},y^{(i)})\right ) cost(θ,(x(i),y(i)))，然后每次迭代后，求出这次对训练样本计算代价的平均值，最后绘制这些平均值与迭代次数之间的函数图表来进一步检查随机梯度下降是否收敛。
对于图a），蓝线可以判断出算法是在下降，但从某一点开始变得平缓，说明学习算法已经收敛了；红线代表使用更小的学习率 α \alpha α，算法的学习变得更慢了，因此代价函数的下降也变慢了，但有可能让算法收敛得更好一点。随机梯度使用更小的 α \alpha α，最终的振荡就会更小。
对于图b），蓝线运行随机梯度下降，然后对1000组样本取 c o s t cost cost函数的平均值，看起来收敛；红线将样本数从1000提高到5000组，会是一条更平滑的曲线，它的缺点是每5000个样本才能得到一个数据点，因此关于学习算法表现的反馈就显得有一些延迟。
对于图c），蓝线看起来一直比较平坦，并没有下降，如果用更大量的样本进行平均时会观察到红线所示的情况，实际上代价函数是在下降的，只是蓝线样本数量较少，不易看出来下降趋势。但如果增大训练样本数量，效果依然比较平坦，那可能就更肯定地说明算法确定没怎么学习好，需要调整学习率 α \alpha α或者改变特征向量。
对于图d），蓝线实际上是在上升的，很明显算法正在发散，那么此时就要用一个小一点的学习率 α \alpha α。
总结： 如果曲线的噪声太大，或者老是上下振动，可以试着增加求均值的样本数量，这样就可以看出函数变化的趋势；如果发现误差在上升，或者说 c o s t cost cost函数值在上升，就用一个更小的学习率 α \alpha α。
我们也可以令学习率 α \alpha α随着迭代次数的增加而减小，例如令： α = 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 \alpha = \frac{const1}{iteration\ _{}Number+const2} α=iteration Number+const2const1，随着迭代次数越大，学习率 α \alpha α会慢慢变小，因此每一步都会越来越精确，直到最终收敛到全局最小值。但是我们很少采用这种逐渐减小 α \alpha α值的方法（因为公式中确定两个常数需要更多的工作量，并且我们对能够接近全局最小值的参数已经很满意），而是让 α \alpha α保持为一个常数。
5. 在线学习
一种新的大规模的机器学习机制，叫做在线学习机制，在线学习机制让我们可以模型化问题。
今天，许多大型网站或者许多大型网络公司，使用不同版本的在线学习机制算法，从大批的涌入又离开网站的用户身上进行学习。特别要提及的是，如果我们有一个由连续的用户流引发的连续的数据流进入网站，我们能做的是使用一个在线学习机制，从数据流中学习用户的偏好，然后使用这些信息来优化一些关于网站的决策。
一个算法在从中学习的时候来模型化问题在线学习算法指的是对数据流而非离线的静态数据集的学习。许多在线网站都有持续不断的用户流，对于每一个用户，网站希望能在不将数据存储到数据库中便顺利地进行算法学习。
在线学习算法与随机梯度下降算法有些类似，我们对单一的样本进行学习，而非对一个提前定义的训练集进行循环。 R e p e a t f o r e v e r { G e t ( x , y ) c o r r e s p o n d i n g t o t h e c u r r e n t u s e r u p d a t e θ u s i n g ( x , y ) : θ j : = θ j − α ( h θ ( x ) − y ) x j ( j = 0 , . . . , n ) } \begin{matrix} Repeat \ _{}forever \left \{ Get\ _{}(x,y)\ _{} corresponding\ _{} to\ _{} the \ _{}current \ _{}user \right. \\ update\ _{}\theta\ _{}using\ _{}(x,y):\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \\ \ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \theta_{j}:= \theta_{j}-\alpha(h_{\theta}(x)-y)x_{j}\ _{}\ _{}( j =0,...,n) \\ \}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{}\ _{} \end{matrix} Repeat forever{ Get (x,y) corresponding to the current userupdate θ using (x,y): θj:=θj−α(hθ(x)−y)xj (j=0,...,n)} 一旦对一个数据的学习完成了，我们便可以丢弃该数据，不需要再存储它了。这种方式的好处在于，我们的算法可以很好的适应用户的倾向性，算法可以针对用户的当前行为不断地更新模型以适应该用户。
在线学习算法与随机梯度下降算法唯一的区别是，在线学习算法不用使用一个固定的数据集，而是获取一个用户样本，从那个样本中学习，然后丢弃那个样本继续下去，如果有一个连续的数据流，这个算法非常值得考虑。在线学习的一个优点是，如果有一个变化的用户群又或者尝试预测的事情在缓慢变化，在线学习算法可以慢慢地调试所学到的假设，将其调节更新到最新的用户行为。
传统的机器学习（ machine learning）技术是利用一批已有的数据，学习到一个固化的模型。该模型的泛化能力不能依赖于精心设计的模型，还更需要一次灌注海量数据来保证。而在线学习（online learning）则不需要海量数据，只需要少量启动数据，通过探索、反馈、修正来逐渐学习。相比之下，在线学习对数据的使用更加灵活，不仅能减轻更新模型时的计算负担，更可以提高模型的时效性，更加符合人的学习方式，而传统的机器学习则是侧重于统计分析。
6. 映射化简和数据并行
映射化简和数据并行对于大规模机器学习问题而言是非常重要的概念。之前提到，如果我们用批量梯度下降算法来求解大规模数据集的最优解，我们需要对整个训练集进行循环，计算偏导数和代价，再求和，计算代价非常大。如果我们能够将我们的数据集分配给多台计算机，让每一台计算机处理数据集的一个子集，然后我们将计算的结果汇总求和。这样的方法叫做映射简化(Map-reduce)。
具体而言，如果任何学习算法能够表达为对训练集的函数的求和，那么便能将这个任务分配给多台计算机（或者同一台计算机的不同CPU 核心），以达到加速处理的目的。
例如，我们有400个训练样本，我们可以将批量梯度下降的求和任务分配给4台计算机进行处理：
| machine no | sample | computation |
|---|---|---|
| 1 | 1-100 | t e m p j ( 1 ) = ∑ i = 1 100 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp^{(1)}_{j}=\sum ^{100}_{i=1}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )x_{j}^{(i)} tempj(1)=∑i=1100(hθ(x(i))−y(i))xj(i) |
| 2 | 101-200 | t e m p j ( 2 ) = ∑ i = 101 200 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp^{(2)}_{j}=\sum ^{200}_{i=101}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )x_{j}^{(i)} tempj(2)=∑i=101200(hθ(x(i))−y(i))xj(i) |
| 3 | 201-300 | t e m p j ( 3 ) = ∑ i = 201 300 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp^{(3)}_{j}=\sum ^{300}_{i=201}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )x_{j}^{(i)} tempj(3)=∑i=201300(hθ(x(i))−y(i))xj(i) |
| 4 | 301-400 | t e m p j ( 4 ) = ∑ i = 301 400 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp^{(4)}_{j}=\sum ^{400}_{i=301}\left ( h_{\theta }(x^{(i)}) -y^{(i)}\right )x_{j}^{(i)} tempj(4)=∑i=301400(hθ(x(i))−y(i))xj(i) |
结果汇总为： θ j : = θ j − α 1 400 ( t e m p ( 1 ) + t e m p ( 2 ) + t e m p ( 3 ) + t e m p ( 4 ) ) \theta_{j}:= \theta_{j}-\alpha\frac{1}{400}(temp^{(1)}+temp^{(2)}+temp^{(3)}+temp^{(4)}) θj:=θj−α4001(temp(1)+temp(2)+temp(3)+temp(4))。
映射化简的示意图如下图所示。有一些训练样本，如果我们希望使用4台计算机并行的运行机器学习算法，那么可以让训练样本尽量均匀地等分成4份，然后将这4个训练样本的子集发送给4个不同的计算机，每一台计算机对 1 4 \frac{1}{4} 41的训练数据进行求和运算，最终每个电脑把结果发送给一个中心服务器，将结果进行汇总。
特别地，如果没有网络延时，也不考虑通过网络来回传输数据所消耗的时间，那么就可以有4倍的计算效率。当然实际上因为网络延时，结果汇总也需要额外的时间以及其他因素，实际上速率会小于4倍。但是不管怎样，映射映射化简算法为我们提供了一种方式来处理一台电脑无法处理的大规模数据。
通过将机器学习算法表示为求和的形式，或者是训练数据的求和形式，我们就可以运用映射化简技术来将算法并行化以便处理大规模数据。
对于多核计算机，即使在一台计算机上也可以把训练集分成多份。把映射化简看成是一台机器中不同核的并行，而不是多台机器的并行，这样的好处在于，可以不用担心网络延迟的问题了。因为通信传输接发变量 t e m p j temp_{j} tempj都在同一台机器里，网络延迟是很小的，还有有些线性代数库可以自动在一台机器的不同核上进行并行处理。如果我们的学习算法有非常好的向量化表示和线性代数库，那么就可以直接以向量化的形式应用标准的学习算法，不用担心并行，线性代数库会帮我们处理好，所以就不需要应用映射化简技术。但对于其他学习问题，应用映射化简是个好的方法，它可以加速学习算法。