用JAVA语言实现离散数学算法

用JAVA语言实现离散数学算法 * 显示离散数学算法的真值表 * 提供将一个中缀合适公式的真值表输出到某一PrintStream流中的功能 * 以单个大写字母表示变量(支持26个变量) * 以字符0或者1表示值 * 以 ~ ^ θ)来更新Y的期望E(Y)，然后用E(Y)代替Y求出新的模型参数θ(1)。如此迭代直到θ趋于稳定。 在HMM问题中，隐含变量自然就是状态变量，要求状态变量的期望值，其实就是求时刻ti观察到xi时处于状态si的概率，为了求此概率，需要用到向前变量和向后变量。 向前变量 向前变量 是假定的参数 它表示t时刻满足状态，且t时刻之前(包括t时刻)满足给定的观测序列的概率。 1. 令初始值 2. 归纳法计算 3. 最后计算 复杂度 向后变量 向后变量 它表示在时刻t出现状态，且t时刻以后的观察序列满足的概率。 1. 初始值 2. 归纳计算 E-Step 定义变量为t时刻处于状态i，t+1时刻处于状态j的概率。 定义变量表示t时刻呈现状态i的概率。 实际上 是从其他所有状态转移到状态i的次数的期望值。 是从状态i转移出去的次数的期望值。 是从状态i转移到状态j的次数的期望值。 M-Step 是在初始时刻出现状态i的频率的期望值， 是从状态i转移到状态j的次数的期望值 除以 从状态i转移出去的次数的期望值， 是在状态j下观察到活动为k的次数的期望值 除以 从其他所有状态转移到状态j的次数的期望值, 然后用新的参数再来计算向前变量、向后变量、和。如此循环迭代，直到前后两次参数的变化量小于某个值为止。 下面给出我的java代码： package nlp; /** * @author Orisun * date 2011-10-22 */ import java.util.ArrayList; public class BaumWelch { int M; // 隐藏状态的种数 int N; // 输出活动的种数 double[] PI; // 初始状态概率矩阵 double[][] A; // 状态转移矩阵 double[][] B; // 混淆矩阵 ArrayList observation = new ArrayList(); // 观察到的集合 ArrayList state = new ArrayList(); // 中间状态集合 int[] out_seq = { 2, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 1 }; // 测试用的观察序列 int[] hidden_seq = { 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 }; // 测试用的隐藏状态序列 int T = 32; // 序列长度为32 double[][] alpha = new double[T][]; // 向前变量 double PO; double[][] beta = new double[T][]; // 向后变量 double[][] gamma = new double[T][]; double[][][] xi = new double[T - 1][][]; // 初始化参数。Baum-Welch得到的是局部最优解，所以初始参数直接影响解的好坏 public void initParameters() { M = 2; N = 2; PI = new double[M]; PI[0] = 0.5; PI[1] = 0.5; A = new double[M][]; B = new double[M][]; for (int i = 0; i < M; i++) { A[i] = new double[M]; B[i] = new double[N]; } A[0][0] = 0.8125; A[0][1] = 0.1875; A[1][0] = 0.2; A[1][1] = 0.8; B[0][0] = 0.875; B[0][1] = 0.125; B[1][0] = 0.25; B[1][1] = 0.75; observation.add(1); observation.add(2); state.add(1); state.add(2); for (int t = 0; t < T; t++) { alpha[t] = new double[M]; beta[t] = new double[M]; gamma[t] = new double[M]; } for (int t = 0; t < T - 1; t++) { xi[t] = new double[M][]; for (int i = 0; i < M; i++) xi[t][i] = new double[M]; } } // 更新向前变量 public void updateAlpha() { for (int i = 0; i < M; i++) { alpha[0][i] = PI[i] * B[i][observation.indexOf(out_seq[0])]; } for (int t = 1; t < T; t++) { for (int i = 0; i < M; i++) { alpha[t][i] = 0; for (int j = 0; j < M; j++) { alpha[t][i] += alpha[t - 1][j] * A[j][i]; } alpha[t][i] *= B[i][observation.indexOf(out_seq[t])]; } } } // 更新观察序列出现的概率，它在一些公式中当分母 public void updatePO() { for (int i = 0; i < M; i++) PO += alpha[T - 1][i]; } // 更新向后变量 public void updateBeta() { for (int i = 0; i = 0; t--) { for (int i = 0; i < M; i++) { for (int j = 0; j < M; j++) { beta[t][i] += A[i][j] * B[j][observation.indexOf(out_seq[t + 1])] * beta[t + 1][j]; } } } } // 更新xi public void updateXi() { for (int t = 0; t < T - 1; t++) { double frac = 0.0; for (int i = 0; i < M; i++) { for (int j = 0; j < M; j++) { frac += alpha[t][i] * A[i][j] * B[j][observation.indexOf(out_seq[t + 1])] * beta[t + 1][j]; } } for (int i = 0; i < M; i++) { for (int j = 0; j < M; j++) { xi[t][i][j] = alpha[t][i] * A[i][j] * B[j][observation.indexOf(out_seq[t + 1])] * beta[t + 1][j] / frac; } } } } // 更新gamma public void updateGamma() { for (int t = 0; t < T - 1; t++) { double frac = 0.0; for (int i = 0; i < M; i++) { frac += alpha[t][i] * beta[t][i]; } // double frac = PO; for (int i = 0; i < M; i++) { gamma[t][i] = alpha[t][i] * beta[t][i] / frac; } // for(int i=0;i