最大熵模型

内容源于公众号《简博士数据分析吧》和b站《【合集】十分钟 机器学习 系列视频 《统计学习方法》》
代码来自于https://blog.csdn.net/weixin_41566471/article/details/106319467

最大熵原理

• 在满足约束条件的模型集合中选取熵最大的模型
• 离散：

$$\begin{array}{rl}& \max -\sum _{x}p(x)\log p(x)\\ & s.t.\sum _{x}p(x)=1\end{array}$$
求解结果是服从均匀分布

• 连续：连续随机变量的均值为$\mu$，方差为${\sigma }^2$，求熵最大对应的概率分布:

$$\begin{array}{rl}& \max L=-{\int }_{-\infty }^{\infty }p(x)\log p(x)dx\\ & s.t.\{\begin{array}{l}{\int }_{-\infty }^{\infty }p(x)dx=1\\ {\int }_{-\infty }^{\infty }xp(x)dx=\mu \\ {\int }_{-\infty }^{\infty }(x-\mu {)}^{2}p(x)dx={\sigma }^2\end{array}\end{array}$$
求得模型服从正态分布

最大熵模型的定义

• 将最大熵原理应用到分类就是最大熵模型。给定训练数据集$T=\{(x_1,y_1),...,(x_N,y_N)\}$，目标就是用最大熵原理选择最好的分类模型。
• 数学定义为：

1. 联合分布$P(X,Y)$和边缘分布$P(X)$的经验分布为：

$$\tilde{P}(X=x,Y=y)=\frac{\mathrm{v}(X=x,Y=y)}{N}$$
$$\tilde{P}(X=x)=\frac{\mathrm{v}(X=x)}{N}$$
$\mathrm{v}(X=x,Y=y)$表示训练数据中样本$(x,y)$出现的频数。

2. 特征函数$f(x,y)$

注意：特征函数可以是任意实值函数，不一定是二值函数

3. 特征函数关于经验分布的期望：

$$E_{\tilde{P}}\left(f_i\right)=\sum _{x,y}\tilde{P}(x,y)f_i(x,y)$$

4. 特征函数关于理论分布的期望：

$$\begin{array}{rl}{E}_P\left(f_i\right)& =\sum _{x,y}P(x,y)f_i(x,y)\\ & =\sum _{x,y}P(x)P(y\mid x)f_i(x,y)\\ & =\sum _{x,y}\tilde{P}(x)P(y\mid x)f_i(x,y)\end{array}$$

5. 约束条件：经验分布的期望=理论分布的期望，若有n个特征函数$f_i(x,y),i=1,..,n$，就有n个约束条件。当然，还有一个自然约束条件：概率和为1
6. 目标：最大熵模型实际上是**「判别方法」**，判别方法就是要得出条件概率分布，就是要得出满足 $\max H(P)$ 的$P(Y|X)$。

$$\begin{array}{rl}H(P)& =\sum _{i=1}^{n}p\left(x_i\right)H\left(Y\mid X=x_i\right)\\ & =-\sum _{i=1}^{n}p\left(x_i\right)\sum _{j=1}^{k}p\left(y_j\mid x_i\right)\log p\left(y_j\mid x_i\right)\\ & =-\sum _{i=1}^n\sum _{j=1}^k\tilde{p}\left(x_i\right)p\left(y_j\mid x_i\right)\log p\left(y_j\mid x_i\right)\\ & =-\sum _{x,y}P(x)P(y\mid x)\log P(y\mid x)\end{array}$$

最大熵模型的学习

约束最优化问题

• 最大熵模型的学习可以形式化为最优化问题：

$$\begin{array}{rl}& \underset{P\in C}{\min }-H(P)=\sum _{x,y}P(x)P(y\mid x)\log P(y\mid x)\\ & s.t.\{\begin{array}{l}{E}_P(f_i)=E_P(f_i),i=1,..,n\\ {\sum }_{y}P(y|x)=1\end{array}\end{array}$$

优化问题的原始问题和对偶问题

• 若 $f(x),c_i(x),h_j(x)$ 是连续可微函数。考虑如下有约束的最优化问题：

$$\begin{array}{ll}{\min }_{x\in R^n}& f(x)\\ s.t.& c_i(x)\le 0,i=1,2,\cdots ,k\\ & h_j(x)=0,j=1,2,\cdots ,l\end{array}$$

这就是该有约束最优化问题的原始形式。这样一个优化问题其实计算起来非常的复杂，因为有 k+l 个约束条件。

1. 引进 「广义拉格朗日函数」 ：

$$L(x,\alpha ,\beta )=f(x)+\sum _{i=1}^k{\alpha }_i{c}_i(x)+\sum _{j=1}^l{\beta }_j{h}_j(x){\alpha }_i,{\beta }_j\ge 0$$

2. 「考虑关于x 的函数」:

$${\theta }_P(x)=\underset{\alpha ,\beta }{\max }L(x,\alpha ,\beta )=\{\begin{array}{l}f(x)有约束\\ \infty 无约束\end{array}$$
原始问题的最优值：
$$p^{\ast }=\underset{x}{\min }{\theta }_P(x)=\underset{x}{\min }\underset{\alpha ,\beta }{\max }L(x,\alpha ,\beta )$$

3. 「考虑关于$\alpha ,\beta$** 的函数」*

对偶问题的最优值：
$$d^{\ast }=\underset{\alpha ,\beta }{\max }{\theta }_D(\alpha ,\beta )=\underset{\alpha ,\beta }{\max }\underset{x}{\min }L(x,\alpha ,\beta )$$

4. 原始问题和对偶问题的关系
   1. 广义拉格朗日函数的区间范围

$$\underset{x}{\min }L(x,\alpha ,\beta )\le L(x,\alpha ,\beta )\le \underset{\alpha ,\beta }{\max }L(x,\alpha ,\beta )$$
$$d^{\ast }=\underset{\alpha ,\beta :{\alpha }_i\ge 0}{\max }\underset{x}{\min }L(x,\alpha ,\beta )\le L(x,\alpha ,\beta )\le \underset{x}{\min }\underset{\alpha ,\beta :{\alpha }_i\ge 0}{\max }L(x,\alpha ,\beta )=p^{\ast }$$

2. 令等号相等需满足的条件

该条件等价于KKT条件：
$$\begin{array}{ll}{\nabla }_{x}L\left(x^{\ast },{\alpha }^{\ast },{\beta }^{\ast }\right)=0& \\ {\alpha }_i^{\ast }{c}_i\left(x^{\ast }\right)=0,& i=1,2,\cdots ,k\\ c_i\left(x^{\ast }\right)\le 0,& i=1,2,\cdots ,k\\ {\alpha }_i^{\ast }\ge 0,& i=1,2,\cdots ,k\\ h_j(x\ast )=0,& j=1,2,\cdots ,l\end{array}$$

证明最大熵模型的原始问题是满足上述条件

$f(x)=-H(P)$如果熵函数是严格的凹函数，就要满足：
$$H\left({\lambda }_{1}P+{\lambda }_{2}Q\right)>{\lambda }_{1}H(P)+{\lambda }_{2}H(Q)$$
将熵的表达式代入上式：
$$\begin{array}{rl}& H\left({\lambda }_{1}P+{\lambda }_{2}Q\right)=-\sum _{i=1}^m\left({\lambda }_1{p}_i+{\lambda }_2{q}_i\right)\log \left({\lambda }_1{p}_i+{\lambda }_2{q}_i\right)\\ & {\lambda }_{1}H(P)+{\lambda }_{2}H(Q)=-{\lambda }_1\sum p_i\log p_i-{\lambda }_2\sum q_i\log q_i\end{array}$$
整理可得我们要证的是下式：
$$\sum {\lambda }_1{p}_i\log \frac{{\lambda }_1{p}_i+{\lambda }_2{q}_i}{p_i}+\sum {\lambda }_2{q}_i\log \frac{{\lambda }_1{p}_i+{\lambda }_2{q}_i}{q_i}<0{\lambda }_1+{\lambda }_2=1$$
利用不等式$\log (t)<t-1，t\ne 1$很容易证的。

内部极小化

最大熵模型的原始问题可以通过对偶问题来求解，它的拉格朗日函数为：
$$\begin{array}{rl}L(P,\omega )& =\sum _{x,y}P(x)P(y\mid x)\log P(y\mid x)+{\omega }_0\left(1-\sum _{y}P(y\mid x)\right)\\ & +\sum _{i=1}^n{\omega }_i\left(\sum _{x,y}P(x,y)f_i(x,y)-\sum _{x,y}P(x)P(y\mid x)f_i(x,y)\right)\end{array}$$
其对偶问题为：
$$d^{\ast }=\underset{\omega \ge 0}{\max }{\theta }_D(P)=\underset{\omega \ge 0}{\max }\underset{P\in C}{\min }L(P,\omega )$$
我们先处理${\min }_{x}L(x,\alpha ,\beta )$这一部分.

1. $$\frac{\partial L(P,\omega )}{\partial P(y|x)}=\sum _{x,y}P(x)[\log P(y\mid x)+1]-{\omega }_0-\sum _{i=1}^n{\omega }_i\sum _{x,y}P(x)f_i(x,y)=0$$

得到
$$P(y\mid x)=\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)+{\omega }_0-1\right)=\frac{\exp \left({\sum }_{i=1}^n{w}_i{f}_i(x,y)\right)}{\exp \left(1-{\omega }_0\right)}$$

2. 由${\sum }_{y}P(y|x)=1$，得
   $$\exp \left(1-{\omega }_0\right)=\sum _y\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)\right)$$
3. 将2待人1，我们可以得到条件概率分布

$$P_{\omega }(y|x)=\frac{1}{Z_{\omega }(x)}\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)\right)$$
其中规范化因子
$$Z_{\omega }(x)=\sum _y\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)\right)$$

外部极大化

把3中的$P_w(y|x)$带入到拉格朗日函数中，得外部极大化问题为max 对偶函数：
$$\begin{array}{rl}\max \Psi (\omega )=& \sum _{x,y}P(x)P_{\omega }(y\mid x)\log P_{\omega }(y\mid x)+{\omega }_0\left(1-\sum _y{P}_{\omega }(y\mid x)\right)\\ & +\sum _{i=1}^n{\omega }_i\left(\sum _{x,y}P(x,y)f_i(x,y)-\sum _{x,y}P(x)P_{\omega }(y\mid x)f_i(x,y)\right)\end{array}$$

证明对偶函数得极大化=最大熵模型得极大似然估计

将对偶函数继续化简：
由${\sum }_y{P}_{\omega }(y\mid x)=1$可知，对偶函数得第二项为0。
$$\begin{array}{rl}\Psi (\omega )=& \sum _{x,y}P(x)P_{\omega }(y\mid x)\log P_{\omega }(y\mid x)+\sum _{i=1}^n{\omega }_i\left(\sum _{x,y}P(x,y)f_i(x,y)-\sum _{x,y}P(x)P_{\omega }(y\mid x)f_i(x,y)\right)\\ =& \sum _{x,y}P(x,y)\sum _{i=1}^n{\omega }_i{f}_i(x,y)+\sum _{x,y}P(x)P_{\omega }(y\mid x)\left(\log P_{\omega }(y\mid x)-\sum _{i=1}^n{\omega }_i{f}_i(x,y)\right)\\ =& \sum _{x,y}P(x,y)\sum _{i=1}^n{\omega }_i{f}_i(x,y)-\sum _{x,y}P(x)P_{\omega }(y\mid x)\log Z_{\omega }(x)\\ =& \sum _{x,y}P(x,y)\sum _{i=1}^n{\omega }_i{f}_i(x,y)-\sum _{x}P(x)\log Z_{\omega }(x)\end{array}$$
现在看最大熵模型的极大似然估计：
最大熵模型的对数似然函数为：（$N\cdot P(x,y)$是数据$(x,y)$出现的次数）
$$\begin{array}{rl}{L}_P\left(P_{\omega }\right)& =\log \prod _{x,y}{P}_{\omega }(y\mid x{)}^{N\cdot P(x,y)}\\ & =N\cdot \log \prod _{x,y}{P}_{\omega }(y\mid x{)}^{P(x,y)}\\ & =N\cdot \sum _{x,y}P(x,y)\log P_{\omega }(y\mid x)\\ & =N\cdot \sum _{x,y}P(x,y)\log \frac{1}{Z_{\omega }(x)}\exp \left(\sum _{i=1}^n{\omega }_i{f}_i(x,y)\right)\\ & =N\left[\sum _{x,y}P(x,y)\left(\sum _{i=1}^n{\omega }_i{f}_i(x,y)\right)-\sum _{x,y}P(x,y)\log Z_{\omega }(x)\right]\\ & =N\left[\sum _{x,y}P(x,y)\left(\sum _{i=1}^n{\omega }_i{f}_i(x,y)\right)-\sum _{x}P(x)\log Z_{\omega }(x)\right]\end{array}$$
N是样本数，是固定的，可以省略。这样会发现
$$\Psi (\omega )=L_P\left(P_{\omega }\right)$$

模型学习的最优化算法

我们把求解最大熵模型转化为求解最大化对数似然函数或者最大化对偶函数，那么关键点就转换到找出 拉格朗日乘子$\omega$ 上。
$$\max \Psi (\omega )=\sum _{x,y}P(x,y)\sum _{i=1}^n{\omega }_i{f}_i(x,y)-\sum _{x}P(x)\log Z_{\omega }(x)$$
$Z_{\omega }(x)={\sum }_y\exp \left({\sum }_{i=1}^n{w}_i{f}_i(x,y)\right)$

梯度下降法解最大熵模型

目标函数$$Q(\omega )=-\Psi (\omega )=\sum _{x}P(x)\log \sum _y\exp \left(\sum _{i=1}^n{\omega }_i{f}_i(x,y)\right)-\sum _{x,y}P(x,y)\sum _{i=1}^n{\omega }_i{f}_i(x,y)$$

$$\nabla Q(\omega )={\left(\frac{\partial Q(\omega )}{\partial {\omega }_1},\frac{\partial Q(\omega )}{\partial {\omega }_2},\cdots ,\frac{\partial Q(\omega )}{\partial {\omega }_n}\right)}^T$$

$$\begin{array}{rl}\frac{\partial Q(\omega )}{\partial {\omega }_i}& =\sum _{x}P(x)\frac{{\sum }_y\exp \left({\sum }_{i=1}^n{\omega }_i{f}_i(x,y)\right)\cdot f_i(x,y)}{{\sum }_y\exp \left({\sum }_{i=1}^n{\omega }_i{f}_i(x,y)\right)}-\sum _{x,y}P(x,y)f_i(x,y)\\ & =\sum _{x}P(x)P_{\omega }(y\mid x)f_i(x,y)-E_P\left(f_i\right),i=1,2,\cdots ,n\end{array}$$

拟牛顿法解最大熵模型

牛顿法

先浅谈一下牛顿法：牛顿法最初是为了求解方程的根。

• 一元

$(x^{(k)},g(x^{(k)}))$处的切线
$$y=g(x^{(k)})+g^{{}^{\prime }}(x^{(k)})(x-x^{(k)})$$
与 x 轴的交点
$$y=0\Rightarrow x=x^{(k)}-\frac{g(x^{(k)})}{g^{{}^{\prime }}(x^{(k)})}$$
求$f(x)$的极值点，就是解$g(x)=f^{{}^{\prime }}(x)=0$的根
$$x=x^{(k)}-\frac{g(x^{(k)})}{g^{{}^{\prime }}(x^{(k)})}=x^{(k)}-\frac{f^{{}^{\prime }}(x^{(k)})}{f^{{}^{\prime \prime }}(x^{(k)})}$$

• 多元

$$x^{(k+1)}=x^{(k)}-H_f^{-1}\left(x^{(k)}\right)\nabla f\left(x^{(k)}\right)$$
这里的难点就在于要求出 「海森矩阵的逆」，但是如果数值计算量过大，由于是二阶偏导，那在计算过程中就会复杂很多，同时，如果海森矩阵的行列式为零 ，则计算不出逆矩阵，因此这时就需要 「拟牛顿法」出场了~搞清楚了牛顿法的难点，接着我们就看看有什么办法能「替代这个海森矩阵的逆」。

拟牛顿条件

牛顿法的实质其实是对它的目标函数 $f(x)$进行二阶泰勒展开，这里选择的点就是$x^{(k)}$ ，这里另提一句，梯度下降法是通过一阶泰勒展开得到的哦。f对x求导是g
$$f(x)\approx f\left(x^{(k)}\right)+g_k^T\left(x-x^{(k)}\right)+\frac{1}{2}{\left(x-x^{(k)}\right)}^{T}H\left(x^{(k)}\right)\left(x-x^{(k)}\right)$$
$$\begin{array}{rl}\frac{\partial f(x)}{\partial x}& \approx 0+g\left(x^{(k)}\right)+\frac{1}{2}\times 2H\left(x^{(k)}\right)\left(x-x^{(k)}\right)\\ & =g_k+H_k\left(x-x^{(k)}\right)\end{array}$$
$$g\left(x^{(k+1)}\right)=g_k+H_k\left(x^{(k+1)}-x^{(k)}\right)$$
「左式」是两个导函数的差值$g_{k+1}-g_k=y_k$，「右式」是两个相邻迭代点之间的差值$x^{(k+1)}-x^{(k)}={\delta }_k$
于是可以写成
$$y_k=H_k{\delta }_k$$
或者
$$H_k^{-1}{y}_k={\delta }_k$$
这两个式子成为拟牛顿条件。

拟牛顿法的合理性

合理性就不证明了，详情看(https://mp.weixin.qq.com/s/NmynLoYV23RCZPXFsYk6PA)

我们知道，拟牛顿法的核心就是为了找到替代品来取代求逆的海森矩阵，那么是不是意味着把这个替代品找到之后，就可以代入牛顿法去计算？
「其实不然！」

拟牛顿法可以看作牛顿法和梯度下降法的结合
$$\{\begin{array}{l}牛顿法:x^{(k+1)}=x^{(k)}-H_k^{-1}{g}_k\\ 梯度下降法:x^{(k+1)}=x^{(k)}+\lambda p_k,\lambda 是步长，p_k是搜索方向\end{array}$$
拟牛顿法的迭代：步长这样确定$\lambda ={\mathrm{argmin}}_{\lambda }f(x^{(k)}+\lambda p_k)$，搜索方向$p_k=-H_k^{-1}{g}_k$

DFP算法

• 使用第二个拟牛顿条件就是DFP算法，推导过程如下

$$P_k{y}_k={\delta }_k\Rightarrow P_k{y}_k=\frac{{\delta }_k({\delta }_k^T{y}_k)}{{\delta }_k^T{y}_k}=\frac{{\delta }_k{\delta }_k^T{y}_k}{{\delta }_k^T{y}_k}\Rightarrow P_k=\frac{{\delta }_k{\delta }_k^T}{{\delta }_k^T{y}_k}$$

$$Q_k{y}_k=-G_k{y}_k\Rightarrow Q_k{y}_k=-\frac{G_k{y}_k(y_k^T{G}_k{y}_k)}{y_k^T{G}_k{y}_k}\Rightarrow Q_k{y}_k=-\frac{G_k{y}_k{y}_k^T{G}_k{y}_k}{y_k^T{G}_k{y}_k}\Rightarrow Q_k=-\frac{G_k{y}_k{y}_k^T{G}_k}{y_k^T{G}_k{y}_k}$$

这里的$G_{k+1}$就去替代$H_{k+1}^{-1}$

DFP求解最大熵模型的完整过程：

BFGS算法

• 使用第一个拟牛顿条件就是BFGS算法，推导过程如下

这里的$B_{k+1}$就去替代$H_{k+1}$

BFGS求解最大熵模型的完整过程：

Broyden算法

改进的迭代尺度法IIS

思想：找$\delta$使得$L(\omega +\delta )>L(\omega )$

在“证明对偶函数得极大化=最大熵模型得极大似然估计”里有：
$$\begin{array}{rl}L(\omega +\delta )-L(\omega )& =\sum _{x,y}P(x,y)\log P_{\omega +\delta }(y\mid x)-\sum _{x,y}P(x,y)\log P_{\omega }(y\mid x)\\ & =\sum _{x,y}P(x,y)\sum _{i=1}^n{\delta }_i{f}_i(x,y)-\sum _{x}P(x)\log \frac{Z_{\omega +\delta }(x)}{Z_{\omega }(x)}\\ & \ge \sum _{x,y}P(x,y)\sum _{i=1}^n{\delta }_i{f}_i(x,y)-\sum _{x}P(x)[1-\frac{Z_{\omega +\delta }(x)}{Z_{\omega }(x)}]\\ & =\sum _{x,y}P(x,y)\sum _{i=1}^n{\delta }_i{f}_i(x,y)+1-\sum _{x}P(x)\frac{Z_{\omega +\delta }(x)}{Z_{\omega }(x)}\end{array}$$
$$\begin{array}{rl}\frac{Z_{\omega +\delta }(x)}{Z_{\omega }(x)}& =\frac{{\sum }_y\exp \left({\sum }_{i=1}^n\left({\omega }_i+{\delta }_i\right)f_i(x,y)\right)}{Z_{\omega }(x)}\\ & =\frac{{\sum }_y\exp \left({\sum }_{i=1}^n{\omega }_i{f}_i(x,y)\right)\cdot \exp \left({\sum }_{i=1}^n{\delta }_i{f}_i(x,y)\right)}{Z_{\omega }(x)}\\ & =\sum _y{P}_{\omega }(y\mid x)\exp \sum _{i=1}^n{\delta }_i{f}_i(x,y)\end{array}$$

令不等式右边的式子
$$A(\delta \mid \omega )=\sum _{x,y}P(x,y)\sum _{i=1}^n{\delta }_i{f}_i(x,y)+1-\sum _{x}P(x)\sum _y{P}_{\omega }(y\mid x)\exp \sum _{i=1}^n{\delta }_i{f}_i(x,y)$$

IIS的真谛

1.找到$A(\delta \mid \omega )$** 函数的下界**
引入：

可以得到如下
$$\{\begin{array}{l}\begin{array}{c}\frac{f_i(x,y)}{f^{\#}(x,y)}\ge 0\\ \sum _i^n\frac{f_i(x,y)}{f^{\#}(x,y)}=1\end{array}\end{array}$$

2. 说明IIS是合理的

IIS求解最大熵模型的完整过程

sklearn没有实现最大熵

1. 模型实现

import numpy as np
np.random.seed(10)


class MyMaxEntropy(object):
    def __init__(self, lr=0.0001):
        """
        最大熵模型的实现，为了方便理解，尽可能的将参数都存储为字典形式
        :param lr: 学习率，默认值为0.0001

        其他参数：
        :param w: 模型的参数，字典
        :param N: 样本数量
        :param label: 标签空间
        :param hat_p_x: 边缘分布P(X)的经验分布
        :param hat_p_x_y: 联合分布P(X,Y)的经验分布
        :param E_p: 特征函数f(x,y)关于模型P(X|Y)与经验分布hatP(X)的期望值
        :param E_hat_p: 特征函数f(x,y)关于经验分布hatP(X,Y)的期望值
        :param eps: 一个接近于0的正数极小值，这个值放在log的计算中，防止报错
        """
        self.lr = lr
        self.params = {'w': None}

        self.N = None
        self.label = None

        self.hat_p_x = {}
        self.hat_p_x_y = {}

        self.E_p = {}
        self.E_hat_p = {}

        self.eps = np.finfo(np.float32).eps


    def _init_params(self):
        """
        随机初始化模型参数w
        :return:
        """
        w = {}
        for key in self.hat_p_x_y.keys():
            w[key] = np.random.rand()
        self.params['w'] = w

    def _rebuild_X(self, X):
        """
        为了自变量的差异化处理，重新命名自变量
        :param X: 原始自变量
        :return:
        """
        X_result = []
        for x in X:
            X_result.append([y_s + '_' + x_s for x_s, y_s in zip(x, self.X_columns)])
        return X_result

    def _build_mapping(self, X, Y):
        """
        求取经验分布，参照公式(1)(2)
        :param X: 训练样本的输入值
        :param Y: 训练样本的输出值
        :return:
        """
        for x, y in zip(X, Y):
            for x_s in x:
                if x_s in self.hat_p_x.keys():
                    self.hat_p_x[x_s] += 1
                else:
                    self.hat_p_x[x_s] = 1
                if (x_s, y) in self.hat_p_x_y.keys():
                    self.hat_p_x_y[(x_s, y)] += 1
                else:
                    self.hat_p_x_y[(x_s, y)] = 1

        self.hat_p_x = {key: count / self.N for key, count in self.hat_p_x.items()}
        self.hat_p_x_y = {key: count / self.N for key, count in self.hat_p_x_y.items()}

    def _cal_E_hat_p(self):
        """
        计算特征函数f(x,y)关于经验分布hatP(X,Y)的期望值，参照公式(3)
        :return:
        """
        self.E_hat_p = self.hat_p_x_y


    def _cal_E_p(self, X):
        """
        计算特征函数f(x,y)关于模型P(X|Y)与经验分布hatP(X)的期望值，参照公式(4)
        :param X:
        :return:
        """
        for key in self.params['w'].keys():
            self.E_p[key] = 0
        for x in X:
            p_y_x = self._cal_prob(x)
            for x_s in x:
                for (p_y_x_s, y) in p_y_x:
                    if (x_s, y) not in self.E_p.keys():
                        continue
                    self.E_p[(x_s, y)] += (1/self.N) * p_y_x_s

    def _cal_p_y_x(self, x, y):
        """
        计算模型条件概率值，参照公式(9)的指数部分
        :param x: 单个样本的输入值
        :param y: 单个样本的输出值
        :return:
        """

        sum = 0.0
        for x_s in x:
            sum += self.params['w'].get((x_s, y), 0)
        return np.exp(sum), y


    def _cal_prob(self, x):
        """
        计算模型条件概率值，参照公式(9)
        :param x: 单个样本的输入值
        :return:
        """
        p_y_x = [(self._cal_p_y_x(x, y)) for y in self.label]
        sum_y = np.sum([p_y_x_s for p_y_x_s, y in p_y_x])
        return [(p_y_x_s / sum_y, y) for p_y_x_s, y in p_y_x]


    def fit(self, X, X_columns, Y, label, max_iter=20000):
        """
        模型训练入口
        :param X: 训练样本输入值
        :param X_columns: 训练样本的columns
        :param Y: 训练样本的输出值
        :param label: 训练样本的输出空间
        :param max_iter: 最大训练次数
        :return:
        """
        self.N = len(X)
        self.label = label
        self.X_columns = X_columns

        X = self._rebuild_X(X)

        self._build_mapping(X, Y)

        self._cal_E_hat_p()

        self._init_params()

        for iter in range(max_iter):

            self._cal_E_p(X)

            for key in self.params['w'].keys():
                sigma = self.lr * np.log(self.E_hat_p.get(key, self.eps) / self.E_p.get(key, self.eps))
                self.params['w'][key] += sigma

    def predict(self, X):
        """
        预测结果
        :param X: 样本
        :return:
        """
        X = self._rebuild_X(X)
        result_list = []

        for x in X:
            max_result = 0
            y_result = self.label[0]
            p_y_x = self._cal_prob(x)
            for (p_y_x_s, y) in p_y_x:
                if p_y_x_s > max_result:
                    max_result = p_y_x_s
                    y_result = y
            result_list.append((max_result, y_result))
        return result_list

2. 模型测试

def run_my_model():
    data_set = [['youth', 'no', 'no', '1', 'refuse'],
               ['youth', 'no', 'no', '2', 'refuse'],
               ['youth', 'yes', 'no', '2', 'agree'],
               ['youth', 'yes', 'yes', '1', 'agree'],
               ['youth', 'no', 'no', '1', 'refuse'],
               ['mid', 'no', 'no', '1', 'refuse'],
               ['mid', 'no', 'no', '2', 'refuse'],
               ['mid', 'yes', 'yes', '2', 'agree'],
               ['mid', 'no', 'yes', '3', 'agree'],
               ['mid', 'no', 'yes', '3', 'agree'],
               ['elder', 'no', 'yes', '3', 'agree'],
               ['elder', 'no', 'yes', '2', 'agree'],
               ['elder', 'yes', 'no', '2', 'agree'],
               ['elder', 'yes', 'no', '3', 'agree'],
               ['elder', 'no', 'no', '1', 'refuse'],
               ]
    columns = ['age', 'working', 'house', 'credit_situation', 'label']
    X = [i[:-1] for i in data_set]
    X_columns = columns[:-1]
    Y = [i[-1] for i in data_set]
    print(X)
    print(Y)

    my = MyMaxEntropy()
    train_X = X[:12]
    test_X = X[12:]
    train_Y = Y[:12]
    test_Y = Y[12:]
    my.fit(train_X, X_columns, train_Y, label=['refuse', 'agree'])

    print(my.params)

    pred_Y= my.predict(test_X)
    print('result: ')
    print('test: ', test_Y)
    print('pred: ', pred_Y)