【机器学习】最大熵模型实现

---

数据准备

最大熵模型可以应用于多类别分类，因此这里直接使用原手写识别mnist十类的数据；即 https://github.com/phdsky/ML/tree/master/data 中的 mnist.csv。

---

最大熵模型推导

书上的公式看起来有点杂乱，这里简要列一下最大熵模型公式的推导过程：
我错了，重新看了一遍，书上的推导和证明写的很清楚。

书上推导和证明中的重要概念：

• 最大熵模型学习的目标是用最大熵原理在训练数据中选择最好的模型，倾向认为在未确定的事件概率是等价的。

• 特征函数/指示函数 指示了输入 $x$ 和输出 $y$ 之间存在的一种关系；这里的 $x$ 和 $y$ 是一一对应的，也就是说它与其他分类器不同的是：最大熵模型中的 $f(x,y)$ 中的 $x$ 是单独的一个特征，不是一个 $n$ 维特征向量，因此我们需要对每个维度特征加一个区分标签，如 $X=(x_0,x_1,x_2,...x_n)$ 改写为 $X=(0-x_0,1-x_1,2-x_2,...n-x_n)$，表示 $x$ 维度取值与输出 $y$ 之间的一种关系，$X$ 在本例中指代一个样本的784维数据。
  $$f(x,y)=\{\begin{array}{rl}& 1，x与y满足某种关系\\ & 0，否则\end{array}$$

• 下面引入两个重要的期望，它们之间的关系构成了最大熵模型的约束条件：
  特征函数 $f(x,y)$ 关于经验分布 $\tilde{P}(X,Y)$ 的期望 $E_{\tilde{p}}(f_i)$：
  $$E_{\tilde{p}}(f_i)=\sum _{x,y}\tilde{P}(x,y)f(x,y)$$
  特征函数 $f(x,y)$ 关于模型 $P(Y|X)$ 与经验分布 $\tilde{P}(X)$ 的期望 $E_p(f_i)$：
  $$E_p(f_i)=\sum _{x,y}\tilde{P}(x)P(y|x)f(x,y)$$
  如果模型能从训练数据中学习到东西，那么就可以假定上面两者的期望相等；这样就构成了模型的约束条件，如果特征函数有多个就有多个约束条件。

• 最大熵模型的定义，就是在上面约束条件下：
  $$C\equiv \left\{P\in \mathcal{P}|E_p(f_i)=E_{\tilde{p}}(f_i)，i=1,2,...,n\right\}$$
  使得定义在条件概率分布 $P(Y|X)$ 上的条件熵最大的模型最大：
  $$H(P)=-\sum _{x,y}\tilde{P}(x)P(y|x)\log P(y|x)$$

• 上式可以转述表达为如下式子：
  $$\underset{P\in C}{\max }H(P)=-\sum _{x,y}\tilde{P}(x)P(y|x)\log P(y|x)$$
  $$\begin{array}{rl}s.t.& E_p(f_i)=E_{\tilde{p}}(f_i)，i=1,2,...,n\\ & \sum _{y}P(y|x)=1\end{array}$$

• 引出上述式子后，则可以构建拉格朗日函数并利用对偶性对其进行求解（6.14 ~ 6.25）；同时可以证得（6.26 ~ 6.27）：最大熵模型学习中的对偶函数极大化 等价于 最大熵模型的极大似然估计。

• 由于上述步骤中最大熵的学习问题已经转化成了求解对数似然函数极大化或对偶函数极大化的问题；根据上一步陈述可以进一步将学习问题转换为对模型进行极大似然估计或正则化的极大似然估计。由此可以将最大熵模型写成如下更一般的形式：

最大熵模型为：
$$\begin{array}{rl}P(y|x)& =\frac{1}{Z_w(x)}exp⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩\\ & =\frac{exp⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩}{\sum _y⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩}\end{array}$$

其中：
$$Z_w(x)=\sum _y⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩$$

极大似然函数为：
$$L(w)=\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _x\tilde{P}(x)\log Z_w(x)$$

通过极大似然估计学习模型参数，求得对数似然函数的极大值 $\hat{w}$ ，代入模型表达式则得到最大熵模型。

逻辑斯蒂回归模型、最大熵模型学习归结为以似然函数为目标函数的最优化问题，通常通过迭代算法进行求解，从最优化的观点来看，此时的目标函数具有很好的性质，它是光滑的凸函数，因此必有全局最优解；上述表达式可以用很多方法来求解，常用的方法有改进迭代尺度法、梯度下降法、牛顿法或拟牛顿法。牛顿法或拟牛顿法一般收敛速度比较快。

---

改进迭代尺度IIS算法

改进迭代尺度算法思想比较简单：

书上通过引入 $f^{♯}(x,y)={\sum }_i{f}_i(x,y)=M$ ，证得每次参数更新时，似然函数增长有一个下紧确界，因此必然能够求得函数的最优解；具体证明在（6.30 ~ 6.33）

下图是改进迭代尺度IIS的算法流程，也是后面要实现的算法：

看懂了模型推导和证明，然后看上面IIS的步骤，第一次的时候还是有点懵比，所以刚开始写了一下算法要求的变量和要实现的式子（令稿些许潦草），下图左边是要求的变量，右边是要实现的式子：

实现过程中：

• 每一次迭代通过样本计算 $\delta$，然后通过 $w=w+\delta$ 更新模型参数；迭代每步所要做的就是求出每次的 $\delta$ 值；下列表示实现的反向递推公式：

$$\begin{array}{rl}{\delta }_i& =\frac{1}{M}\log \frac{E_{\tilde{p}}(f_i)}{E_p(f_i)}\\ & =\frac{1}{M}\log \frac{{\sum }_{x,y}\tilde{P}(x,y)f(x,y)}{{\sum }_{x,y}\tilde{P}(x)P(y|x)f(x,y)}\end{array}\text{\hspace{1em}(1)}$$

$$\{\begin{array}{rl}{E}_{\tilde{p}}(f_i)& =\sum _{x,y}\tilde{P}(x,y)f(x,y)\\ E_p(f_i)& =\sum _{x,y}\tilde{P}(x)P(y|x)f(x,y)\end{array}\text{\hspace{1em}(2)}$$

$$\begin{array}{rl}P(y|x)& =\frac{1}{Z_w(x)}exp⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩\\ & =\frac{exp⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩}{\sum _y⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩}\end{array}\text{\hspace{1em}(3)}$$

$$Z_w(x)=\sum _y⟨\sum _{i=1}^n{w}_i{f}_i(x,y)⟩\text{\hspace{1em}(4)}$$

• 指示函数这个概念在实现的时候如何正确认识比较重要，其实就是 0，1，结合相关的式子一起使用，哪些量满足条件应该加到函数里哪些不满足不应该加到函数里；
• 在最大熵模型中，样本特征每一维都视作一个输入变量，这也是指示函数形式所表现的，因此需要对样本特征进行重构；在下面最大熵的定义中也可以看到，这里的 $X\in \mathcal{X}\subseteq R^n$ 与其他章节里的定义是不一样的：
  • 比如：决策树中的特征向量 $x_i=(x_1^{(1)},x_2^{(2)},...,x_n^{(n)})$、SVM 中的特征向量（实例） $x_i\in \mathcal{X}=R^n$，都是 $(x_i\in R^n,y_i)$构成一个样本；
  • 最大熵的 $X$ 是 $n$ 维变量，它的每一维 $x_1$，$x_2$，…，$x_n$ 与相应的 $y_i$，即$(x_i,y_i)$ 构成了训练样本。

代码实现如下：

# @Author: phd
# @Date: 2019/8/19
# @Site: github.com/phdsky
# @Description: NULL

import time
import logging
import numpy as np
import pandas as pd

from collections import defaultdict
from sklearn.model_selection import train_test_split


def log(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        ret = func(*args, **kwargs)

        end_time = time.time()
        logging.debug('%s() cost %s seconds' % (func.__name__, end_time - start_time))

        return ret
    return wrapper


def calc_accuracy(y_pred, y_truth):
    assert len(y_pred) == len(y_truth)
    n = len(y_pred)

    hit_count = 0
    for i in range(0, n):
        if y_pred[i] == y_truth[i]:
            hit_count += 1

    print("Predicting accuracy %f" % (hit_count / n))


class maxEnt(object):

    def init_params(self, X_train, y_train):
        assert(len(X_train) == len(y_train))

        self.labels = set()
        self.cal_Vxy(X_train, y_train)

        self.N = len(X_train)  # Training set number
        self.n = len(self.Vxy)  # Feature counts
        self.M = 10000.0  # A constant value depends on training set
        self.iter = 500

        self.build_dict()
        self.cal_Pxy()  # Equals to Ep~fi

    def cal_Vxy(self, X_train, y_train):
        # defaultdict: Do not need to judge whether key is in dict or not
        self.Vxy = defaultdict(int)

        # Count the V(X=x, Y=y) feature counts in all samples
        for i in range(0, len(y_train)):
            sample = X_train[i]
            label = y_train[i]

            self.labels.add(label)
            for feature in sample:
                self.Vxy[(feature, label)] += 1

    def build_dict(self):
        # self.Vxy:  key: (x, y)  <---->  value: feature counts
        # Use id key to index

        self.id2xy = {}
        self.xy2id = {}

        for id, xy in enumerate(self.Vxy):
            self.id2xy[id] = xy
            self.xy2id[xy] = id

    def cal_Pxy(self):
        self.Pxy = np.full((self.n, 1), 0.0, dtype=float)

        for id in range(0, self.n):
            xy = self.id2xy[id]
            feature_counts = self.Vxy[xy]

            self.Pxy[id] = feature_counts / float(self.N)

    def cal_Zx(self, sample):
        Zx = defaultdict(float)

        for label in self.labels:
            weights = 0.0
            for feature in sample:
                xy = (feature, label)

                if xy in self.xy2id:
                    id = self.xy2id[xy]
                    weights += self.weight[id]

            Zx[label] = np.exp(weights)

        return Zx

    def cal_Pyx(self, sample):
        Pyx = defaultdict(float)

        Zx = self.cal_Zx(sample)
        Zwx = sum(Zx.values())

        for key in Zx.keys():
            Pyx[key] = Zx[key] / Zwx

        return Pyx

    def cal_Epfi(self, X_train):
        Epfi = np.full((self.n, 1), 0.0, dtype=float)

        for sample in X_train:
            Pyx = self.cal_Pyx(sample)

            for feature in sample:
                for label in Pyx.keys():

                    xy = (feature, label)
                    if xy in self.xy2id:
                        id = self.xy2id[xy]

                        # Calculate P(y|x)*P~(x)f(x, y)
                        # += means every time calculate one to empirical distribution
                        Epfi[id] += Pyx[label] * (1 / self.N)

        return Epfi

    @log
    def train(self, X_train, y_train):
        self.init_params(X_train, y_train)
        self.weight = np.full((self.n, 1), 0.0, dtype=float)

        for it in range(0, self.iter):
            print("Iteration number: %d" % it)
            Epfi = self.cal_Epfi(X_train)

            delta = 1 / self.M * np.log(self.Pxy / Epfi)
            self.weight += delta

    @log
    def predict(self, X_test):
        n = len(X_test)
        predict_label = np.full(n, -1)

        for i in range(0, n):
            to_predict = X_test[i]
            Pyx = self.cal_Pyx(to_predict)
            max_prob = max(zip(Pyx.values(), Pyx.keys()))
            predict_label[i] = max_prob[-1]

        return predict_label


def rebuid_features(subsets):
    features = []
    for sample in subsets:
        feature = []
        for index, value in enumerate(sample):
            feature.append(str(index) + '_' + str(value))
        features.append(feature)
    return features


if __name__ == "__main__":
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)

    mnist_data = pd.read_csv("../data/mnist.csv")
    mnist_values = mnist_data.values

    sample_num = 5000
    images = mnist_values[:sample_num, 1::]
    labels = mnist_values[:sample_num, 0]

    X_train, X_test, y_train, y_test = train_test_split(
        images, labels, test_size=0.33, random_state=42
    )

    X_train = rebuid_features(subsets=X_train)
    X_test = rebuid_features(subsets=X_test)

    max_ent = maxEnt()

    print("Training max entropy model...")
    max_ent.train(X_train=X_train, y_train=y_train)
    print("Training done...")

    print("Testing on %d samples..." % len(X_test))
    y_predicted = max_ent.predict(X_test=X_test)

    calc_accuracy(y_pred=y_predicted, y_truth=y_test)

代码输出结果：

/Users/phd/Softwares/anaconda3/bin/python /Users/phd/Desktop/ML/maxEnt/maxEnt.py
Training max entropy model...
Iteration number: 0
Iteration number: 1
Iteration number: 2
Iteration number: 3
Iteration number: 4
... 中间略过
Iteration number: 499
Training done...
Testing on 1650 samples...
DEBUG:root:train() cost 53459.26920700073 seconds
DEBUG:root:predict() cost 19.44344210624695 seconds
Predicting accuracy 0.822424

Process finished with exit code 0

从结果可以看到，仅仅使用了5000*0.66个样本训练就训练了将近15个小时。。。虽然算法准确率还可以，但是太费时间了，由此推之最大熵模型对于高维数据不太实用；另外代码能写成向量计算的就写成向量形式吧，不然算得更慢。

---

总结

基本上都在模型推导一节了

---

参考

1. 《统计学习方法》