公式输入请参考:
在线Latex公式
Hidden Markov Model(HMM)介绍
既可以看做判别模型,也可以看做生成模型。
例子:丢硬币
不能免俗,讲下丢硬币的例子,现在有两个硬币A和B,它们出现正面的概率分别是
μ
1
,
μ
2
\mu_1,\mu_2
μ 1 , μ 2 现在有一个叫小明的人丢硬币,而我只能看到丢的结果,不知道丢的是A还是B。 针对这个描述,我们现在有几个问题: 问题1(inference/decody问题):通过观测到的正反面,小明丢硬币的序列是什么? 问题2(parameter estimate问题):
μ
1
,
μ
2
\mu_1,\mu_2
μ 1 , μ 2 分别是什么?也就是丢了A后,丢A的概率是多少?丢B的概率是多少?丢了B后,丢A的概率是多少?丢B的概率是多少? 表示起来就是一个矩阵(transition matrix) 问题三:如果计算某个观测序列出现的边界概率?例如:P(正反正正反)(通常是用DP来解决)
例子:Part of Speech Tagging(POS)略
问题一:维特比解决 问题二:EM解决
Parameters of HMM
隐变量
z
i
z_i
z i 是离散型的,也就是它的隐状态是有限的,例如丢硬币的例子中隐状态是A或B,在语义分析中的隐状态词性也是有限的。假设其隐状态有m个(m: # of states) 观测变量
x
i
x_i
x i 可以是离散的(例如抛硬币),也可以是连续的(例如语音识别中的语音信号)。 HMM的参数
θ
=
(
A
,
B
,
π
)
\theta=(A,B,\pi)
θ = ( A , B , π ) ,每一个参数如下:
A
A
A 为转移矩阵transition probability/matrix,
A
i
j
A_{ij}
A i j 是状态
z
i
z_i
z i 到下一个时态转化为
z
j
z_j
z j 的概率,矩阵大小是m×m。
B
B
B 是emission probability/matrix,就是生成概率矩阵,就在状态
z
i
z_i
z i 的情况下,生成观测变量
x
i
x_i
x i 的概率,例如丢硬币的例子中,当用硬币A有2/3的几率是正面,1/3的几率是反面。矩阵大小是m×V,V为观测变量的取值类型(连续型用GMM来处理)
π
=
[
π
1
,
π
2
,
.
.
.
,
π
m
]
,
π
1
+
π
2
+
.
.
.
+
π
m
=
1
\pi=[\pi_1,\pi_2,...,\pi_m],\pi_1+\pi_2+...+\pi_m=1
π = [ π 1 , π 2 , . . . , π m ] , π 1 + π 2 + . . . + π m = 1 ,这里是每个隐变量出现在第一个位置的概率。 问题1:给定
θ
,
x
\theta,x
θ , x 估计
z
z
z 问题2:给定
x
x
x inference
θ
\theta
θ
问题1
Naive Approach
最笨的方法,适合用于隐变量状态较少的情况,把所有可能生出观察变量的排列组合全部列举出来,然后计算似然概率,取最大值。
三个可能性,序列长度是10,那么可能性就是
3
10
3^{10}
3 1 0
Viterbi
使用维特比算法的一个前提是,某个状态只和它前后的状态有关,与其他状态无关。 上图的
z
i
z_i
z i 是隐变量,
1
∼
m
1\sim m
1 ∼ m 是隐变量可以的取值状态,我们是想通过已知条件
θ
,
x
\theta,x
θ , x 来估计
z
i
z_i
z i 通俗的说就是
z
1
z_1
z 1 取
1
∼
m
1\sim m
1 ∼ m 的某一个状态,
z
2
z_2
z 2 取
1
∼
m
1\sim m
1 ∼ m 的某一个状态,.。。。 连起来就是上面的折线。
z
1
z_1
z 1 取2的概率
p
(
z
1
=
2
)
p(z_1=2)
p ( z 1 = 2 ) 是参数
π
\pi
π 决定的,另外还有一个因素要从
z
1
=
2
z_1=2
z 1 = 2 的状态生成观测变量
x
1
x_1
x 1 ,因此数学表达就是:
p
(
z
1
=
2
)
p
(
x
1
∣
z
1
=
2
)
p(z_1=2)p(x_1|z_1=2)
p ( z 1 = 2 ) p ( x 1 ∣ z 1 = 2 ) 对于
z
2
z_2
z 2 来说,它要在
z
1
=
2
z_1=2
z 1 = 2 条件下进行计算:
p
(
z
2
=
1
∣
z
1
=
2
)
p
(
x
2
∣
z
2
=
1
)
p(z_2=1|z_1=2)p(x_2|z_2=1)
p ( z 2 = 1 ∣ z 1 = 2 ) p ( x 2 ∣ z 2 = 1 ) 以此类推,那么整根折线的概率就是把上面的概率连乘:
p
(
z
1
=
2
)
p
(
x
1
∣
z
1
=
2
)
p
(
z
2
=
1
∣
z
1
=
2
)
p
(
x
2
∣
z
2
=
1
)
.
.
.
p(z_1=2)p(x_1|z_1=2)p(z_2=1|z_1=2)p(x_2|z_2=1)...
p ( z 1 = 2 ) p ( x 1 ∣ z 1 = 2 ) p ( z 2 = 1 ∣ z 1 = 2 ) p ( x 2 ∣ z 2 = 1 ) . . . 概率越高越好。但是可以看到这个折线的组合是有很多种的,接下来看如何用DP来简化。 假设第
k
k
k 时刻,最好的概率(最优路径)是
δ
k
(
i
)
\delta_k(i)
δ k ( i ) ,这个状态取值是
i
i
i 那么第
k
+
1
k+1
k + 1 时刻,最好的路径是前一个状态乘上第
k
+
1
k+1
k + 1 时刻的概率,这里我们用log来把连乘转换为连加,由于上一个状态的取值可能是1~i,所以我们要取一个最大值:
δ
k
+
1
(
j
)
=
m
a
x
{
δ
k
(
1
)
+
l
o
g
p
(
z
k
+
1
=
j
∣
z
k
=
1
)
+
l
o
g
p
(
x
k
+
1
∣
z
k
+
1
=
j
)
δ
k
(
2
)
+
l
o
g
p
(
z
k
+
1
=
j
∣
z
k
=
2
)
+
l
o
g
p
(
x
k
+
1
∣
z
k
+
1
=
j
)
⋮
δ
k
(
m
)
+
l
o
g
p
(
z
k
+
1
=
j
∣
z
k
=
m
)
+
l
o
g
p
(
x
k
+
1
∣
z
k
+
1
=
j
)
\delta_{k+1}(j)=max\begin{cases} &\delta_k(1)+logp(z_{k+1}=j|z_k=1) +logp(x_{k+1}|z_{k+1}=j)\\ & \delta_k(2)+logp(z_{k+1}=j|z_k=2) +logp(x_{k+1}|z_{k+1}=j) \\ &\vdots\\ & \delta_k(m)+logp(z_{k+1}=j|z_k=m) +logp(x_{k+1}|z_{k+1}=j) \end{cases}
δ k + 1 ( j ) = m a x ⎩ ⎪ ⎪ ⎪ ⎪ ⎨ ⎪ ⎪ ⎪ ⎪ ⎧ δ k ( 1 ) + l o g p ( z k + 1 = j ∣ z k = 1 ) + l o g p ( x k + 1 ∣ z k + 1 = j ) δ k ( 2 ) + l o g p ( z k + 1 = j ∣ z k = 2 ) + l o g p ( x k + 1 ∣ z k + 1 = j ) ⋮ δ k ( m ) + l o g p ( z k + 1 = j ∣ z k = m ) + l o g p ( x k + 1 ∣ z k + 1 = j ) 上式可以简化为:
δ
k
+
1
(
j
)
=
m
a
x
i
[
δ
k
(
i
)
+
l
o
g
p
(
z
k
+
1
=
j
∣
z
k
=
i
)
+
l
o
g
p
(
x
k
+
1
∣
z
k
+
1
=
j
]
\delta_{k+1}(j)=\underset{i}{max}[\delta_k(i)+logp(z_{k+1}=j|z_k=i)+logp(x_{k+1}|z_{k+1}=j]
δ k + 1 ( j ) = i ma x [ δ k ( i ) + l o g p ( z k + 1 = j ∣ z k = i ) + l o g p ( x k + 1 ∣ z k + 1 = j ] 可以看到,每次计算都可以确定出前一个时刻到当前时刻的最佳路径,这样从第一个时刻开始一次向后计算,并把路径结果保存下来就可以求出第k个时刻的最佳路径。
问题2:Forward/Backward Algorithm
这个算法是用来估计:
p
(
z
k
∣
x
)
p(z_k|x)
p ( z k ∣ x ) ,这个概率可以拆分为: Forward Algorithm:计算联合概率:
p
(
z
k
,
x
1
:
k
)
p(z_k,x_{1:k})
p ( z k , x 1 : k ) Backward Algorithm:计算条件概率:
p
(
x
(
k
+
1
)
:
n
∣
z
k
)
p(x_{(k+1):n}|z_k)
p ( x ( k + 1 ) : n ∣ z k ) 为什么能这样拆分?
p
(
z
k
∣
x
)
=
p
(
z
k
,
x
)
p
(
x
)
∝
p
(
z
k
,
x
)
p(z_k|x)=\cfrac{p(z_k,x)}{p(x)}\propto p(z_k,x)
p ( z k ∣ x ) = p ( x ) p ( z k , x ) ∝ p ( z k , x ) 下面这个怎么来的?不太清楚。。。。
p
(
z
k
,
x
)
=
p
(
x
(
k
+
1
)
:
n
∣
z
k
,
x
1
:
k
)
p
(
z
k
,
x
1
:
k
)
p(z_k,x)=p(x_{(k+1):n}|z_k,x_{1:k})p(z_k,x_{1:k})
p ( z k , x ) = p ( x ( k + 1 ) : n ∣ z k , x 1 : k ) p ( z k , x 1 : k ) 由于
x
1
:
k
x_{1:k}
x 1 : k 和
x
(
k
+
1
)
:
n
x_{(k+1):n}
x ( k + 1 ) : n 都是独立于
z
k
z_k
z k 的,根据D-seperate定理,
x
(
k
+
1
)
:
n
x_{(k+1):n}
x ( k + 1 ) : n 可以去掉:
p
(
z
k
,
x
)
=
p
(
x
(
k
+
1
)
:
n
∣
z
k
)
p
(
z
k
,
x
1
:
k
)
p(z_k,x)=p(x_{(k+1):n}|z_k)p(z_k,x_{1:k})
p ( z k , x ) = p ( x ( k + 1 ) : n ∣ z k ) p ( z k , x 1 : k ) 可以看到,前面一项是Backward Algorithm,后面一项是Forward Algorithm 但是由于
p
(
z
k
,
x
)
p(z_k,x)
p ( z k , x ) 与
p
(
z
k
∣
x
)
p(z_k|x)
p ( z k ∣ x ) 不是相等,而是正比关系而已,所以在计算的时候要用归一化处理一下,例如:
p
(
z
1
∣
x
)
=
p
(
z
1
,
x
)
∑
j
p
(
z
k
=
j
,
x
)
p(z_1|x)=\cfrac{p(z_1,x)}{\sum_{j}p(z_k=j,x)}
p ( z 1 ∣ x ) = ∑ j p ( z k = j , x ) p ( z 1 , x )
Forward Algorithm
算法目标是求:
p
(
z
k
,
x
1
:
k
)
p(z_k,x_{1:k})
p ( z k , x 1 : k ) ,记作:
α
k
(
z
k
)
\alpha_k(z_k)
α k ( z k ) 也是利用动态规划的思想来解决这个问题:
p
(
z
k
,
x
1
:
k
)
=
∑
z
k
−
1
p
(
z
k
−
1
,
z
k
,
x
1
:
k
)
p(z_k,x_{1:k})=\sum_{z_{k-1}}p(z_{k-1},z_k,x_{1:k})
p ( z k , x 1 : k ) = z k − 1 ∑ p ( z k − 1 , z k , x 1 : k ) 上式是把
z
k
−
1
z_{k-1}
z k − 1 边缘化(这里没怎么看懂),然后下面进行连乘改造:
p
(
z
k
,
x
1
:
k
)
=
∑
z
k
−
1
p
(
z
k
,
x
1
:
k
)
p
(
z
k
∣
z
k
,
x
1
:
k
)
p
(
x
k
∣
z
k
,
z
k
−
1
,
x
1
:
k
−
1
)
p(z_k,x_{1:k})=\sum_{z_{k-1}}p(z_k,x_{1:k})p(z_k|z_k,x_{1:k})p(x_k|z_k,z_{k-1},x_{1:k-1})
p ( z k , x 1 : k ) = z k − 1 ∑ p ( z k , x 1 : k ) p ( z k ∣ z k , x 1 : k ) p ( x k ∣ z k , z k − 1 , x 1 : k − 1 ) 根据D-seperate定理,去掉条件独立的项。
p
(
z
k
,
x
1
:
k
)
=
∑
z
k
−
1
p
(
z
k
,
x
1
:
k
)
p
(
z
k
∣
z
k
)
p
(
x
k
∣
z
k
)
p(z_k,x_{1:k})=\sum_{z_{k-1}}p(z_k,x_{1:k})p(z_k|z_k)p(x_k|z_k)
p ( z k , x 1 : k ) = z k − 1 ∑ p ( z k , x 1 : k ) p ( z k ∣ z k ) p ( x k ∣ z k ) 以上就是DP的推导,然后初始条件:
p
(
z
1
,
x
1
)
=
p
(
z
1
)
p
(
x
1
∣
z
1
)
p(z_1,x1)=p(z_1)p(x_1|z_1)
p ( z 1 , x 1 ) = p ( z 1 ) p ( x 1 ∣ z 1 )
Backward Algorithm
算法目标是求:
p
(
x
(
k
+
1
)
:
n
∣
z
k
)
p(x_{(k+1):n}|z_k)
p ( x ( k + 1 ) : n ∣ z k ) ,记作:
β
k
(
z
k
)
\beta_k(z_k)
β k ( z k ) 也是利用动态规划的思想来解决这个问题:
p
(
x
(
k
+
1
)
:
n
∣
z
k
)
=
∑
z
k
+
1
p
(
x
(
k
+
1
)
:
n
,
z
k
+
1
∣
z
k
)
=
∑
z
k
+
1
p
(
x
(
k
+
2
)
:
n
∣
z
k
+
1
,
z
k
,
x
k
+
1
)
p
(
x
k
+
1
∣
z
k
+
1
,
z
k
)
p
(
z
k
+
1
∣
z
k
)
=
∑
z
k
+
1
p
(
x
(
k
+
2
)
:
n
∣
z
k
+
1
)
p
(
x
k
+
1
∣
z
k
+
1
)
p
(
z
k
+
1
∣
z
k
)
p(x_{(k+1):n}|z_k)=\sum_{z_{k+1}}p(x_{(k+1):n},z_{k+1}|z_k)\\ =\sum_{z_{k+1}}p(x_{(k+2):n}|z_{k+1},z_k,x_{k+1})p(x_{k+1}|z_{k+1},z_k)p(z_{k+1}|z_k)\\ =\sum_{z_{k+1}}p(x_{(k+2):n}|z_{k+1})p(x_{k+1}|z_{k+1})p(z_{k+1}|z_k)
p ( x ( k + 1 ) : n ∣ z k ) = z k + 1 ∑ p ( x ( k + 1 ) : n , z k + 1 ∣ z k ) = z k + 1 ∑ p ( x ( k + 2 ) : n ∣ z k + 1 , z k , x k + 1 ) p ( x k + 1 ∣ z k + 1 , z k ) p ( z k + 1 ∣ z k ) = z k + 1 ∑ p ( x ( k + 2 ) : n ∣ z k + 1 ) p ( x k + 1 ∣ z k + 1 ) p ( z k + 1 ∣ z k ) 两个算法计算的方向不一样,Forward 是从前向后,Backward 是从后向前。
FB算法估计参数π
假定隐变量只有三个状态:1,2,3 对于第一个序列(这些概率是老师给出来的): 第二个序列: 第三个序列: 把每个状态的概率加起来,得到期望次数: 然后转换为概率:
FB估计参数B
假设隐状态有三个:1,2,3 观测值有三个:a,b,c 要算出灰色的隐状态,每个状态有3个取值,在参数已知的情况下可以估计概率值: 弄好了是这个样子 开始计算矩阵B: 这个1.4(这里老师算错了,应该是1.7,截图不好改,就这样吧)是从下面的绿色圈住的数字加起来得到的,表示从状态1生成a的期望次数之和: 然后把B期望次数转换为概率:
估计A
由于是正比于的关系,不能是直接用,要归一化,把上面的结果记为:
β
k
(
i
,
j
)
\beta_k(i,j)
β k ( i , j ) 因此有:
p
(
z
k
=
1
,
z
k
+
1
=
1
∣
x
)
∝
β
k
(
1
,
1
)
p(z_k=1,z_{k+1}=1|x)\propto \beta_k(1,1)
p ( z k = 1 , z k + 1 = 1 ∣ x ) ∝ β k ( 1 , 1 )
p
(
z
k
=
1
,
z
k
+
1
=
2
∣
x
)
∝
β
k
(
1
,
2
)
p(z_k=1,z_{k+1}=2|x)\propto \beta_k(1,2)
p ( z k = 1 , z k + 1 = 2 ∣ x ) ∝ β k ( 1 , 2 )
p
(
z
k
=
1
,
z
k
+
1
=
3
∣
x
)
∝
β
k
(
1
,
3
)
p(z_k=1,z_{k+1}=3|x)\propto \beta_k(1,3)
p ( z k = 1 , z k + 1 = 3 ∣ x ) ∝ β k ( 1 , 3 )
p
(
z
k
=
2
,
z
k
+
1
=
1
∣
x
)
∝
β
k
(
2
,
1
)
⋮
p(z_k=2,z_{k+1}=1|x)\propto \beta_k(2,1)\\ \vdots
p ( z k = 2 , z k + 1 = 1 ∣ x ) ∝ β k ( 2 , 1 ) ⋮
p
(
z
k
=
3
,
z
k
+
1
=
3
∣
x
)
∝
β
k
(
3
,
3
)
p(z_k=3,z_{k+1}=3|x)\propto \beta_k(3,3)
p ( z k = 3 , z k + 1 = 3 ∣ x ) ∝ β k ( 3 , 3 ) 归一化:
p
(
z
k
=
1
,
z
k
+
1
=
1
∣
x
)
=
β
k
(
1
,
1
)
β
k
(
1
,
1
)
+
β
k
(
1
,
2
)
+
β
k
(
1
,
3
)
+
.
.
.
+
β
k
(
3
,
3
)
p(z_k=1,z_{k+1}=1|x)=\cfrac{ \beta_k(1,1)}{ \beta_k(1,1)+\beta_k(1,2)+\beta_k(1,3)+...+\beta_k(3,3)}
p ( z k = 1 , z k + 1 = 1 ∣ x ) = β k ( 1 , 1 ) + β k ( 1 , 2 ) + β k ( 1 , 3 ) + . . . + β k ( 3 , 3 ) β k ( 1 , 1 ) 以此类推。 下面看A怎么计算 下面看具体例子: 计算矩阵: 这里注意颜色,还有就是最后一个状态不算。 这样就可以把A求出来。
Complete vs Incomplete Case
Complete Case:
(
z
,
x
)
(z,x)
( z , x ) is observable 例如: Incomplete Case:
(
x
)
(x)
( x ) is observable,
z
z
z is unobservable.EM算法来求解
Complete Case示例
可以看到x有三个值:abc,z有三个值:123.都是离散的,现在要估计参数。 估计
π
\pi
π ,从图中可以看到有三个序列:
值
1
2
3
出现次数
2
1
0
π取值
2/3
1/3
0
估计A,根据定义,A是3*3的矩阵,先写出状态转移次数,例如左边矩阵中的第一行第一列的数字代表从状态1转移到状态1的次数一共有2次,第一行第二列的数字代表从状态1转移到状态2的次数一共有1次,以此类推:
[
2
1
2
1
2
1
0
2
1
]
\begin{bmatrix} 2 &1 &2 \\ 1 &2 & 1\\ 0 &2 &1 \end{bmatrix}
⎣ ⎡ 2 1 0 1 2 2 2 1 1 ⎦ ⎤ 然后再计算出概率:
[
2
/
5
1
/
5
2
/
5
1
/
4
2
/
4
1
/
4
0
2
/
3
1
/
3
]
\begin{bmatrix} 2/5 &1/5 &2/5 \\ 1/4 &2/4 &1/4\\ 0 &2/3 &1 /3 \end{bmatrix}
⎣ ⎡ 2 / 5 1 / 4 0 1 / 5 2 / 4 2 / 3 2 / 5 1 / 4 1 / 3 ⎦ ⎤ 同理估计B,先写次数,再写概率:
MLE for Complete and Incomplete Case
用最大似然来求解
θ
\theta
θ Complete Case
l
(
θ
;
D
)
=
log
p
(
x
,
z
∣
θ
)
=
log
p
(
z
∣
θ
z
)
+
log
p
(
x
∣
z
,
θ
x
)
l(\theta;D)=\text{log}p(x,z|\theta)=\text{log}p(z|\theta_z)+\text{log}p(x|z,\theta_x)
l ( θ ; D ) = log p ( x , z ∣ θ ) = log p ( z ∣ θ z ) + log p ( x ∣ z , θ x ) Incomplete Case
l
(
θ
;
D
)
=
log
∑
z
p
(
x
,
z
∣
θ
)
=
log
∑
z
p
(
z
∣
θ
z
)
p
(
x
∣
z
,
θ
x
)
l(\theta;D)=\text{log}\sum_zp(x,z|\theta)=\text{log}\sum_zp(z|\theta_z)p(x|z,\theta_x)
l ( θ ; D ) = log z ∑ p ( x , z ∣ θ ) = log z ∑ p ( z ∣ θ z ) p ( x ∣ z , θ x ) 这里用的累加实际上就是边缘概率,要考虑所有z的可能,比较复杂,所以要引入EM算法来进行求解,第一步是求出z,再把z带入后面一项,求最大似然。
EM推导
θ
\theta
θ :模型参数
x
x
x :观测变量
z
z
z :隐变量 下面用MLE的方式来推导EM,因此按照MLE,写出损失函数:
L
(
θ
)
=
log
p
(
x
∣
θ
)
L(\theta)=\text{log}p(x|\theta)
L ( θ ) = log p ( x ∣ θ ) 目标函数:
a
r
g
m
a
x
L
(
θ
)
=
a
r
g
m
a
x
log
p
(
x
∣
θ
)
argmaxL(\theta)=argmax\text{log}p(x|\theta)
a r g m a x L ( θ ) = a r g m a x log p ( x ∣ θ ) 假设第
n
n
n 次迭代后得到了
θ
n
\theta_n
θ n ,这个参数是已知的。那么我们希望下一步找到的新参数
θ
\theta
θ 与
θ
n
\theta_n
θ n 差距越大越好(这里的下一步的
θ
\theta
θ 其实是
θ
n
+
1
\theta_{n+1}
θ n + 1 ):
a
r
g
m
a
x
θ
(
L
(
θ
)
−
L
(
θ
n
)
)
=
log
p
(
x
∣
θ
)
−
log
p
(
x
∣
θ
n
)
\underset{\theta}{argmax}(L(\theta)-L(\theta_n))=\text{log}p(x|\theta)-\text{log}p(x|\theta_n)
θ a r g ma x ( L ( θ ) − L ( θ n ) ) = log p ( x ∣ θ ) − log p ( x ∣ θ n ) 然后把隐变量考虑进来:
L
(
θ
)
−
L
(
θ
n
)
=
log
∑
z
p
(
x
,
z
∣
θ
)
−
log
p
(
x
∣
θ
n
)
=
log
∑
z
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
−
log
p
(
x
∣
θ
n
)
=
log
∑
z
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
p
(
z
∣
x
,
θ
n
)
p
(
z
∣
x
,
θ
n
)
−
log
p
(
x
∣
θ
n
)
=
log
∑
z
p
(
z
∣
x
,
θ
n
)
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
p
(
z
∣
x
,
θ
n
)
−
log
p
(
x
∣
θ
n
)
L(\theta)-L(\theta_n)=\text{log}\sum_zp(x,z|\theta)-\text{log}p(x|\theta_n)\\ =\text{log}\sum_zp(x|z,\theta)p(z|\theta)-\text{log}p(x|\theta_n)\\ =\text{log}\sum_zp(x|z,\theta)p(z|\theta)\cfrac{p(z|x,\theta_n)}{p(z|x,\theta_n)}-\text{log}p(x|\theta_n)\\ =\text{log}\sum_zp(z|x,\theta_n)\cfrac{p(x|z,\theta)p(z|\theta)}{p(z|x,\theta_n)}-\text{log}p(x|\theta_n)
L ( θ ) − L ( θ n ) = log z ∑ p ( x , z ∣ θ ) − log p ( x ∣ θ n ) = log z ∑ p ( x ∣ z , θ ) p ( z ∣ θ ) − log p ( x ∣ θ n ) = log z ∑ p ( x ∣ z , θ ) p ( z ∣ θ ) p ( z ∣ x , θ n ) p ( z ∣ x , θ n ) − log p ( x ∣ θ n ) = log z ∑ p ( z ∣ x , θ n ) p ( z ∣ x , θ n ) p ( x ∣ z , θ ) p ( z ∣ θ ) − log p ( x ∣ θ n )
根据jensen’s inequality,有 具体证明 当
∑
i
=
1
n
λ
i
=
1
\sum_{i=1}^n\lambda_i=1
∑ i = 1 n λ i = 1 时:
log
∑
i
=
1
n
λ
i
x
i
≥
∑
i
=
1
n
λ
i
log
x
i
\text{log}\sum_{i=1}^n\lambda_ix_i\ge \sum_{i=1}^n\lambda_i\text{log}x_i
log i = 1 ∑ n λ i x i ≥ i = 1 ∑ n λ i log x i 所以上面我们构造了一个类似
λ
i
\lambda_i
λ i 的这么一个项:
p
(
z
∣
x
,
θ
n
)
p(z|x,\theta_n)
p ( z ∣ x , θ n ) ,因为
∑
z
p
(
z
∣
x
,
θ
n
)
=
1
\sum_zp(z|x,\theta_n)=1
∑ z p ( z ∣ x , θ n ) = 1 ,所以:
L
(
θ
)
−
L
(
θ
n
)
≥
∑
z
p
(
z
∣
x
,
θ
n
)
log
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
p
(
z
∣
x
,
θ
n
)
−
log
p
(
x
∣
θ
n
)
L(\theta)-L(\theta_n)\ge \sum_zp(z|x,\theta_n)\text{log}\cfrac{p(x|z,\theta)p(z|\theta)}{p(z|x,\theta_n)}-\text{log}p(x|\theta_n)
L ( θ ) − L ( θ n ) ≥ z ∑ p ( z ∣ x , θ n ) log p ( z ∣ x , θ n ) p ( x ∣ z , θ ) p ( z ∣ θ ) − log p ( x ∣ θ n ) 由于
log
p
(
x
∣
θ
n
)
\text{log}p(x|\theta_n)
log p ( x ∣ θ n ) 和$没有关系,所以
log
p
(
x
∣
θ
n
)
=
1
⋅
log
p
(
x
∣
θ
n
)
=
∑
z
p
(
z
∣
x
,
θ
n
)
⋅
log
p
(
x
∣
θ
n
)
\text{log}p(x|\theta_n)=1\cdot\text{log}p(x|\theta_n)=\sum_zp(z|x,\theta_n)\cdot\text{log}p(x|\theta_n)
log p ( x ∣ θ n ) = 1 ⋅ log p ( x ∣ θ n ) = z ∑ p ( z ∣ x , θ n ) ⋅ log p ( x ∣ θ n ) 上面的不等式就变成:
L
(
θ
)
−
L
(
θ
n
)
≥
∑
z
p
(
z
∣
x
,
θ
n
)
log
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
p
(
z
∣
x
,
θ
n
)
p
(
x
∣
θ
n
)
=
Δ
(
θ
θ
n
)
L(\theta)-L(\theta_n)\ge \sum_zp(z|x,\theta_n)\text{log}\cfrac{p(x|z,\theta)p(z|\theta)}{p(z|x,\theta_n)p(x|\theta_n)}=\Delta(\cfrac{\theta}{\theta_n})
L ( θ ) − L ( θ n ) ≥ z ∑ p ( z ∣ x , θ n ) log p ( z ∣ x , θ n ) p ( x ∣ θ n ) p ( x ∣ z , θ ) p ( z ∣ θ ) = Δ ( θ n θ ) 因此:
L
(
θ
)
−
L
(
θ
n
)
≥
Δ
(
θ
θ
n
)
→
L
(
θ
)
≥
L
(
θ
n
)
+
Δ
(
θ
θ
n
)
L(\theta)-L(\theta_n)\ge\Delta(\cfrac{\theta}{\theta_n})\to L(\theta)\ge L(\theta_n)+\Delta(\cfrac{\theta}{\theta_n})
L ( θ ) − L ( θ n ) ≥ Δ ( θ n θ ) → L ( θ ) ≥ L ( θ n ) + Δ ( θ n θ ) 这样我们就找到了
L
(
θ
)
L(\theta)
L ( θ ) 的下界,求最大值的时候,我们可以不断最大化下界,从而使得
L
(
θ
)
L(\theta)
L ( θ ) 最大化。
a
r
g
m
a
x
θ
[
L
(
θ
n
)
+
Δ
(
θ
θ
n
)
]
=
a
r
g
m
a
x
θ
[
L
(
θ
n
)
+
∑
z
p
(
z
∣
x
,
θ
n
)
log
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
p
(
z
∣
x
,
θ
n
)
p
(
x
∣
θ
n
)
]
\underset{\theta}{argmax}[L(\theta_n)+\Delta(\cfrac{\theta}{\theta_n})]\\ =\underset{\theta}{argmax}[L(\theta_n)+ \sum_zp(z|x,\theta_n)\text{log}\cfrac{p(x|z,\theta)p(z|\theta)}{p(z|x,\theta_n)p(x|\theta_n)}]
θ a r g ma x [ L ( θ n ) + Δ ( θ n θ ) ] = θ a r g ma x [ L ( θ n ) + z ∑ p ( z ∣ x , θ n ) log p ( z ∣ x , θ n ) p ( x ∣ θ n ) p ( x ∣ z , θ ) p ( z ∣ θ ) ] 这里把和求极值的目标
θ
\theta
θ 无关的东西都去掉,简化:
=
a
r
g
m
a
x
θ
[
∑
z
p
(
z
∣
x
,
θ
n
)
log
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
]
=
a
r
g
m
a
x
θ
[
∑
z
p
(
z
∣
x
,
θ
n
)
log
p
(
x
,
z
∣
θ
)
]
=\underset{\theta}{argmax}[ \sum_zp(z|x,\theta_n)\text{log}p(x|z,\theta)p(z|\theta)]\\ =\underset{\theta}{argmax}[ \sum_zp(z|x,\theta_n)\text{log}p(x,z|\theta)]
= θ a r g ma x [ z ∑ p ( z ∣ x , θ n ) log p ( x ∣ z , θ ) p ( z ∣ θ ) ] = θ a r g ma x [ z ∑ p ( z ∣ x , θ n ) log p ( x , z ∣ θ ) ]
根据概率公式:
p
(
A
B
)
=
p
(
A
,
B
)
=
p
(
A
∣
B
)
P
(
B
)
p(AB)=p(A,B)=p(A|B)P(B)
p ( A B ) = p ( A , B ) = p ( A ∣ B ) P ( B ) 扩展一下:
p
(
A
B
∣
C
)
=
p
(
A
,
B
∣
C
)
=
p
(
A
∣
B
,
C
)
P
(
B
∣
C
)
p(AB|C)=p(A,B|C)=p(A|B,C)P(B|C)
p ( A B ∣ C ) = p ( A , B ∣ C ) = p ( A ∣ B , C ) P ( B ∣ C )
p
(
A
,
B
∣
C
)
p(A,B|C)
p ( A , B ∣ C ) 表示C发生的条件下,AB发生的概率
p
(
A
∣
B
,
C
)
p(A|B,C)
p ( A ∣ B , C ) 表示事件B,事件C都发生的条件下,A发生的概率 所以上式中:
p
(
x
∣
z
,
θ
)
p
(
z
∣
θ
)
=
p
(
x
,
z
∣
θ
)
p(x|z,\theta)p(z|\theta)=p(x,z|\theta)
p ( x ∣ z , θ ) p ( z ∣ θ ) = p ( x , z ∣ θ )
这里的前面一项是一个z的期望值(数学期望概念 ),所以:
=
a
r
g
m
a
x
θ
[
E
z
∣
x
,
θ
n
log
p
(
x
,
z
∣
θ
)
]
=\underset{\theta}{argmax}[E_{z|x,\theta_n}\text{log}p(x,z|\theta)]
= θ a r g ma x [ E z ∣ x , θ n log p ( x , z ∣ θ ) ] 以上就是EM算法的形式,它分两个步骤: 求期望:E-step,求z的期望值,就是求
E
z
∣
x
,
θ
n
E_{z|x,\theta_n}
E z ∣ x , θ n 在
log
p
(
x
,
z
∣
θ
)
\text{log}p(x,z|\theta)
log p ( x , z ∣ θ ) 的条件下的期望。 求极值:M-step,最大化
log
p
(
x
,
z
∣
θ
)
\text{log}p(x,z|\theta)
log p ( x , z ∣ θ ) ,这个时候
z
z
z 是已知的。相当于Complete Case。
EM小结
E-step是求z M-step是求
θ
\theta
θ 1、EM算法不是全局最优解,是局部最优解。通常我们使用不同的初始化,多重复几次,以获得较好效果。 2、EM算是严格递增的,所以EM一定会converge。
K-means
K均值本质上也是属于EM算法的一个特例。大概说一个这个算法的思想: 1、先标记两个点,图2 2、根据这两个点计算距离,分类.图3. 3、根据分类,重新计算分类的中心点。图4.回到步骤2,知道完成收敛。 可以看到K均值算法中,有两个未知的东西: 1、变量
r
n
k
r_{nk}
r n k ,代表一个点属于哪个分类,当
r
n
k
=
1
r_{nk}=1
r n k = 1 代表
x
n
x_n
x n 属于第
k
k
k 个分类,不属于则为0.那么每个样本
x
n
x_n
x n 的分类可以表示为一个k维向量
[
0
,
0
,
.
.
.
,
1
,
.
.
.
0
]
[0,0,...,1,...0]
[ 0 , 0 , . . . , 1 , . . . 0 ] ,属于那一个分类那么就是1,其他的都为0. 2、分类的中心点在什么地方?这个我们可以用
μ
k
\mu_k
μ k 代表k个分类的各自的中心点坐标。 目标函数表示为:
J
=
∑
n
=
1
N
∑
k
=
1
K
r
n
k
∣
∣
x
n
−
μ
k
∣
∣
2
J=\sum_{n=1}^N\sum_{k=1}^Kr_{nk}||x_n-\mu_k||^2
J = n = 1 ∑ N k = 1 ∑ K r n k ∣ ∣ x n − μ k ∣ ∣ 2 这里
r
n
k
r_{nk}
r n k 相当于隐变量。
μ
k
\mu_k
μ k 相当于参数,从EM算法的角度来看 E-STEP计算
r
n
k
r_{nk}
r n k M-STEM计算
μ
k
\mu_k
μ k
MLE for GMM
GMM在李宏毅的课里面有讲过,这里不多展开,上图。 The joint distribution between
x
x
x and
z
z
z (representing color) are
p
(
x
,
z
=
′
r
e
d
′
)
=
N
(
x
∣
μ
1
,
Σ
1
)
p(x,z='red')=N(x|\mu_1,\Sigma_1)
p ( x , z = ′ r e d ′ ) = N ( x ∣ μ 1 , Σ 1 )
p
(
x
,
z
=
′
b
l
u
e
′
)
=
N
(
x
∣
μ
2
,
Σ
2
)
p(x,z='blue')=N(x|\mu_2,\Sigma_2)
p ( x , z = ′ b l u e ′ ) = N ( x ∣ μ 2 , Σ 2 )
p
(
x
,
z
=
′
g
r
e
e
n
′
)
=
N
(
x
∣
μ
3
,
Σ
3
)
p(x,z='green')=N(x|\mu_3,\Sigma_3)
p ( x , z = ′ g r e e n ′ ) = N ( x ∣ μ 3 , Σ 3 ) 在GMM中,每个样本可以用以下数学公式表达:
p
(
x
)
=
∑
k
=
1
K
π
k
N
(
x
∣
μ
k
,
Σ
k
)
p(x)=\sum_{k=1}^K\pi_k N(x|\mu_k,\Sigma_k)
p ( x ) = k = 1 ∑ K π k N ( x ∣ μ k , Σ k )
π
k
\pi_k
π k 是每个分布的权重,属于隐变量
μ
k
,
Σ
k
\mu_k,\Sigma_k
μ k , Σ k 是模型的参数。 可以看到K均值算法就是GMM的一个特例。 每一个点是上面的公式,那么所有的整体就是:
log
p
(
D
∣
π
,
μ
,
Σ
)
=
∑
n
=
1
N
log
{
∑
k
=
1
K
π
k
N
(
x
∣
μ
k
,
Σ
k
)
}
\text{log}p(D|\pi,\mu,\Sigma)=\sum_{n=1}^N\text{log}\{\sum_{k=1}^K\pi_k N(x|\mu_k,\Sigma_k)\}
log p ( D ∣ π , μ , Σ ) = n = 1 ∑ N log { k = 1 ∑ K π k N ( x ∣ μ k , Σ k ) }
HMM vs RNN
HMM的每个状态之间进行转移要用到转移矩阵进行计算,这个和状态维度有关,会变很大 至于优缺点对比可以直接参考分布式表示比独热表示的对比。