Spark MLlib

基本概念

1. 项不项集
这是一个集合的概念，在一篮子商品中的一件消费品即一项（item），则若干项的集合为
项集，如{啤酒，尿布}构成一个二元项集。

2. 关联规则
关联规则用亍表示数据内隐含的关联性，例如表示购买了尿布的消费者往往也会购买啤酒。
关联性强度如何，由3 个概念，即支持度、置信度、提升度来控制和评价。

3. 支持度（support）
支持度是指在所有项集中{X, Y}出现的可能性，即项集中同时含有X 和Y 的概率：
设定最小阈值为5%，由亍{尿布，啤酒}的支持度为800/10000=8%，满足最小阈值要求，
成为频繁项集，保留规则；而{尿布，面包}的支持度为100/10000=1%，则被剔除。

4. 置信度（confidence）
置信度表示在先决条件X 发生的条件下，关联结果Y 发生的概率：这是生成强关联规则的
第二个门槛，衡量了所考察的关联规则在“质”上的可靠性。相似地，我们需要对置信度设定
最小阈值（mincon）来实现进一步筛选。
当设定置信度的最小阈值为70%时，例如{尿布，啤酒}中，购买尿布时会购买啤
酒的置信度为800/1000=80%，保留规则；而购买啤酒时会购买尿布的置信度为800/2000=40%，
则被剔除。

5. 提升度（lift）
提升度表示在含有X 的条件下同时含有Y 的可能性与没有X 这个条件下项集中含有Y 的可
能性之比：公式为置信度(artichok=>cracker)/支持度(cracker)。该指标与置信度同样衡量规则的
可靠性，可以看作是置信度的一种互补指标。

1. Spark MLlib矩阵向量

Spark MLlib底层的向量、矩阵运算使用了Breeze库，Breeze库提供了Vector/Matrix的实现以及相应计算的接口（Linalg）。但是在MLlib里面同时也提供了Vector和Linalg等的实现。

1.1 Breeze创建函数

1. 在使用Breeze 库时，需要导入相关包：

​ import breeze.linalg._

​ import breeze.numerics._

2. API：

   http://www.scalanlp.org/api/breeze/index.html#breeze.linalg.package

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xSz77xus-1603511454051)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701101858674.png)]

scala> val m1 = DenseMatrix.zeros[Double](2,3)
m1: breeze.linalg.DenseMatrix[Double] = 
0.0 0.0 0.0 
0.0 0.0 0.0 

scala> val v1 = DenseVector.zeros[Double](3)
v1: breeze.linalg.DenseVector[Double] = DenseVector(0.0, 0.0, 0.0)

scala> val v2 = DenseVector.ones[Double](3)
v2: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 1.0, 1.0)

scala> val v3 = DenseVector.fill(3){5.0}
v3: breeze.linalg.DenseVector[Double] = DenseVector(5.0, 5.0, 5.0)

scala> val v4 = DenseVector.range(1,10,2)
v4: breeze.linalg.DenseVector[Int] = DenseVector(1, 3, 5, 7, 9)

scala> val m2 = DenseMatrix.eye[Double](3)
m2: breeze.linalg.DenseMatrix[Double] = 
1.0 0.0 0.0 
0.0 1.0 0.0 
0.0 0.0 1.0

scala> val v6 = diag(DenseVector(1.0,2.0,3.0))
v6: breeze.linalg.DenseMatrix[Double] = 
1.0 0.0 0.0 
0.0 2.0 0.0 
0.0 0.0 3.0

scala> val v8 = DenseVector(1,2,3,4)
v8: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4)

scala> val v9 = DenseVector(1,2,3,4).t
v9: breeze.linalg.Transpose[breeze.linalg.DenseVector[Int]] = Transpose(DenseVector(1, 2, 3, 4))

scala> val v10 = DenseVector.tabulate(3){i => 2*i}
v10: breeze.linalg.DenseVector[Int] = DenseVector(0, 2, 4)

scala> val m4 = DenseMatrix.tabulate(3, 2){case (i, j) => i+j}
m4: breeze.linalg.DenseMatrix[Int] = 
0 1 
1 2 
2 3

scala> val v11 = new DenseVector(Array(1, 2, 3, 4))
v11: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4)
scala> val m5 = new DenseMatrix(2, 3, Array(11, 12, 13, 21, 22, 23))
m5: breeze.linalg.DenseMatrix[Int] = 
11 13 22 
12 21 23

scala> val v12 = DenseVector.rand(4)
v12: breeze.linalg.DenseVector[Double] = DenseVector(0.7517657487447951, 0.8171495400874123, 0.8923542318540489, 
0.174311259949119)

scala> val m6 = DenseMatrix.rand(2, 3)
m6: breeze.linalg.DenseMatrix[Double] = 
0.5349430131148125 0.8822136832272578 0.7946323804433382 
0.41097756311601086 0.3181490074596882 0.34195102205697414

1.2 Breeze元素访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-racB3EM5-1603511454054)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701102134192.png)]

scala> val a = DenseVector(1,2,3,4,5,6,7,8,9,10)
a: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a(0)
res2: Int = 1

scala> a(1 to 4) 
res4: breeze.linalg.DenseVector[Int] = DenseVector(2, 3, 4, 5)

scala> a(5 to 0 by -1)
res5: breeze.linalg.DenseVector[Int] = DenseVector(6, 5, 4, 3, 2, 1)

scala> a(1 to -1)
res6: breeze.linalg.DenseVector[Int] = DenseVector(2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a( -1 )
res7: Int = 10

scala> val m = DenseMatrix((1.0,2.0,3.0), (3.0,4.0,5.0))
m: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
3.0 4.0 5.0

scala> m(0,1)
res8: Double = 2.0

scala> m(::,1)
res9: breeze.linalg.DenseVector[Double] = DenseVector(2.0, 4.0)

1.3 Breeze元素操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VJON8ZYu-1603511454056)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701102704320.png)]

scala> val m = DenseMatrix((1.0,2.0,3.0), (3.0,4.0,5.0))
m: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
3.0 4.0 5.0

scala> m.reshape(3, 2)
res11: breeze.linalg.DenseMatrix[Double] = 
1.0 4.0 
3.0 3.0 
2.0 5.0 

scala>m.toDenseVector
res12: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 3.0, 2.0, 4.0, 3.0, 5.0)

scala> val m = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
m: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0 

scala> val m = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
m: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0

scala> lowerTriangular(m)
res19: breeze.linalg.DenseMatrix[Double] = 
1.0 0.0 0.0 
4.0 5.0 0.0 
7.0 8.0 9.0 

scala> upperTriangular(m)
res20: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
0.0 5.0 6.0 
0.0 0.0 9.0

scala> m.copy
res21: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0 

scala> diag(m)
res22: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 5.0, 9.0)

scala> m(::, 2) := 5.0
res23: breeze.linalg.DenseVector[Double] = DenseVector(5.0, 5.0, 5.0)

scala> m
res24: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 5.0 
4.0 5.0 5.0 
7.0 8.0 5.0 

scala> m(1 to 2,1 to 2) := 5.0
res32: breeze.linalg.DenseMatrix[Double] = 
5.0 5.0 
5.0 5.0 

scala> m
res33: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 5.0 
4.0 5.0 5.0 
7.0 5.0 5.0

scala> val a = DenseVector(1,2,3,4,5,6,7,8,9,10)
a: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a(1 to 4) := 5
res27: breeze.linalg.DenseVector[Int] = DenseVector(5, 5, 5, 5)

scala> a(1 to 4) := DenseVector(1,2,3,4)
res29: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4)

scala> a
res30: breeze.linalg.DenseVector[Int] = DenseVector(1, 1, 2, 3, 4, 6, 7, 8, 9, 10)

scala> val a1 = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0))
a1: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0

scala> val a2 = DenseMatrix((1.0,1.0,1.0), (2.0,2.0,2.0))
a2: breeze.linalg.DenseMatrix[Double] = 
1.0 1.0 1.0 
2.0 2.0 2.0 

scala> DenseMatrix.vertcat(a1,a2)
res34: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
1.0 1.0 1.0 
2.0 2.0 2.0 

scala> DenseMatrix.horzcat(a1,a2)
res35: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 1.0 1.0 1.0 
4.0 5.0 6.0 2.0 2.0 2.0

scala> val b1 = DenseVector(1,2,3,4)
b1: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4)

scala> val b2 = DenseVector(1,1,1,1)
b2: breeze.linalg.DenseVector[Int] = DenseVector(1, 1, 1, 1)

scala> DenseVector.vertcat(b1,b2)
res36: breeze.linalg.DenseVector[Int] = DenseVector(1, 2, 3, 4, 1, 1, 1, 1)

1.4 Breeze数值计算函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kpbYDs16-1603511454057)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701102814634.png)]

scala> val a = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0))
a: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 

scala> val b = DenseMatrix((1.0,1.0,1.0), (2.0,2.0,2.0))
b: breeze.linalg.DenseMatrix[Double] = 
1.0 1.0 1.0 
2.0 2.0 2.0 

scala> a + b
res37: breeze.linalg.DenseMatrix[Double] = 
2.0 3.0 4.0 
6.0 7.0 8.0

scala> a :* b
res38: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
8.0 10.0 12.0 

scala> a :/ b
res39: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
2.0 2.5 3.0 

scala> a :< b
res40: breeze.linalg.DenseMatrix[Boolean] = 
false false false 
false false false

scala> a :== b
res41: breeze.linalg.DenseMatrix[Boolean] = 
true false false 
false false false 

scala> a :+= 1.0
res42: breeze.linalg.DenseMatrix[Double] = 
2.0 3.0 4.0 
5.0 6.0 7.0 

scala> a :*= 2.0
res43: breeze.linalg.DenseMatrix[Double] = 
4.0 6.0 8.0 
10.0 12.0 14.0

scala> max(a)
res47: Double = 14.0

scala> argmax(a)
res48: (Int, Int) = (1,2)

scala> DenseVector(1, 2, 3, 4) dot DenseVector(1, 1, 1, 1)
res50: Int = 10

1.5 Breeze求和函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jc9qefzV-1603511454059)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701102938578.png)]

scala> val a = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
a: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0 

scala> sum(a)
res51: Double = 45.0

scala> sum(a, Axis._0)
res52: breeze.linalg.DenseMatrix[Double] = 12.0 15.0 18.0

scala> sum(a, Axis._1)
res53: breeze.linalg.DenseVector[Double] = DenseVector(6.0, 15.0, 24.0)

scala> trace(a)
res54: Double = 15.0

scala> accumulate(DenseVector(1, 2, 3, 4))
res56: breeze.linalg.DenseVector[Int] = DenseVector(1, 3, 6, 10)

1.6 Breeze布尔函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o7rgXnAz-1603511454061)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701103338864.png)]

scala> val a = DenseVector(true, false, true)
a: breeze.linalg.DenseVector[Boolean] = DenseVector(true, false, true)

scala> val b = DenseVector(false, true, true)
b: breeze.linalg.DenseVector[Boolean] = DenseVector(false, true, true)

scala> a :& b
res57: breeze.linalg.DenseVector[Boolean] = DenseVector(false, false, true)

scala> a :| b
res58: breeze.linalg.DenseVector[Boolean] = DenseVector(true, true, true)

scala> !a
res59: breeze.linalg.DenseVector[Boolean] = DenseVector(false, true, false)

scala> val a = DenseVector(1.0, 0.0, -2.0)
a: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 0.0, -2.0)

scala> any(a)
res60: Boolean = true

scala> all(a)
res61: Boolean = false

1.7 Breeze线性代数函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-peWpTdRE-1603511454062)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701103514939.png)]

scala> val a = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
a: breeze.linalg.DenseMatrix[Double] = 
1.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0 

scala> val b = DenseMatrix((1.0,1.0,1.0), (1.0,1.0,1.0) , (1.0,1.0,1.0))
b: breeze.linalg.DenseMatrix[Double] = 
1.0 1.0 1.0 
1.0 1.0 1.0 
1.0 1.0 1.0

scala> a \ b
res74: breeze.linalg.DenseMatrix[Double] = 
-2.5 -2.5 -2.5 
4.0 4.0 4.0 
-1.5 -1.5 -1.5 

scala> a.t
res63: breeze.linalg.DenseMatrix[Double] = 
1.0 4.0 7.0 
2.0 5.0 8.0 
3.0 6.0 9.0 

scala> det(a)
res64: Double = 6.661338147750939E-16

scala> a \ b
res74: breeze.linalg.DenseMatrix[Double] = 
-2.5 -2.5 -2.5 
4.0 4.0 4.0 
-1.5 -1.5 -1.5

scala> a.t
res63: breeze.linalg.DenseMatrix[Double] = 
1.0 4.0 7.0 
2.0 5.0 8.0 
3.0 6.0 9.0 

scala> det(a)
res64: Double = 6.661338147750939E-16

1.8 Breeze取整函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ep2UBRRV-1603511454063)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701103648416.png)]

scala> val a = DenseVector(1.2, 0.6, -2.3)
a: breeze.linalg.DenseVector[Double] = DenseVector(1.2, 0.6, -2.3)

scala> round(a)
res75: breeze.linalg.DenseVector[Long] = DenseVector(1, 1, -2)

scala> ceil(a)
res76: breeze.linalg.DenseVector[Double] = DenseVector(2.0, 1.0, -2.0)

scala> floor(a)
res77: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 0.0, -3.0)

scala> signum(a)
res78: breeze.linalg.DenseVector[Double] = DenseVector(1.0, 1.0, -1.0)

scala> abs(a)
res79: breeze.linalg.DenseVector[Double] = DenseVector(1.2, 0.6, 2.3)

1.9 Breeze其它函数

1.9.1 Breeze三角函数

Breeze三角函数包括：

	sin, sinh, asin, asinh

	cos, cosh, acos, acosh

	tan, tanh, atan, atanh

	atan2

	sinc(x) ，即sin(x)/x

	sincpi(x) ，即 sinc(x * Pi)

1.9.2 Breeze对数和指数函数

Breeze对数和指数函数包括：

	log, exp log10
	
	log1p, expm1
	
	sqrt, sbrt
	
	pow

2.0 BLAS介绍

BLAS按照功能被分为三个级别：

 Level 1：矢量-矢量运算，比如点积（ddot)，加法和数乘 (daxpy)， 绝对值的和（dasum)，等等；

 Level 2：矩阵-矢量运算，最重要的函数是一般的矩阵向量乘法(dgemv)； 

 Level 3：矩阵-矩阵运算，最重要的函数是一般的矩阵乘法 (dgemm)； 

 每一种函数操作都区分不同数据类型（单精度、双精度、复数）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A7hRoXuY-1603511454064)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701104304628.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkMrN7Pg-1603511454066)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701104317527.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqMCx6bG-1603511454067)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701104338559.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hhGEuOSp-1603511454068)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701104345480.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3zXtzXxk-1603511454069)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701104420360.png)]

2. 数学模型

一元线性回归 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SP0SfIMD-1603511454757)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111330622.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u0uCEj0m-1603511454757)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111416866.png)]
多元线性回归 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cDiyhDoI-1603511454758)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111357600.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0hfquX1t-1603511454759)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111432234.png)]

3. 批量梯度下降算法

3.1 损失函数 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rbpMuJie-1603511454071)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111533487.png)]

3.2 J(θ)的极小值问题 —> 梯度下降法 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pM1of3ou-1603511454072)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111635039.png)]

3.3 样本数量m为1时

4. 随机梯度下降算法

当样本集数据量 m 很大时，批量梯度下降算法每迭代一次的复杂度为 O ( mn )，复杂度很高。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eNjukFSI-1603511454073)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701111951895.png)]

即每读取一条样本，就迭代对 进行更新，这样迭代一次的算法复杂度为 O ( n )。

4.1 源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V4yQmleY-1603511454074)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112116011.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IwfmpreT-1603511454075)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112143077.png)]

5. 贝叶斯定理

5.1 在贝叶斯中的相关术语定义：

1） P ( A ) 是 A 的先验概率或边缘概率。之所以称为"先验"是因为它不考虑任何B方面的因素。
2） P ( A | B ) 是已知 B 发生后 A 的条件概率，也由于得自 B 的取值而被称作 A 的后验概率。
3） P ( B | A )是已知 A 发生后 B 的条件概率，也由于得自 A 的取值而被称作 B 的后验概率。
4） P ( B ) 是 B 的先验概率或边缘概率，也被称作标准化常量 （normalized constant）。

5.2 朴素贝叶斯分类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AoYIJ0SX-1603511454076)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112335159.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jyCbpqbP-1603511454077)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112340610.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NAw9jP3u-1603511454078)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112345733.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H2AtaBxM-1603511454079)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112351184.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90aNenRI-1603511454080)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112400762.png)]

5.3 源码分析

MLlib的贝叶斯分类模型采用朴素贝叶斯分类算法，其模型主要是计算每个类别的先验概率 、各类别下各个特征属性的条件概率，其分布式实现方法是：对样本进行聚合操作，统计所有标签出现的次数、对应特征之和；对(label, features)格式样本采用combineByKey聚合函数，对同一标签数据进行聚合统计操作。通过聚合操作后，可以通过聚合结果计算先验概率、条件概率，得到朴素贝叶斯分类模型。对于预测，根据模型的先验概率、条件概率，计算每个样本属于每个类别的概率，最后取最大项作为样本的类别。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pZlgrudS-1603511454081)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701112507916.png)]

6. 决策树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90EUuzKF-1603511454082)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133735817.png)]

决策树定义：
决策树（decision tree）是一个树结构，决策树由节点和有向边组成。
节点有两种类型：内部节点和叶节点，内部节点表示一个特征或属性，叶节点表示一个类。
其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出。

决策树学习过程：
决策树学习的本质是从训练数据集上归纳出一组分类规则，通常采用启发式的方法：局部最优。
具体做法就是，每次选择feature时，都挑选当前条件下最优的那个feature作为划分规则，即局部最优的feature。
决策树学习通常分为3 个步骤：特征选择、决策树生成和决策树的修剪。

选择特征的标准是找出局部最优的特征 ，判断一个特征对于当前数据集的分类效果。也就是按照这个特征进行分类后，数据集是否更加有序（不同分类的数据被尽量分开）。
衡量节点数据集合的有序性（纯度）有：
1) 熵
2) 基尼
3) 方差

6.1 熵

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8IImOoqn-1603511454082)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133915334.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jZsMwRC7-1603511454083)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133919556.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hHPOAR50-1603511454084)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133926815.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7vDzqEJe-1603511454085)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133934329.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jT23aWIC-1603511454086)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701133938169.png)]

6.2 ID3算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sOQBldsD-1603511454087)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134001872.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jt1PnG16-1603511454088)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134007130.png)]

6.3 决策树生成实例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SmTb1n3H-1603511454089)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134038529.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6e8MAnTX-1603511454090)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134043748.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sDEzFn6N-1603511454091)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134047424.png)]

6.4 源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G5GQMKbq-1603511454092)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134052817.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NljS2Nfi-1603511454093)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134056488.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQfy5KqY-1603511454094)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134103734.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S5aUWEoG-1603511454095)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134106921.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MWA13Cug-1603511454096)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134412121.png)]

7. KMeans 算法

KMeans 算法的基本思想是初始随机给定K 个簇中心，按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心，从而确定新的簇心。一直迭代，直到簇心的移动距离小于某个给定的值。
KMeans 聚类算法主要分为3 个步骤。
1）第1 步是为待聚类的点寻找聚类中心；
2）第2 步是计算每个点到聚类中心的距离，将每个点聚类到离该点最近的聚类中去；
3）第3 步是计算每个聚类中所有点的坐标平均值，并将这个平均值作为新的聚类中心。
反复执行2）、3），直到聚类中心不再进行大范围移动或者聚类次数达到要求为止。

展示了对n 个样本点进行KMeans 聚类的效果，这里k 取2。
（a）未聚类的初始点集；
（b）随机选取两个点作为聚类中心；
（c）计算每个点到聚类中心的距离，
并聚类到离该点最近的聚类中去；
（d）计算每个聚类中所有点的坐标平均值，
并将这个平均值作为新的聚类中心；
（e）重复（c），计算每个点到聚类中心的距离，
并聚类到离该点最近的聚类中去；
（f）重复（d），计算每个聚类中所有点的坐标平均值，并将这个平均值作为新的聚类中心。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Svku4cid-1603511454097)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134546142.png)]

7.1 初始化聚类中心点

k-means++算法选择初始中心点的基本思想就是：初始的聚类中心之间的相互距离要尽可能远。初始化过程如下。
1）从输入的数据点集合中随机选择一个点作为第一个聚类中心；
2）对于数据集中的每一个点x，计算它与最近聚类中心（指已选择的聚类中心）的距离D(x)；
3）选择一个新的数据点作为新的聚类中心，选择的原则是：D(x)较大的点，被选取作为聚类中心的概率较大；
4）重复2）和3），直到k 个聚类中心被选出来；
5）利用这k 个初始的聚类中心来运行标准的KMeans 算法。

从上面的算法描述可以看到，算法的关键是第3 步，如何将D(x)反映到点被选择的概率上。一种算法如下。
1）随机从点集D 中选择一个点作为初始的中心点。
2）计算每一个点到最近中心点的距离Si ，对所有Si 求和得到sum。
3）然后再取一个随机值，用权重的方式计算下一个“种子点”。取随机值random
（0<random<sum），对点集D 循环，做random - = Si 运算，直到random < 0，那么点i 就是下一个中心点。
4）重复2）和3），直到k 个聚类中心被选出来。
5）利用这k 个初始的聚类中心来运行标准的KMeans 算法。

7.2 源码分析

MLlib 实现KMeans 聚类算法：首先随机生成聚类中心点，支持随机选择样本点当作初始中心点，还支持k-means++方法选择最优的聚类中心点。然后迭代计算样本的中心点，迭代计算中心点的分布式实现是：首先计算每个样本属于哪个中心点，之后采用聚合函数统计属于每个中心点的样本值之和以及样本数量，最后求得最新中心点，并且判断中心点是否发生改变。

MLlib 的KMeans 聚类模型的runs 参数可以设置并行计算聚类中心的数量，runs 代表同时计算多组聚类中心点，最后取计算结果最好的那一组中心点作为聚类中心点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hqcPvbcm-1603511454097)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134808709.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4DvOrEvx-1603511454098)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134817799.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hJp0KVaV-1603511454099)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701134837943.png)]

8. FPGrowth 算法

1. 按以下步骤构造FP 树
1）扫描事务数据库D 一次。收集频繁项的集合F 和它们的支持度。对F 按支持度降序排序，结果为频繁项
表L。

2）创建FP 树的根节点，以“null”标记它。对亍D 中的每个事务Trans，执行：选择 Trans
中的频繁项，并按L 中的次序排序。设排序后的频繁项表为[p | P]，其中，p 是第一个元素，而
P 是剩余元素的表。调用insert_tree([p | P], T)。该过程执行情况如下。如果T 有子节点N 使得
N.item-name = p.item-name，则N 的计数增加1；否则创建一个新节点N 将其计数设置为1，链
接到它的父节点T，并且通过节点的链结构将其链接到具有相同item-name 的节点中。如果P
非空，则递归地调用insert_tree(P, N)。

8.1 FP 树构建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5k6nYfbo-1603511454100)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135244379.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cY2Dk8uA-1603511454101)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135345417.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCDYrrHF-1603511454102)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135351302.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-miHWC7gU-1603511454103)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135355977.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bUg28UW5-1603511454104)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135400421.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IXLSYq5O-1603511454105)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135405470.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dHHfDcW8-1603511454105)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135409774.png)]

8.2 源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nljKuCyz-1603511454106)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135443568.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CVDdiH4-1603511454107)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135452238.png)]

9. 协同过滤推荐算法

9.1 概述

| | 协同过滤推荐算法，是最经典、最常用的推荐算法。
通过分析用户兴趣，在用户群中找到指定用户的相似用户，综合这些相似用户对某一信息的评价，形成系统关于该指定用户对此信息的喜好程度预测。

要实现协同过滤，需要以下几个步骤：
1）收集用户偏好；
2）找到相似的用户或物品；

3）计算推荐。

9.2 用户评分

从用户的行为和偏好中发现规律，并基于此进行推荐，所以收集用户的偏好信息成为系统推荐效果最基础的决定因素。用户有很多种方式向系统提供自己的偏好信息，比如：评分、投票、转发、保存书签、购买、点击流、页面停留时间等。

1. 将不同的行为分组
       一般可以分为查看和购买，然后基于不同的用户行为，计算不同用户或者物品的相似度。
2. 对不同行为进行加权
        对不同行为产生的用户喜好进行加权，然后求出用户对物品的总体喜好。当我们收集好用户的行为数据后，还要对       数据进行预处理，最核心的工作就是减噪和归一化。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a8YK7Cri-1603511454108)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135819937.png)]

9.3 相似度计算

对用户的行为分析得到用户的偏好后，可以根据用户的偏好计算相似用户和物品，然后可以基于相似用户或物品进行推荐。这就是协同过滤中的两个分支了，即基于用户的协同过滤和基于物品的协同过滤。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Xis7QrR-1603511454109)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135847108.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E7spblBJ-1603511454110)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135900503.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SQgCyG6n-1603511454111)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135906642.png)]

3. 皮尔逊相关系数（Pearson Correlation Coefficient）
4. Cosine 相似度（Cosine Similarity）
5. Tanimoto 系数（Tanimoto Coefficient）

9.4 推荐计算

1. 基于用户的CF（User CF）
基于用户的 CF 的基本思想相当简单：基于用户对物品的偏好找到相邻的邻居用户，然后将邻居用户喜欢的推荐给当前用户。在计算上，就是将一个用户对所有物品的偏好作为一个向量来计算用户之间的相似度，找到K 邻居后，根据邻居的相似度权重及其对物品的偏好，预测当前用户没有偏好的未涉及物品，计算得到一个排序的物品列表作为推荐。图14-1 给出了一个例子，对于用户A，根据用户的历史偏好，这里只计算得到一个邻居-用户C，然后将用户C 喜欢的物品D 推荐给用户A。 

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r1bxNDZQ-1603511454111)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701135946655.png)]

2. 基于物品的CF（Item CF）
基于物品的CF 的原理和基于用户的CF 类似，只是在计算邻居时采用物品本身，而不是从用户的角度。即基于用户对物品的偏好找到相似的物品，然后根据用户的历史偏好，推荐相似的物品给他。从计算的角度看，就是将所有用户对某个物品的偏好作为一个向量来计算物品之间的相似度，得到物品的相似物品后，根据用户历史的偏好预测当前用户还没有表示偏好的物品，计算得到一个排序的物品列表作为推荐。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lYBOBbNr-1603511454112)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140003770.png)]

9.5 协同推荐算法实现

根据用户评分矩阵采用同现相似度计算物品相似度矩阵。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BpD5AmKE-1603511454113)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140039848.png)]

其相似度计算实现了分布式计算，实现过程如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZTkqXtKX-1603511454114)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140051750.png)]

对于欧氏相似度的计算，采用离散计算公式d(x, y) = sqrt(Σ((x(i)-y(i)) * (x(i)- y(i))))。其中，i 只取x、y 同现的点，未同现的点不参与相似度计算；sim(x, y) = m / (1 + d(x, y))，m 为x、y 重叠数，同现次数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aFW93GNq-1603511454115)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140110035.png)]

根据物品相似度矩阵和用户评分计算用户推荐列表，计算公式是R=W*A，取推荐计算中用户未评分过的物品，并且按照计算结果倒序推荐给用户。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gvklARp3-1603511454116)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140122047.png)]

其推荐计算实现了分布式计算。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3KcyF7Le-1603511454117)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140142874.png)]

9.6 源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ajTJYGLD-1603511454118)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140203728.png)]

10. 神经元

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pERJ6OCm-1603511454118)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140254299.png)]

神经元是神经网络的最小单元，神经网络是由神经元组成的，神经元的结构如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ivYUQmAw-1603511454119)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140314555.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F3GXldG0-1603511454120)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140317673.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2LwKfEdy-1603511454120)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140321433.png)]

10.1神经网络模型

神经网络就是将多个单一神经元联结在一起组成一个网络模型，图15-3 是一个简单的神经网络模型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t9C5i2xB-1603511454121)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140353004.png)]

10.2 信号前向传播

神经网络的信号前向传播过程如下：
 1）输入样本数据。
 2）将输入层作为隐含层节点的输入，计算隐含层节点的输出。如果隐含层包含多层，则将上
一层的输出作为下一层的输入，计算下一层的输出，依此类推。
 3）将隐含层节点的输出作为输出层的输入，计算输出层的输出。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ncfwrI4R-1603511454122)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140542294.png)]

10.3 误差反向传播

误差的反向传播，即首先由输出层开始逐层计算各层神经元的输出误差，然后根据误差梯度下降法来调
节各层的权值和阈值，使修改后的网络的最终输出能接近期望值。

对于每一个训练样本的误差函数定义为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CJVA25Xq-1603511454123)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140627537.png)]

对于 m 个样例的数据集，我们可以定义整体误差函数为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-26tgshlr-1603511454124)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140701712.png)]

我们的目标是求解( w , b )，使得整体误差 J ( w , b )最小，其常用的方法是梯度下降法。梯度下降法中的每一
次迭代都按照如下公式对参数 w 和 b 进行更新：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MWmhhHUu-1603511454125)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140719931.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yPmYqA4l-1603511454126)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140723312.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QWY7TSL4-1603511454126)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140727896.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eqntn2H6-1603511454127)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140731136.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oNwLMfvt-1603511454128)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140734420.png)]

10.3 源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jjegsUMP-1603511454129)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140804124.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MrYGIzmu-1603511454130)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140809670.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HsLzF6Sz-1603511454131)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140815200.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CQxYN1JK-1603511454132)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140841622.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KhgU77PO-1603511454133)(C:\Users\panshupeng\AppData\Roaming\Typora\typora-user-images\image-20200701140846657.png)]

隐含层节点的输入，计算隐含层节点的输出。如果隐含层包含多层，则将上
一层的输出作为下一层的输入，计算下一层的输出，依此类推。
3）将隐含层节点的输出作为输出层的输入，计算输出层的输出。

[外链图片转存中...(img-ncfwrI4R-1603511454122)]

### 10.3 误差反向传播

误差的反向传播，即首先由输出层开始逐层计算各层神经元的输出误差，然后根据误差梯度下降法来调
节各层的权值和阈值，使修改后的网络的最终输出能接近期望值。

对于每一个训练样本的误差函数定义为：

[外链图片转存中...(img-CJVA25Xq-1603511454123)]

对于 m 个样例的数据集，我们可以定义整体误差函数为：

[外链图片转存中...(img-26tgshlr-1603511454124)]

我们的目标是求解( w , b )，使得整体误差 J ( w , b )最小，其常用的方法是梯度下降法。梯度下降法中的每一
次迭代都按照如下公式对参数 w 和 b 进行更新：

[外链图片转存中...(img-MWmhhHUu-1603511454125)]

[外链图片转存中...(img-yPmYqA4l-1603511454126)]

[外链图片转存中...(img-QWY7TSL4-1603511454126)]

[外链图片转存中...(img-Eqntn2H6-1603511454127)]

[外链图片转存中...(img-oNwLMfvt-1603511454128)]

### 10.3 源码分析

[外链图片转存中...(img-jjegsUMP-1603511454129)]

[外链图片转存中...(img-MrYGIzmu-1603511454130)]

[外链图片转存中...(img-HsLzF6Sz-1603511454131)]

[外链图片转存中...(img-CQxYN1JK-1603511454132)]

[外链图片转存中...(img-KhgU77PO-1603511454133)]