本课程是在网易云课堂学习的，花费大概2个月时间，特此记录这一段学习过程。
本人才疏学浅，文中如有错误或不足还望大家指正！
一、有监督学习（Supervised learning）
有监督学习是从标签化训练数据集中训练得到一个最优模型，利用这个模型将所有的输入映射为相应的输出，从而实现预测和分类的目的，也就具有了对未知数据进行预测和分类的能力。
1. 线性回归（Linear regression）
线性回归模型:
假设函数：
h
θ
(
x
)
=
θ
0
+
θ
1
x
1
+
θ
2
x
2
+
…
+
θ
n
x
n
=
θ
T
X
h_{\theta}(x)=\theta_{0}+\theta_{1} x_{1}+\theta_{2} x_{2}+\ldots+\theta_{n} x_{n}=\theta^{T} X
hθ(x)=θ0+θ1x1+θ2x2+…+θnxn=θTX，其中
n
n
n 是特征数量，
θ
\theta
θ 是模型参数，
x
x
x 是输入变量（特征），
θ
\theta
θ 和
x
x
x 都是
n
+
1
n+1
n+1 维向量。
X
=
[
x
0
x
1
⋯
x
n
]
θ
=
[
θ
0
θ
1
⋯
θ
n
]
X=\left[\begin{array}{c} x_{0} \\ x_{1} \\ \cdots \\ x_{n} \end{array}\right] \quad \theta=\left[\begin{array}{c} \theta_{0} \\ \theta_{1} \\ \cdots \\ \theta_{n} \end{array}\right]
X=⎣⎢⎢⎡x0x1⋯xn⎦⎥⎥⎤θ=⎣⎢⎢⎡θ0θ1⋯θn⎦⎥⎥⎤
代价函数（MSE，Mean Square Error）：
J
(
θ
)
=
J
(
θ
0
，
θ
1
，
…
，
θ
n
)
=
1
2
m
∑
i
=
1
m
(
h
θ
(
x
(
i
)
)
−
y
(
i
)
)
2
J(\theta)=J\left(\theta_{0}，\theta_{1}，\ldots，\theta_{n}\right)=\frac{1}{2 m} \sum_{i=1}^{m}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right)^{2}
J(θ)=J(θ0，θ1，…，θn)=2m1i=1∑m(hθ(x(i))−y(i))2
梯度下降算法:
R e p e a t u n t i l c o n v e r g e n c e { θ j : = θ j − α ∂ ∂ θ j J ( θ ) } Repeat \ until \ convergence\left\{\theta_{j}:=\theta_{j}-\alpha \frac{\partial}{\partial \theta_{j}} J(\theta)\right\} Repeat until convergence{θj:=θj−α∂θj∂J(θ)}
R e p e a t u n t i l c o n v e r g e n c e { θ 0 : = θ 0 − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x ( i ) } Repeat \ until \ convergence \left\{\begin{array}{l}\theta_{0}:=\theta_{0}-\alpha \frac{1}{m} \sum_{i=1}^{m}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) \\ \theta_{j}:=\theta_{j}-\alpha \frac{1}{m} \sum_{i=1}^{m}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) x^{(i)}\end{array}\right\} Repeat until convergence{θ0:=θ0−αm1∑i=1m(hθ(x(i))−y(i))θj:=θj−αm1∑i=1m(hθ(x(i))−y(i))x(i)}
2. 逻辑回归（Logistic regression）
Logistic回归模型的假设函数是 h θ ( x ) = g ( θ T X ) h_{\theta}(x)=g\left(\theta^{T} X\right) hθ(x)=g(θTX)，其中 X X X 代表特征向量， g g g 代表Logistic函数。一个常用的Logistic函数为S形函数 (Sigmoid function) ，公式为 g ( z ) = 1 1 + e − z g(z)=\frac{1}{1+e^{-z}} g(z)=1+e−z1，函数图象如下图所示。
h
θ
(
x
)
h_{\theta}(x)
hθ(x) 的作用是：对于给定的输入变量
x
x
x，根据选择的参数计算输出变量
y
=
1
y=1
y=1 的可能性 (estimated probablity)，即
h
θ
(
x
)
=
P
(
y
=
1
∣
x
;
θ
)
h_{\theta}(x)=P(y=1 \mid x ; \theta)
hθ(x)=P(y=1∣x;θ)，所以有
P
(
y
=
0
∣
x
;
θ
)
+
P
(
y
=
P(y=0 \mid x ; \theta)+P(y=
P(y=0∣x;θ)+P(y=
1
∣
x
;
θ
)
=
1
1 \mid x ; \theta)=1
1∣x;θ)=1。
代价函数：
J
(
θ
)
=
1
m
∑
i
=
1
m
Cost
(
h
θ
(
x
(
i
)
)
，
y
(
i
)
)
=
−
1
m
∑
i
=
1
m
[
y
(
i
)
×
log
(
h
θ
(
x
(
i
)
)
)
+
(
1
−
y
(
i
)
)
×
log
(
1
−
h
θ
(
x
(
i
)
)
)
]
J(\theta)=\frac{1}{m} \sum_{i=1}^{m} \operatorname{Cost}\left(h_{\theta}\left(x^{(i)}\right)，y^{(i)}\right)=-\frac{1}{m} \sum_{i=1}^{m}\left[y^{(i)} \times \log \left(h_{\theta}\left(x^{(i)}\right)\right)+\left(1-y^{(i)}\right) \times \log \left(1-h_{\theta}\left(x^{(i)}\right)\right)\right]
J(θ)=m1i=1∑mCost(hθ(x(i))，y(i))=−m1i=1∑m[y(i)×log(hθ(x(i)))+(1−y(i))×log(1−hθ(x(i)))]
梯度下降算法：
Repeat
{
θ
j
:
=
θ
j
−
α
1
m
∑
i
=
1
m
(
h
θ
(
x
(
i
)
)
−
y
(
i
)
)
x
j
(
i
)
}
(Simultaneously update all
θ
j
)
\text { Repeat } \left.\left\{\theta_{j}:=\theta_{j}-\alpha \frac{1}{m} \sum_{i=1}^{m}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)}\right\} \quad \text { (Simultaneously update all } \theta_{j}\right)
Repeat {θj:=θj−αm1i=1∑m(hθ(x(i))−y(i))xj(i)} (Simultaneously update all θj)
3. 神经网络（Neural Networks）
假设函数：
h
θ
(
x
)
=
1
1
+
e
−
θ
T
x
h_{\theta}(x)=\frac{1}{1+e^{-\theta ^{T}x}}
hθ(x)=1+e−θTx1。
大致模型：
上图是一个简易的神经网络，分为3层：输入层、隐含层，输出层。
其中，
x
1
x_{1}
x1 、
x
2
x_{2}
x2 、
x
3
x_{3}
x3 是输入单元（input units），我们将原始数据输入给它们。
a
1
a_{1}
a1 、
a
2
a_{2}
a2 、
a
3
a_{3}
a3 是中间单元，它们负责将数据进行处理，然后呈递到下一层。 最后是输出单元，它负责计算
h
θ
(
x
)
h_{\theta}(x)
hθ(x)。
模型优化：
其中，
a
i
(
j
)
a_{i}^{(j)}
ai(j) 代表第
j
j
j层的第
i
i
i个激活单元。
θ
(
j
)
\theta^{(j)}
θ(j) 代表从第
j
j
j层映射到第
j
+
1
j+1
j+1层时的权重的矩阵，其尺寸为以第
j
+
1
j+1
j+1层的激活单元数量为行数，以第
j
j
j层的激活单元数加一为列数的矩阵。例如，上图所示的神经网络中的尺寸为
3
×
4
3\times4
3×4。
对于上图所示的模型，激活单元和输出分别表达为：
a
1
(
2
)
=
g
(
θ
10
(
1
)
x
0
+
θ
11
(
1
)
x
1
+
θ
12
(
1
)
x
2
+
θ
13
(
1
)
x
3
)
a_{1}^{(2)}=g\left(\theta_{10}^{(1)} x_{0}+\theta_{11}^{(1)} x_{1}+\theta_{12}^{(1)} x_{2}+\theta_{13}^{(1)} x_{3}\right)
a1(2)=g(θ10(1)x0+θ11(1)x1+θ12(1)x2+θ13(1)x3)
a 2 ( 2 ) = g ( θ 20 ( 1 ) x 0 + θ 21 ( 1 ) x 1 + θ 22 ( 1 ) x 2 + θ 23 ( 1 ) x 3 ) a_{2}^{(2)}=g\left(\theta_{20}^{(1)} x_{0}+\theta_{21}^{(1)} x_{1}+\theta_{22}^{(1)} x_{2}+\theta_{23}^{(1)} x_{3}\right) a2(2)=g(θ20(1)x0+θ21(1)x1+θ22(1)x2+θ23(1)x3)
a 3 ( 2 ) = g ( θ 30 ( 1 ) x 0 + θ 31 ( 1 ) x 1 + θ 32 ( 1 ) x 2 + θ 33 ( 1 ) x 3 ) a_{3}^{(2)}=g\left(\theta_{30}^{(1)} x_{0}+\theta_{31}^{(1)} x_{1}+\theta_{32}^{(1)} x_{2}+\theta_{33}^{(1)} x_{3}\right) a3(2)=g(θ30(1)x0+θ31(1)x1+θ32(1)x2+θ33(1)x3)
h θ ( x ) = a 1 ( 3 ) = g ( θ 10 ( 2 ) a 0 ( 2 ) + θ 11 ( 2 ) a 1 ( 2 ) + θ 12 ( 2 ) a 2 ( 2 ) + θ 13 ( 2 ) a 3 ( 2 ) ) h_{\theta}(x)=a_{1}^{(3)}=g\left(\theta_{10}^{(2)} a_{0}^{(2)}+\theta_{11}^{(2)} a_{1}^{(2)}+\theta_{12}^{(2)} a_{2}^{(2)}+\theta_{13}^{(2)} a_{3}^{(2)}\right) hθ(x)=a1(3)=g(θ10(2)a0(2)+θ11(2)a1(2)+θ12(2)a2(2)+θ13(2)a3(2))
我们知道每一个
a
a
a都是由上一层所有的
x
x
x和每一个
x
x
x所对应的
θ
\theta
θ决定的。我们把这样从左到右的算法称为前向传播算法( Forward Propagation)。
把
x
x
x 、
θ
\theta
θ、
a
a
a 分别用矩阵表示：
x
=
[
x
0
x
1
x
2
x
3
]
，
θ
=
[
θ
10
θ
11
θ
12
θ
13
θ
20
θ
21
θ
22
θ
23
θ
30
θ
31
θ
32
θ
33
]
，
a
=
[
a
1
a
2
a
3
]
x=\left[\begin{array}{c} x_{0} \\ x_{1} \\ x_{2} \\ x_{3} \end{array}\right]，\quad \theta=\left[\begin{array}{llll} \theta_{10} & \theta_{11} & \theta_{12} & \theta_{13} \\ \theta_{20} & \theta_{21} & \theta_{22} & \theta_{23} \\ \theta_{30} & \theta_{31} & \theta_{32} & \theta_{33} \end{array}\right]，\quad a=\left[\begin{array}{l} a_{1} \\ a_{2} \\ a_{3} \end{array}\right]
x=⎣⎢⎢⎡x0x1x2x3⎦⎥⎥⎤，θ=⎣⎡θ10θ20θ30θ11θ21θ31θ12θ22θ32θ13θ23θ33⎦⎤，a=⎣⎡a1a2a3⎦⎤
我们可以得到
θ
⋅
x
=
a
∘
\theta \cdot x=a_{\circ}
θ⋅x=a∘
神经网络中的代价函数为：
J
(
Θ
)
=
−
1
m
[
∑
i
=
1
m
∑
k
=
1
k
y
k
(
i
)
log
(
h
Θ
(
x
(
i
)
)
)
k
+
(
1
−
y
k
(
i
)
)
log
(
1
−
(
h
Θ
(
x
(
i
)
)
)
k
)
]
+
λ
2
m
∑
l
=
1
L
−
1
∑
i
=
1
s
l
∑
j
=
1
s
l
+
1
(
Θ
j
i
(
l
)
)
2
J(\Theta)=-\frac{1}{m}\left[\sum_{i=1}^{m} \sum_{k=1}^{k} y_{k}^{(i)} \log \left(h_{\Theta}\left(x^{(i)}\right)\right)_{k}+\left(1-y_{k}^{(i)}\right) \log \left(1-\left(h_{\Theta}\left(x^{(i)}\right)\right)_{k}\right)\right] +\frac{\lambda}{2 m} \sum_{l=1}^{L-1} \sum_{i=1}^{s_{l}} \sum_{j=1}^{s_{l}+1}\left(\Theta_{j i}^{(l)}\right)^{2}
J(Θ)=−m1[i=1∑mk=1∑kyk(i)log(hΘ(x(i)))k+(1−yk(i))log(1−(hΘ(x(i)))k)]+2mλl=1∑L−1i=1∑slj=1∑sl+1(Θji(l))2
其中，
h
θ
(
x
)
∈
R
K
h_{\theta}(x)\in R^{K}
hθ(x)∈RK ，
(
h
θ
(
x
)
)
k
(h_{\theta}(x))_{k}
(hθ(x))k表示第
k
k
k个输出。正则化的那一项需要先排除每一层的
θ
0
\theta_{0}
θ0 后再对每一层的
θ
\theta
θ 矩阵求和。最里层的循环
j
j
j循环所有的行（由
S
l
+
1
S_{l}+1
Sl+1层的激活单元数决定），循环
i
i
i则循环所有的列（由
S
l
S_{l}
Sl层的激活单元数所决定）。
反向传播算法
之前在计算神经网络预测结果的时候我们采用了一种正向传播方法：从神经网络的第一层开始正向一层一层进行计算，直到最后一层。
现在，为了计算代价函数的偏导数
∂
∂
Θ
i
j
(
l
)
J
(
Θ
)
\frac{\partial }{\partial \Theta _{ij}^{(l)}}J(\Theta )
∂Θij(l)∂J(Θ)，我们需要采用一种反向传播算法：首先计算最后一层的误差，然后再一层一层反向求出各层的误差，直到倒数第二层。
通过下图的神经网络模型来说明反向传播算法。
假设我们的训练集只有一个样本
(
x
(
1
)
，
y
(
1
)
)
(x^{(1)}，y^{(1)})
(x(1)，y(1))，我们的神经网络如上图所示是一个四层的神经网络，其中，
K
=
4
K=4
K=4，
S
L
=
4
S_{L}=4
SL=4，
L
=
4
L=4
L=4（
K
K
K表示输出单元的个数，
L
L
L表示神经网络层数，
S
l
S_{l}
Sl 表示第
l
l
l层的单元数即神经元的数量（不包含第
l
l
l层的偏差单元）。
前向传播算法：
a
(
1
)
=
x
z
(
2
)
=
Θ
(
1
)
a
(
1
)
a
(
2
)
=
g
(
z
(
2
)
)
(
add
a
0
(
2
)
)
z
(
3
)
=
Θ
(
2
)
a
(
2
)
a
(
3
)
=
g
(
z
(
3
)
)
(
add
a
0
(
3
)
)
z
(
4
)
=
Θ
(
3
)
a
(
3
)
a
(
4
)
=
g
(
z
(
4
)
)
=
h
Θ
(
x
)
\begin{aligned} a^{(1)} &=x \\ z^{(2)} &=\Theta^{(1)} a^{(1)} & \\ a^{(2)} &=g\left(z^{(2)}\right) &\left(\text { add } a_{0}^{(2)}\right) \\ z^{(3)} &=\Theta^{(2)} a^{(2)} & \\ a^{(3)} &=g\left(z^{(3)}\right) &\left(\text { add } a_{0}^{(3)}\right) \\ z^{(4)} &=\Theta^{(3)} a^{(3)} & \\ a^{(4)} &=g\left(z^{(4)}\right)=h_{\Theta}(x) \end{aligned}
a(1)z(2)a(2)z(3)a(3)z(4)a(4)=x=Θ(1)a(1)=g(z(2))=Θ(2)a(2)=g(z(3))=Θ(3)a(3)=g(z(4))=hΘ(x)( add a0(2))( add a0(3))
反向传播算法：
对于反向传播算法，首先我们定义第
l
l
l层第
j
j
j个结点激活单元的预测值与实际值之间的误差为
δ
j
(
l
)
=
a
j
(
l
)
−
y
j
\delta_{j}^{(l)}=a_{j}^{(l)}-y_{j}
δj(l)=aj(l)−yj，其中
a
j
(
l
)
a_{j}^{(l)}
aj(l)代表第
l
l
l层第
j
j
j个结点的激活值。
我们从最后一层的误差开始计算，可以得到
δ
j
(
4
)
=
a
j
(
4
)
−
y
j
\delta_{j}^{(4)}=a_{j}^{(4)}-y_{j}
δj(4)=aj(4)−yj
当
δ
(
4
)
\delta^{(4)}
δ(4)、
a
(
4
)
a^{(4)}
a(4)、
y
j
y_{j}
yj均为维数相同的向量时，有
δ
(
4
)
=
a
(
4
)
−
y
\delta^{(4)}=a^{(4)}-y
δ(4)=a(4)−y。 我们利用这个误差值来计算前一层的误差：
δ
(
3
)
=
(
Θ
(
3
)
)
T
δ
(
4
)
⋅
g
′
(
z
(
3
)
)
\delta ^{(3)}=(\Theta ^{(3)})^{T}\delta ^{(4)}\cdot g^{'}(z^{(3)})
δ(3)=(Θ(3))Tδ(4)⋅g′(z(3))
其中，
g
′
(
z
(
3
)
)
g^{'}(z^{(3)})
g′(z(3))是
S
S
S形函数的导数，
g
′
(
z
(
3
)
)
=
a
(
3
)
⋅
(
1
−
a
(
3
)
)
g^{'}(z^{(3)})=a^{(3)}\cdot (1-a^{(3)})
g′(z(3))=a(3)⋅(1−a(3))，而
(
Θ
(
3
)
)
T
δ
(
4
)
(\Theta ^{(3)})^{T}\delta ^{(4)}
(Θ(3))Tδ(4)则是权重导致的误差的和。接下来继续计算第二层的误差：
δ
(
2
)
=
(
Θ
(
2
)
)
T
δ
(
3
)
⋅
g
′
(
z
(
2
)
)
\delta ^{(2)}=(\Theta ^{(2)})^{T}\delta ^{(3)}\cdot g^{'}(z^{(2)})
δ(2)=(Θ(2))Tδ(3)⋅g′(z(2))
因为第一层是输入变量，不存在误差，所以在我们有了所有误差的表达式后，便可以计算代价函数的偏导数了。
因此，假设
λ
=
0
\lambda =0
λ=0，即我们不做任何正则化处理时有：
∂
∂
Θ
i
j
(
l
)
J
(
Θ
)
=
a
j
(
l
)
δ
i
(
l
+
1
)
\frac{\partial }{\partial \Theta _{ij}^{(l)}}J(\Theta )=a_{j}^{(l)}\delta_{i}^{(l+1)}
∂Θij(l)∂J(Θ)=aj(l)δi(l+1)
其中，
l
l
l代表目前所计算的是第几层；
j
j
j代表目前计算层中的激活单元的下标，也将是下一层的第
j
j
j个输入变量的下标；
i
i
i代表下一层中误差单元的下标，是受到权重矩阵中第
i
i
i行影响的下一层中的误差单元的下标。
综上，训练神经网络前我们需要做什么呢？
- 选择一种网络架构：架构是指神经元之间的连接模式；
- 选择输入单元和输出单元的数量：输入单元的数量为特征的维度，输出单元的数量为类别个数；
- 选择隐藏单元的数量。
训练神经网络的步骤：
- 随机初始化权重；
- 执行前向传播算法，对于该神经网络任意一个输入 x ( i ) x^{(i)} x(i)，计算出对应的 h Θ ( x ( i ) ) h_{\Theta}(x^{(i)}) hΘ(x(i))；
- 通过代码计算出代价函数 J ( Θ ) J(\Theta) J(Θ)；
- 执行反向传播算法来计算出这些偏导数项
∂
∂
Θ
i
j
(
l
)
J
(
Θ
)
\frac{\partial }{\partial \Theta _{ij}^{(l)}}J( \Theta)
∂Θij(l)∂J(Θ)；
使用梯度检验来比较这些已经计算得到的偏导数项，把用反向传播得到的偏导数项值与用数值方法得到的估计值进行比较，然后停用梯度检验代码； - 使用一个优化算法，例如梯度下降算法或者更加高级的优化算法，将这些优化算法和反向传播算法相结合来最小化代价函数 J ( Θ ) J(\Theta) J(Θ)。
对于神经网络来说，代价函数 J ( Θ ) J(\Theta) J(Θ)是一个非凸函数，因此理论上可能停留在局部最小值的位置，代价函数 J ( Θ ) J(\Theta) J(Θ)度量的就是这个神经网络对训练数据的拟合情况。
4. 支持向量机（Support Vector Machines）
Logistic假设函数：
h
θ
(
x
)
=
1
1
+
e
−
θ
T
X
h_{\theta}(x)=\frac{1}{1+e^{-\theta^{T} X}}
hθ(x)=1+e−θTX1
Logistic回归的代价函数为:
J ( θ ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( h θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h θ ( x ( i ) ) ) ] + λ 2 m ∑ j = 1 n θ j 2 J(\theta )=-\frac{1}{m}\sum_{i=1}^{m}[y^{(i)}log(h_{\theta}(x^{(i)}))+(1-y^{(i)})log(1-h_{\theta}(x^{(i)}))]+\frac{\lambda }{2m} \sum_{j=1}^{n} \theta _{j}^{2} J(θ)=−m1i=1∑m[y(i)log(hθ(x(i)))+(1−y(i))log(1−hθ(x(i)))]+2mλj=1∑nθj2
Logistic回归的优化目标为:
min
θ
J
(
θ
)
\min_{\theta}J(\theta )
θminJ(θ)
在SVM中，我们用 c o s t 0 ( z ) cost_{0}(z) cost0(z)来替换 − l o g ( 1 − 1 1 + e − z ) -log(1-\frac{1}{1+e^{-z}}) −log(1−1+e−z1)，用 c o s t 1 ( z ) cost_{1}(z) cost1(z)来替换 − l o g 1 1 + e − z -log\frac{1}{1+e^{-z}} −log1+e−z1，如下图所示。
对优化目标来说，我们用
cost
0
(
θ
T
x
(
i
)
)
\operatorname{cost}_{0}\left(\theta^{T} x^{(i)}\right)
cost0(θTx(i)) 来替换
−
log
(
1
−
h
θ
(
x
(
i
)
)
)
-\log \left(1-h_{\theta}\left(x^{(i)}\right)\right)
−log(1−hθ(x(i)))，用
cost
1
(
θ
T
x
(
i
)
)
\operatorname{cost}_{1}\left(\theta^{T} x^{(i)}\right)
cost1(θTx(i)) 来替换
−
log
(
h
θ
(
x
(
i
)
)
)
-\log \left(h_{\theta}\left(x^{(i)}\right)\right)
−log(hθ(x(i)))，则SVM的优化目标为
min
θ
C
∑
i
=
1
m
[
y
(
i
)
cost
1
(
θ
T
x
(
i
)
)
+
(
1
−
y
(
i
)
)
cost
0
(
θ
T
x
(
i
)
)
]
+
1
2
∑
j
=
1
n
θ
j
2
\min _{\theta} C \sum_{i=1}^{m}\left[y^{(i)} \operatorname{cost}_{1}\left(\theta^{T} x^{(i)}\right)+\left(1-y^{(i)}\right) \operatorname{cost}_{0}\left(\theta^{T} x^{(i)}\right)\right]+\frac{1}{2} \sum_{j=1}^{n} \theta_{j}^{2}
θminCi=1∑m[y(i)cost1(θTx(i))+(1−y(i))cost0(θTx(i))]+21j=1∑nθj2
其中，
C
C
C 控制着对误差分类的惩罚力度，
C
C
C 越大， SVM越努力地试图将训练样本全部正确分类。 Logistic回归的代价函数可以写为
A
+
λ
B
A+\lambda B
A+λB 的形式，若
λ
\lambda
λ 非常大，意味着
B
B
B 的权重很大。而SVM的 代价函数可以写为
C
A
+
B
CA+B
CA+B 的形式，对应于Logistic回归的代价函数形式，
C
=
1
λ
C=\frac{1}{\lambda}
C=λ1，若
C
C
C 非常小，相应的
B
B
B 有更大权重。 SVM的假设函数为
h
θ
(
x
)
=
{
1
if
θ
T
x
⩾
0
0
otherwise
h_{\theta}(x)=\left\{\begin{array}{ll} 1 & \text { if } \theta^{T} x \geqslant 0 \\ 0 & \text { otherwise } \end{array}\right.
hθ(x)={10 if θTx⩾0 otherwise
有别于Logistic回归输出的概率，最小化支持向量机的代价函数获得参数
θ
\theta
θ 时，支持向量机所做的 是直接预测
y
y
y 的值等于1还是等于0。如果
θ
T
x
⩾
0
\theta^{T}x \geqslant 0
θTx⩾0，假设函数就会输出1，反之会输出0，所以学习参数
θ
\theta
θ 就是支持向量机的假设函数形式。
谈到支持向量机，不得不提一下核函数。
在吴恩达老师的课程中，对核函数是这样解释的：
对于下图的非线性数据集，可以通过构造一个复杂的多项式模型来解决无法用直线进行分隔的分类问题。
为了获得上图所示的决策边界，我们的模型可能是
h
θ
(
x
)
=
θ
0
+
θ
1
x
1
+
θ
2
x
2
+
θ
3
x
1
x
2
+
θ
4
x
1
2
+
θ
5
x
2
2
+
…
h_{\theta}(x)=\theta_{0}+\theta_{1} x_{1}+\theta_{2} x_{2}+\theta_{3} x_{1} x_{2}+\theta_{4} x_{1}^{2}+\theta_{5} x_{2}^{2}+\ldots
hθ(x)=θ0+θ1x1+θ2x2+θ3x1x2+θ4x12+θ5x22+… 的形式。接下来我们用一系列新的特征
f
f
f 来替换模型中的每一项。例如令
f
1
=
x
1
f_{1}=x_{1}
f1=x1
f
2
=
x
2
，
f
3
=
x
1
x
2
，
f
4
=
x
1
2
，
f
5
=
x
2
2
，
…
f_{2}=x_{2}，f_{3}=x_{1} x_{2}，f_{4}=x_{1}^{2}，f_{5}=x_{2}^{2}，\ldots
f2=x2，f3=x1x2，f4=x12，f5=x22，…，得到
h
θ
(
x
)
=
θ
0
+
θ
1
f
1
+
θ
2
f
2
+
θ
3
f
3
+
θ
4
f
4
+
θ
5
f
5
+
…
h_{\theta}(x)=\theta_{0}+\theta_{1} f_{1}+\theta_{2} f_{2}+\theta_{3} f_{3}+\theta_{4} f_{4}+\theta_{5} f_{5}+\ldots
hθ(x)=θ0+θ1f1+θ2f2+θ3f3+θ4f4+θ5f5+… 那么除了对原有的特征进行组合以外，有没有更好的方法来构造特征
f
1
，
f
2
f_{1}，f_{2}
f1，f2，
f
3
f_{3}
f3 ?
我们可以利用核函数来计算出新的特征。 给定一个训练样本
x
x
x，我们利用
x
x
x 的各个特征与我们预先选定的地标(landmarks)
l
(
1
)
，
l
(
2
)
，
l
(
3
)
l^{(1)}，l^{(2)}，l^{(3)}
l(1)，l(2)，l(3) 的 近似程度来选取新的特征
f
1
，
f
2
，
f
3
f_{1}，f_{2}，f_{3}
f1，f2，f3，如下图所示。
例如，
f
1
=
similarity
(
x
，
l
(
1
)
)
=
e
(
−
∥
x
−
l
(
1
)
∥
2
2
σ
2
)
f
2
=
similarity
(
x
，
l
(
2
)
)
=
e
(
−
∥
x
−
l
2
)
∥
2
2
σ
2
)
f
3
=
similarity
(
x
，
l
(
3
)
)
=
e
(
−
∥
x
−
l
3
)
∥
2
2
σ
2
)
f_{1}=\operatorname{similarity}\left(x，l^{(1)}\right)=e\left(-\frac{\left\|x-l^{(1)}\right\|^{2}}{2 \sigma^{2}}\right) \\ f_{2}=\operatorname{similarity}\left(x，l^{(2)}\right) =e\left(-\frac{\left\|x-l^{2)}\right\|^{2}}{2 \sigma^{2}}\right) \\ f_{3}=\operatorname{similarity}\left(x，l^{(3)}\right) =e\left(-\frac{ \left.\| x-l^{3}\right) \|^{2}}{2 \sigma^{2}}\right)
f1=similarity(x，l(1))=e(−2σ2∥∥x−l(1)∥∥2)f2=similarity(x，l(2))=e(−2σ2∥∥x−l2)∥∥2)f3=similarity(x，l(3))=e(−2σ2∥x−l3)∥2)
其中， ∥ x − l ( 1 ) ∥ 2 = ∑ j = 1 n ( x j − l j ( 1 ) ) 2 \left\|x-l^{(1)}\right\|^{2}=\sum_{j=1}^{n}\left(x_{j}-l_{j}^{(1)}\right)^{2} ∥∥x−l(1)∥∥2=∑j=1n(xj−lj(1))2 为实例中所有特征与地标之间的距离的和，similarity ( x ， l ( 1 ) ) \left(x，l^{(1)}\right) (x，l(1)) 是核函数，具体而言是一个高斯核函数(Gaussian Kernel)。
通过课后查找资料，我了解到了以下内容：
核函数：是映射关系
ϕ
(
x
)
\phi(x)
ϕ(x)的内积，映射函数本身仅仅是一种映射关系，并没有增加维度的特性，不过可以利用核函数的特性，构造可以增加维度的核函数，这通常是我们希望的。
下面是李航的《统计学习方法》中对于核函数的定义：
要注意，核函数和映射没有关系。核函数只是用来计算映射到高维空间之后的内积的一种简便方法。
二、无监督学习（Unsupervised learning）
在无监督学习中，我们需要将一系列无标签的训练数据输入到一个算法中，然后通过实现算法为我们找到训练数据的内在结构。将无标签数据集划分成一系列点集（称为簇）。能够划分这些点集的算法，就被称为聚类算法。
1. K-means算法
K-均值算法是一种迭代求解的聚类分析算法，算法接受一个未标记的数据集，然后将数据聚类成不同的组。其步骤是，预将数据分为K组，则随机选取K个对象作为初始的聚类中心，然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。
K-均值算法会做两件事：1. 簇分配；2. 移动聚类中心。
假设有一个无标签的数据集，想将其分为两个簇，执行K均值算法。如下图所示，首先随机生成两点，这两点称为聚类中心，然后根距离移动聚类中心，直至中心点不再变化为止。
如何初始化K-均值聚类算法？如何使算法避开局部最优？
随机初始化：
上式中循环次数
i
i
i 设为100，一般取50-1000之间，应该选择
K
<
m
K<m
K<m。如果
K
=
2
−
10
K=2-10
K=2−10，一般可得到比较好的局部最优解；如果
K
K
K比较大（比10大很大），那么多次随机初始化对聚类结果不会有太大的改善。
局部最优指的是代价函数（畸变函数）
J
J
J 的局部最优。为了避免这个问题，我们可以尝试多次随机初始化，初始化K-均值算法很多次，并运行K-均值算法很多次，以此来保证我们最后能得到一个足够好的结果，一个尽可能好的局部或全局最优值。
如何选择聚类数
最好的选择聚类数的方法，通常是根据不同的问题，人工进行选择，选择能最好服务于聚类目的的数量。但是也可以应用肘部法则（Elbow method）：
大部分时候，聚类数量K仍是通过手动、人工输入或者经验来决定，一种可以尝试的方法是使用“肘部原则”，但不能期望它每次都有效果。选择聚类数量更好的思路是去问自己运行K-均值聚类算法的目的是什么，然后再想聚类数目K取哪一个值能更好的服务于后续的目的。
2. PCA主成分分析
PCA算法的应用领域：
- 压缩：减少存储数据所需的存储器或硬盘空间；加速学习算法。
- 可视化。
PCA 从 n 维减少到 k 维的步骤：
- 均值归一化。我们需要计算出所有特征的均值 μ j = 1 m ∑ i = 1 m x j ( i ) \mu_{j}=\frac{1}{m} \sum_{i=1}^{m} x_{j}^{(i)} μj=m1∑i=1mxj(i)，然后令 x j = x j − μ j x_{j}=x_{j}-\mu_{j} xj=xj−μj 。如果特征是在不同的数量级上，我们还需要将其除以标准差 S j S_{j} Sj，令 x j = x j − μ j S j x_{j}=\frac{x_{j}-\mu_{j}}{S_{j}} xj=Sjxj−μj 。
- 计算协方差矩阵（covariance matrix) : Σ = 1 m ∑ i = 1 m ( x ( i ) ) ( x ( i ) ) T \Sigma=\frac{1}{m} \sum_{i=1}^{m}\left(x^{(i)}\right)\left(x^{(i)}\right)^{T} Σ=m1∑i=1m(x(i))(x(i))T 。
- 计算协方差矩阵的特征向量（eigenvectors)：利用奇异值分解来求解， [ u ， s ， v ] = [\mathrm{u}，\mathrm{s}，\mathrm{v}]= [u，s，v]= svd(sigma); 。 其中， U = [ ∣ ∣ ∣ u ( 1 ) u ( 2 ) ⋯ u ( m ) ∣ ∣ ∣ ] ∈ R n × n U=\left[\begin{array}{lccc}\mid & \mid & & \mid \\ u^{(1)} & u^{(2)} & \cdots & u^{(m)} \\ \mid & \mid & & \mid\end{array}\right] \in R^{n \times n} U=⎣⎡∣u(1)∣∣u(2)∣⋯∣u(m)∣⎦⎤∈Rn×n，获取矩阵U的前 k \mathrm{k} k 列得到 U reduce = [ ∣ ∣ ∣ u ( 1 ) u ( 2 ) ⋯ u ( k ) ∣ ∣ ∣ ] ∈ R n × k U_{\text {reduce }}= \left[\begin{array}{cccc}\mid & \mid & & \mid \\ u^{(1)} & u^{(2)} & \cdots & u^{(k)} \\ \mid & \mid & & \mid\end{array}\right] \in R^{n \times k} Ureduce =⎣⎡∣u(1)∣∣u(2)∣⋯∣u(k)∣⎦⎤∈Rn×k，然后通过 z ( i ) = U reduce T ∗ x ( i ) z^{(i)}=U_{\text {reduce }}^{T} * x^{(i)} z(i)=Ureduce T∗x(i) 计算获得要求的新特征向量 z ( i ) ∈ R k × 1 z^{(i)} \in R^{k \times 1} z(i)∈Rk×1 。
重建压缩表示：对于给定的
z
(
i
)
z^{(i)}
z(i)，怎么回到原来的表示
x
(
i
)
x^{(i)}
x(i)？
总结： 将 n 维降维至 k 维：
z
(
i
)
=
U
r
e
d
u
c
e
T
⋅
x
(
i
)
z^{(i)}=U_{reduce}^{T} \cdot x^{(i)}
z(i)=UreduceT⋅x(i)；
将 k 维重建至 n 维：
x
a
p
p
r
o
x
≈
U
r
e
d
u
c
e
⋅
z
x_{approx}\approx U_{reduce}\cdot z
xapprox≈Ureduce⋅z。
三、具体应用实例
这一节吴老师列举了一些简单的机器学习应用，让我们对机器学习的用途有一个基本的认识。
1. 手写数字识别
问题描述：使用机器学习算法识别图片中的数字。下面的每个数字都是一张20×20像素的图片，我们将其视为20*20=400个特征进行前馈神经网络的建模和训练。
应用算法：神经网络
2. 人脸图像压缩
问题描述：使用PCA主成分分析算法压缩图像。下面的每个头像都是一张32×32像素的图片，我们对其进行数据标准化和PCA算法进而压缩图像大小。
应用算法：特征缩放、PCA
原图像如下：
特征标准化后：
使用PCA算法后：
3. 异常检测（Anomaly detection）
问题描述：通过高斯分布的特性，根据交叉验证集确定最优的概率密度阈值对训练集数据进行异常值检测。
应用算法：多维高斯分布
异常检测结果：
4. 推荐系统
问题描述：将协同过滤算法应用于1682部电影，943个人的数据集上进行训练，确定用户的参数向量以及为电影的特征向量，然后录入自己的电影评分数据，通过模型得到所推荐电影的评分结果。
应用算法：协同过滤算法
5. 大规模机器学习
对于数据量特别大的模型训练过程，我们有两大法宝：1. 随机梯度下降 2.减少映射。
-
随机梯度下降
随机梯度下降跟批量梯度下降不同之处在于，随机梯度下降不需要对全部 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个训练集都遍历一遍。 -
映射化简
如果任何学习算法能够表达为对训练集的函数的求和，那么便能将这个任务分配给多台计算机（或者同一台计算机的不同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_{j}^{(1)}=\sum_{i=1}^{100}\left(h_{\theta}\left(x^{(i)}\right)-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 ( 1 ) = ∑ i = 101 200 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp_{j}^{(1)}=\sum_{i=101}^{200}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)} tempj(1)=∑i=101200(hθ(x(i))−y(i))xj(i) |
| 3 | 201-300 | t e m p j ( 1 ) = ∑ i = 201 300 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp_{j}^{(1)}=\sum_{i=201}^{300}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)} tempj(1)=∑i=201300(hθ(x(i))−y(i))xj(i) |
| 4 | 301-400 | t e m p j ( 1 ) = ∑ i = 301 400 ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) temp_{j}^{(1)}=\sum_{i=301}^{400}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right) x_{j}^{(i)} tempj(1)=∑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倍的计算效率。
6. 图片OCR
OCR（Optical Character Recognition）指的是光学字符识别，图片OCR系统能够自动识别图片中的文字，具体的流程如下：
- step1：给定某张图像，将图像扫描一遍，找出图像中的文字信息，进行文字检测（Text detection）；
- step2：重点关注这些文字区域，并对区域内文字内容进行识别。对文字区域的矩形轮廓进行字符分割（character segmention），试着将其分割成独立的字符；
- step3：在成功将字段分割成独立字符后，运行一个分类器，输入这些可识别的字符进行字符识别（character recognition），识别出字母分别是什么。
四、建立机器学习系统的建议
1. 偏差（bias）与方差（variance）的识别
偏差：Bias反映的是模型在样本上的输出与真实值之间的误差，即模型本身的精准度，即算法本身的拟合能力。
方差：Variance反映的是模型每一次输出结果与模型输出期望之间的误差，即模型的稳定性。反应预测的波动情况。
2. 正则化（Regularization）
正则化指的是在代价函数中加入有关θ的惩罚项，θ出现的目的是抑制某些特征的作用，纠正过拟合。
3. 特征缩放（Feature scaling）
数据的归一化和标准化是特征缩放(feature scaling)的方法，是数据预处理的关键步骤。
虽然存在决策树和随机森林这种少数不需要特征缩放的机器学习算法，但是对于大部分机器学习算法和优化算法来说，如果特征都在同一范围内,会获得更好的结果。
归一化（Normalization）
归一化是为了消除不同数据之间的量纲，方便数据比较和共同处理。换言之，将数据映射到指定的范围之内(通常映射到[0，1]或者[-1，1]之间)
公式如下：
线性比例变换法:
y
i
=
x
i
max
(
x
)
y_{i}=\frac{x_{i}}{\max (x)}
yi=max(x)xi
极差变换法:
y
i
=
x
i
−
min
(
x
)
max
(
x
)
−
min
(
x
)
y_{i}=\frac{x_{i}-\min (x)}{\max (x)-\min (x)}
yi=max(x)−min(x)xi−min(x)
特征如下：
- 把数据变为（0,1）之间的小数，主要是为了方便数据处理，因为将数据映射到0~1范围之内，可以使处理过程更加便捷、快速。
- 把有量纲表达式变换为无量纲表达式，成为纯量。经过归一化处理的数据，处于同一数量级，可以消除指标之间量纲和量纲单位的影响，提高不同数据指标之间的可比性。
- 主要算法：线性转换，即min-max归一化（常用方法 y=(x-min)/(max-min)
标准化（Standardization）
标准化（Standarlization）是为了方便数据的下一步处理，而进行的数据缩放等变换。就是将数据缩放到以0为中心，标准差为1。
标准化后的特征形式服从正态分布，这样学习权重参数更容易。此外，标准化后的数据保持异常值中的有用信息，使得算法对异常值不太敏感，这一点归一化就无法保证。
标准化的公式如下:
4. 决定下一步做什么（next to do）
“高偏差”指的是“欠拟合”，而“高方差”指的是“过拟合”，两者均指的是无法很好的泛化（generalize)新样本。
当一个机器学习系统建立后，我们接下来该如何进行优化，有哪些可以简单而有效地提高算法精度？首先，我们需要检测出算法是否处于高偏差还是高方差状态。接着，可以按照以下的方法进行优化：
| 高偏差 | 高方差 |
|---|---|
| 1.尝试更多的特征 | 1.尝试更少的特征（人工或者PCA之类的算法） |
| 2.尝试增加 h θ ( x ) h_θ(x) hθ(x)的特征多项式 | 2.获得更多样本来训练。（请结合学习曲线来确定 |
| 3.尝试减少正则项的λ | 3.尝试正则化或者增加正则项的λ（注意均值归一化（mean normalization）和特征缩放（feature scaling）） |
5. 学习算法的评估（assess）
据算法的预测结果和实际结果出现的不同情况， 我们分成以下四种：
1. 真阳性（True Positive,TP）：预测为真，实际为真；
2. 真阴性（True Negative,TN）：预测为假，实际为假 ；
3. 假阳性（False Positive ,FP）：预测为真，实际为假 ；
4. 假阴性（False Negative,FN）：预测为假，实际为真。
查准率：真正预测准确的数量 / 预测是准确的数量。公式为：查准率(Precision)=
T
P
T
P
+
F
P
\frac{TP}{TP+FP}
TP+FPTP。
查全率：真正预测准确的数量 / 所有真正准确的数量。公式为：查全率(Recall)=
T
P
T
P
+
F
N
\frac{TP}{TP+FN}
TP+FNTP。
与此同时，我们有一个帮助我们选择阈值的方法——计算F1值（F1 Score），其计算公式为： F 1 S c o r e = 2 P R P + R F1\ _{} \ _{}Score=2\frac{PR}{P+R} F1 Score=2P+RPR 。其中，P为查准率，R为查全率。F1值会综合考虑查准率和查全率，它结合了查准率和查全率，并且在实际应用中，F1值越高代表模型拟合效果越好 。
6. 学习曲线（learning curve）
学习曲线是一个很好的工具，它可以判断某一个学习算法是否处于偏差、方差问题。学习曲线就是将训练集误差和交叉验证集误差作为训练集样本数量
m
m
m的函数绘制的图表，如下图所示。
下图绘制出了不同训练集样本数量对应的学习曲线。
当训练较少数据的时候，训练的模型将能够非常完美地适应较少的训练数据，但是训练出来的模型却不能很好地适应交叉验证集数据或测试集数据。
如何利用学习曲线识别高偏差/欠拟合？我们尝试用一条直线
h
θ
(
x
)
=
θ
0
+
θ
1
x
h_{\theta}(x)=\theta_{0}+\theta_{1}x
hθ(x)=θ0+θ1x来适应训练集数据，从下图可以看出无论训练集有多么大，误差都不会有太大改观。
结论：在高偏差/欠拟合的情况下，增加数据到训练集不一定能有帮助。
如何利用学习曲线识别高方差/过拟合？我们使用一个非常高次的多项式模型 h θ ( x ) = θ 0 + θ 1 x + . . . + θ 100 x 100 h_{\theta}(x)=\theta_{0}+\theta_{1}x+...+\theta_{100}x^{100} hθ(x)=θ0+θ1x+...+θ100x100，并且正则化非常小，从下图可以看出当交叉验证集误差远大于训练集误差时，往训练集增加更多数据可以提高模型的效果。
结论：在高方差/过拟合的情况下，增加更多数据到训练集可能可以提高算法效果。
7. 误差分析（Error analysis）
误差分析在吴老师这节课中指的是，在建立一个机器学习系统过程中，我们利用CV集对算法进行调参、优化，然而总有些样本会使算法出错。这时，我们应该找出这类样本，并统一地分析它们，看能够通过什么方式帮助算法正确运行。
8. 上限分析（Ceiling analysis）
上限分析指的是在一个机器学习系统流水线（pipeline）中，例如图片OCR的流水线如下，针对流水线的每个模块进行分析，找出这个系统中的短板进行优化。