深入浅出EM算法

EM（Expectation Maximization）算法主要用来估计含隐变量的模型参数。

我们先讲解EM算法的一般推导，然后列出EM算法的两个特例，k-Means和高斯混合模型。
参考资料：
http://www.cnblogs.com/jerrylead/archive/2011/04/06/2006936.html
这个链接讲的很详细，我只是复述总结一下，再解决一些遗留问题。
在讲EM之前，我们先谈谈Jensen不等式这个东西

Jensen不等式

回顾凸函数的定义，假设
$(1 - a)f(x_1) + af(x_2) \geq f((1 - a)x_1 + ax_2)$
对任意的$a \in [0, 1]$和任意的在定义域内的$x_1, x_2$都成立，那么$f(x)$是一个凸函数。
Jensen不等式实际上是凸函数定义的形式上的推广
如果$f(x)$是一个凸函数，那么有
Eq. 1
$E[f(x)] \geq f(E[x])$

这个实际上也是由凸函数的定义来的，一张图表明Eq. 1的物理意义：

定理1：如果$f(x)$是严格凸的，那么$E[f(x)] = f(E[x])$的充要条件是$x = E[x]$，也就是说$x$是一个常量。

ok，说完了Jensen不等式，我们开始讲解EM算法。

EM算法原理

含隐变量模型的对数似然：
$l(\theta)$
$= \sum_{i = 1}^n log \text{ } P(x; \theta)$ —– (1)
$= \sum_{i = 1}^n log \text{ } \sum_{j = 1}^k P(x, z_j; \theta)$ —– (2)
$= \sum_{i = 1}^n log \text{ } \sum_{j = 1}^k P(z_j)\frac{P(x, z_j; \theta)}{P(z_j)}$ —– (3)
$\geq \sum_{i = 1}^n \sum_{j = 1}^k P(z_j)log \text{ } \frac{P(x, z_j; \theta)}{P(z_j)}$ —–(4)
这里$z_j$是隐变量，比如在聚类方法中，$z_j$可能是类别属性，也可能是其他隐变量。其中，
第(1)步到第(2)步：联合概率之和等于边缘概率，概率学基础知识。
第(2)步到第(3)步：分子分母乘一个相等的数，小学知识，其中$P(z_j)$表示$z_j$的概率质量函数，而且$\sum_{i = 1}^k P(z_i) = 1$。
第(3)步到第(4)步：Jensen不等式。在这里：
$\sum_{j = 1}^k P(z_j)\frac{P(x, z_j; \theta)}{P(z_j)} = E[\frac{P(x, z_j; \theta)}{P(z_j)}]$， 概率统计知识，
$f(\cdot) = log(\cdot)$。
由于对数函数是一个凹函数，因此由$f(E[x]) \geq E[f(x)]$可得（注意到，这里符号反的）
$f(E[\frac{P(x, z_j; \theta)}{P(z_j)}]) = log \text{ } \sum_{j = 1}^k P(z_j)\frac{P(x, z_j; \theta)}{P(z_j)} \geq$
$E[f(\frac{P(x, z_j; \theta)}{P(z_j)})] = \sum_{j = 1}^k P(z_j)log \text{ } \frac{P(x, z_j; \theta)}{P(z_j)}$

我们看到，实际上$E[f(x)]$是$l(\theta)$的下界，因为我们要极大化$l(\theta)$。因此我们需要使得$E[f(x)]$极大，从而逼近$l(\theta)$。根据定理1，由于$log(\cdot)$是严格凹的，因此$l(\theta) \geq \sum_{i = 1}^n \sum_{j = 1}^k P(z_j)log \text{ } \frac{P(x, z_j; \theta)}{P(z_j)}$中的等式成立当且仅当$\frac{P(x, z; \theta)}{P(z)}$是一个常量，不妨令

$\frac{P(x, z_j; \theta)}{P(z_j)} = c, j = 1,\dots, k$

那么，由于$\sum P(z_j) = 1$，因此$\sum_{j = 1}^k P(x, z_j; \theta) = c$，所以
$P(z_j) = \frac{P(x, z_j; \theta)}{c} = \frac{P(x, z_j; \theta)}{\sum_{j = 1}^k P(x, z_j; \theta)} = \frac{P(x, z_j; \theta)}{P(x; \theta)} = P(z_j | x; \theta)$。

这样，我们就通过极大化下界使得其逼近$l(\theta)$，这也就是EM算法中的E步，其实本质上就是计算$z_j$的后验概率。

在EM算法中的M步里面，因为已经给定了$P(z_j)$，所以M步直接极大化$\theta$的对数似然:
Eq. 2
$\theta^* := argmax_{\theta} \sum_{i = 1}^n \sum_{j = 1}^k P(z_j)log \text{ } \frac{P(x, z_j; \theta)}{P(z_j)}$.

所以，我们可以给出EM算法的通用形式：

Randomly initialize theta
while (unconvergence) do
    for j from 1 to k do
        P(z_j) := P(z_j | x; theta)
    update theta according to Eq. 2

我们可以定义
$J(\theta, P(z)) = \sum_{i = 1}^n \sum_{j = 1}^k P(z_j)log \text{ } \frac{P(x_i, z_j; \theta)}{P(z_j)}$
EM算法可以看成是对函数$J$的坐标上升，即先固定$\theta$，求$J$关于$P(z)$的极大；然后固定$P(z)$，求$J$关于$\theta$的极大。

k-Means

作为EM算法的特例，k-Means是必须要讲的。

k-Means算法的流程如下：

1. Initialize $k$ centroids $\mu_1, \dots, \mu_k \in R^n$ randomly.
2. Repeat follow steps until convergence
   3. for each $x_i$ do $c_i := argmin_{1 \leq j \leq k} ||x_i - \mu_j||^2$
   4. for each $\mu_j$ do $\mu_j := \frac{\sum_{i = 1}^n\mathbf{1}\{c_i = j\} x_i}{\sum_{i = 1}^n \mathbf{1}\{c_i = j\}}$

这里$J(\mu, c) = \sum_{i = 1}^n ||x_i - \mu_{c_i}||^2$，所以我们可以认为k-Means是对函数$J$的坐标上升。这里$J$不是凸函数，因此可能得到局部最优解。

高斯混合模型—GMM

高斯混合模型的基本假设是观测数据由多个不同参数的高斯分布所生成。因此假设观测数据为$(x_1, \dots, x_n), x_i \in R^m$，那么
$P(x; \theta)$
$= \sum_{i = 1}^k \alpha_i \mathcal N(x | \mu_i, \Sigma_i)$
$= \sum_{i = 1}^k \alpha_i [\frac{1}{|\Sigma_i|^{\frac{1}{2}} (2\pi)^{\frac{m}{2}}}e^{-\frac{1}{2}(x - \mu_i)^T\Sigma_i^{-1}(x - \mu_i)}]$

其中，$\sum \alpha_i = 1$。在这里，我们自然而然的想到，利用MLE估计参数
$\theta = (\alpha_1, \mu_1, \Sigma_1; \dots; \alpha_k, \mu_k, \Sigma_k)$
那么对数似然并使其极大化：
$max \text{ } l(\theta) = max \text{ } \sum_{i = 1}^n log P(x_i; \theta)$
$s.t. \sum_{i = 1}^k \alpha_i = 1, \alpha_i \geq 0, i = 1, \dots, k$
这篇文章https://blog.csdn.net/xmu_jupiter/article/details/50889023提到说上式不好求解，因为求偏导麻烦，这很麻烦吗？根据链式法则不是很好求吗？我们来求解一下：
$\nabla_{\alpha_i}l = \sum_{i = 1}^n \frac{\frac{1}{|\Sigma_i|^{\frac{1}{2}} (2\pi)^{\frac{m}{2}}}e^{-\frac{1}{2}(x_i - \mu_i)^T\Sigma_i^{-1}(x_i - \mu_i)}}{P(x_i; \theta)}$

$\nabla_{\mu_i}l = \sum_{i = 1}^n \frac{\frac{\alpha_i}{|\Sigma_i|^{\frac{1}{2}} (2\pi)^{\frac{m}{2}}}e^{-\frac{1}{2}(x - \mu_i)^T\Sigma_i^{-1}(x_i - \mu_i)} \Sigma_i^{-1}(x_i - \mu_i) }{P(x_i; \theta)}$
为简单起见，假设变量间相互独立，那么$\Sigma_i = diag(\sigma_{i1}^2, \sigma_{i2}^2, \dots, \sigma_{im}^2)$是一个对角阵，
显然有$|\Sigma_i|^{\frac{1}{2}} = \sigma_{i1}\sigma_{i2}\dots\sigma_{im}$
令$g(\Sigma_i) = \frac{\alpha_i}{|\Sigma_i|^{\frac{1}{2}} (2\pi)^{\frac{m}{2}}}=\alpha_i(2\pi)^{-\frac{m}{2}}\prod_{l = 1}^m\sigma_{il}^{-1}, h(\Sigma_i) = e^{-\frac{1}{2}(x - \mu_i)^T\Sigma_i^{-1}(x - \mu_i)}$.
涉及到矩阵行列式及逆矩阵对变量求导，推导可得：
$\frac{\partial g}{\partial \sigma_{ij}} = -\alpha_i (2\pi)^{-\frac{m}{2}}(\prod_{l = 1}^m \sigma_{il})^{-1}\sigma_{ij}^{-1}$
$\frac{\partial h}{\partial \sigma_{ij}} = e^{-\frac{1}{2}(x - \mu_i)^T\Sigma_i^{-1}(x - \mu_i)}(x^j - \mu_i^j)^2\sigma_{ij}^{-3}$
$\nabla_{\sigma_{ij}} l = \sum_{i = 1}^n \frac{\frac{\partial g}{\partial \sigma_{ij}}h + \frac{\partial h}{\partial \sigma_{ij}}g}{P(x_i; \theta)}$。

利用坐标上升的方法可得到参数的迭代更新公式：

Randomly initialize theta
while (unconvergence) do
for i from 1 to k do
$\alpha_i^{(j + 1)} := \alpha_i^{(j)} + \lambda\nabla_{\alpha_i}l$
for l from 1 to m do
$\mu_{il}^{(j + 1)} := \mu_i^{(j)} + \lambda\nabla_{\mu_{il}}l$
$\sigma_{il}^{(j + 1)} := \sigma_i^{(j)} + \lambda\nabla_{\sigma_{il}}l$
endforl
endfori
// Normalize $\alpha$ to satisfy constraint.
normalize $\alpha_i^{(j + 1)} := \frac{\alpha_i^{(j + 1)}}{\sum_{i = 1}^k \alpha_i^{(j + 1)}}$ for each i from 1 to k
endwhile
从理论上来说，我觉得这样求解没问题，那么从实际实现来看又会如何呢？

用Python实现了Gaussian混合模型的坐标上升方法的代码：

#!/usr/local/bin/python3
# -*- coding: utf-8 -*-

from sklearn.datasets.samples_generator import make_blobs
import numpy as np
from operator import mul
import math
from functools import reduce
from pandas import DataFrame
from matplotlib import pyplot as plt


def norm_distribution_value(x, mu, sigma):
    k, d = np.shape(mu)
    t_normalizations = np.zeros(k)
    for i in range(k):
        t_normalizations[i] = math.exp(-0.5 * sum(
            (x[j] - mu[i, j])**2 / sigma[i, j]**2 for j in range(d)))
        t_normalizations[i] /= (reduce(mul, sigma[i]) * (2 * math.pi)**(d / 2))
    return t_normalizations


def gradient_alpha(X, alpha_old, mu, sigma):
    k = len(alpha_old)  # How many gaussian distributions
    n, d = np.shape(X)  # The data shape
    grad_alpha = np.zeros(k)
    for x in X:
        t_value = norm_distribution_value(x, mu, sigma)
        p = sum(alpha_old * t_value)
        #print("ok", p)
        if np.all(t_value / p == t_value / p):
            grad_alpha += t_value / p
    return grad_alpha


def gradient_mu(X, alpha, mu_old, sigma):
    k = len(alpha)  # How many gaussian distributions
    n, d = np.shape(X)  # The data shape
    grad_mu = np.zeros(np.shape(mu_old))
    for x in X:
        t_value = norm_distribution_value(x, mu_old, sigma)
        for i in range(k):
            t_re = alpha[i] * t_value[i] * \
                (x - mu_old[i]) / (sigma[i]**2) / sum(t_value * alpha)
            if np.all(t_re == t_re):
                grad_mu[i] +=  t_re
    return grad_mu

def gradient_sigma(X, alpha, mu, sigma_old):
    k = len(alpha)  # How many gaussian distributions
    n, d = np.shape(X)  # The data shape
    grad_sigma = np.zeros(np.shape(sigma_old))
    for x in X:
        t_value = norm_distribution_value(x, mu, sigma_old)
        for i in range(k):
            g = alpha[i] / (2 * math.pi)**(d / 2) / (reduce(mul, sigma_old[i]))
            g_grad = -g / sigma_old[i]
            h = math.exp(-0.5 * sum(
                (x[j] - mu[i, j])**2 / sigma_old[i, j]**2 for j in range(d)))
            h_grad = h * (x - mu[i])**2 / sigma_old[i]**3
            t_re = (h * g_grad + g * h_grad) / sum(alpha * t_value)
            if np.all(t_re == t_re):
                grad_sigma[i] += t_re
    return grad_sigma

def gaussian_mixture_model_gradient_ascent(X, k=3, learn_rate=0.1):
    # Initialize
    n, d = np.shape(X)
    alpha = np.random.random_sample(k)
    mu = np.random.random_sample((k, d))
    sigma = np.random.random_sample((k, d))
    alpha = alpha / sum(alpha)  # Normalization
    ite_num = 0
    while ite_num < 100:
        alpha += learn_rate * gradient_alpha(X, alpha, mu, sigma)
        alpha = alpha / sum(alpha)
        print(alpha)
        mu += learn_rate * gradient_mu(X, alpha, mu, sigma)
        print(mu)
        sigma += learn_rate * gradient_sigma(X, alpha, mu, sigma)
        print(sigma)
        ite_num += 1
        print('iteration: ', ite_num)
    return alpha, mu, sigma

def gaussian_cluster(x, alpha, mu, sigma):
    k = len(alpha)
    d = len(x)
    p = np.zeros(k)
    for i in range(k):
        p[i] = alpha[i] / reduce(mul, sigma[i]) * math.exp(-0.5 * sum(
            (x[j] - mu[i, j])**2 / sigma[i, j]**2 for j in range(d)))
    return np.argmax(p)


X, y = make_blobs(n_samples=100, centers=2, n_features=2)
alpha, mu, sigma = gaussian_mixture_model_gradient_ascent(X,k=2)

p_y = np.zeros(len(X))
for i in range(len(X)):
    p_y[i] = gaussian_cluster(X[i], alpha, mu, sigma)

df = DataFrame(dict(x1=X[:, 0], x2=X[:, 1], label=p_y))
df.to_csv('gaussianTestData.csv')
colors = {0: 'red', 1: 'blue'}
fig, ax = plt.subplots()

grouped = df.groupby('label')
for key, group in grouped:
    group.plot(ax=ax, kind='scatter', x='x1',
               y='x2', label=key, color=colors[key])
plt.show()

发现只有在极少部分情况下，才能收敛到一个全局最优解。这是因为优化目标并不是一个凸函数，参数个数也比较多。因此很大程度上坐标上升无法保证得到一个较为满意的结果。