多项式混合模型

最新推荐文章于 2021-12-20 16:33:27 发布
最新推荐文章于 2021-12-20 16:33:27 发布
阅读量1k 收藏
点赞数
分类专栏： 贝叶斯分析 文章标签： 多项式混合模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkq_1986/article/details/51484405
版权

===============================================

Multi_Multi_EM


package wangfang_em;



import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Multi_Multi_EM {


public static void main(String[] args) {
System.out.println("start execute.");
try {
long start = System.currentTimeMillis();
run();
long end = System.currentTimeMillis();
System.out.println("execute time: " + (double) (end - start) / 1000 + " s.");
} catch (IOException e) {
e.printStackTrace();
}
}


static void run() throws IOException {
int[][] matrixA = getData(Config.MATRIX_A_PATH);
int[][] matrixB = getData(Config.MATRIX_B_PATH);


int K = Config.K;// 主题数


int D = matrixA.length;// 文档数,最后一位存储所属的类
int X = matrixA[0].length - 1;// 词数
int Y = matrixB[0].length - 1;// 词数


int maxItr = Config.MAX_ITR;


System.out.println("docsNumber:" + D + ", X:" + X + ", Y:" + Y + ", K:" + K + ", maxItr:" + maxItr);


// double[] lamda_n_T = initNRT(D, matrixA);
// double[] lamda_n_R = initNRT(D, matrixB);


double[] pi_k = initPIK(K);
double[][] theta_ktx = initTheta_kt(K, X);
double[][] theta_kry = initTheta_kt(K, Y);


double[][] g_n_k = init_gnk(D, K);


for (int itr = 0; itr < maxItr; itr++) {// 迭代
System.out.println("start itr: " + itr + " ...");


for (int k = 0; k < K; k++) {// 主题
// 更新pi
double sum_gnk = 0;
for (int i = 0; i < D; i++) {// 文档
sum_gnk += g_n_k[i][k];
}
pi_k[k] = sum_gnk / D;


// 更新theta_ktx
double fenmu = 0;
for (int x = 0; x < X; x++) {// 词
double fenzi = 1;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixA[i][x] * g_n_k[i][k];
}
fenmu += fenzi;
theta_ktx[k][x] = fenzi;
}
for (int x = 0; x < X; x++) {// 词
theta_ktx[k][x] /= fenmu;
}


// 更新theta_kry
fenmu = 0;
for (int y = 0; y < Y; y++) {// 词
double fenzi = 1;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixB[i][y] * g_n_k[i][k];
}
fenmu += fenzi;
theta_kry[k][y] = fenzi;
}
for (int y = 0; y < Y; y++) {// 词
theta_kry[k][y] /= fenmu;
}
}


System.out.println("    start update g_n_k ...");
// 计算g_n_k
for (int i = 0; i < D; i++) {// 文档
double max = Double.NEGATIVE_INFINITY;
for (int k = 0; k < K; k++) {// 主题,计算p(dn│theta_k )
double log_ret = 0;
for (int x = 0; x < X; x++) {
log_ret += Math.log(theta_ktx[k][x]) * matrixA[i][x];
}
for (int y = 0; y < Y; y++) {
log_ret += Math.log(theta_kry[k][y]) * matrixB[i][y];
}
if (max < log_ret) {
max = log_ret;
}
g_n_k[i][k] = log_ret;
}
double sum = 0;
for (int k = 0; k < K; k++) {// 主题，计算g(n,k)
g_n_k[i][k] = Math.exp(g_n_k[i][k] - max) * pi_k[k];
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题概率归一化
g_n_k[i][k] /= sum;
}
}


System.out.println("end itr: " + itr + " ...");
}


// 输出结果
out(D, K, matrixA, g_n_k);
}




// 读取数据
static int[][] getData(String path) throws IOException {
System.out.println("start getData " + path + " ...");
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(path)), "utf-8"));


String line;
List<String[]> ls = new ArrayList<String[]>();
int maxV = 0;
while ((line = br.readLine()) != null) {
if (!line.startsWith("@")) {
String[] es = line.split(",");
if (es.length > 1) {
if (es.length > maxV) {
maxV = es.length;
}
ls.add(es);
}
}
}


int[][] matrix = new int[ls.size()][maxV];
for (int i = 0; i < ls.size(); i++) {
String[] es = ls.get(i);
for (int j = 0; j < es.length; j++) {
int val = (int) Double.parseDouble(es[j]);
matrix[i][j] = val;
}
}
System.out.println("end getData " + path + " ...");
return matrix;
}


// // 初始lamda_n_t和lamda_r_y
// static BigInteger[] initNRT(int D, int[][] matrix) {
// BigInteger[] lamda_n = new BigInteger[D];
// int len = matrix[0].length - 1;
// for (int i = 0; i < D; i++) {
// int sum = 0;
// BigInteger fenmu = BigInteger.ONE;
// for (int j = 0; j < len; j++) {
// sum += matrix[i][j];
// fenmu = fenmu.multiply(BigInteger_JieCheng.bigFactorial(matrix[i][j]));
// }
// BigInteger fenzi = BigInteger_JieCheng.bigFactorial(sum);
// lamda_n[i] = fenzi.divide(fenmu);
// }
// return lamda_n;
// }


static double[] initPIK(int K) {
double[] pi_k = new double[K];
double sum = 0;
for (int i = 0; i < K; i++) {
pi_k[i] = Math.random();
sum += pi_k[i];
}
for (int i = 0; i < K; i++) {
pi_k[i] /= sum;
}
return pi_k;
}


static double[][] initTheta_kt(int K, int len) {
double[][] theta_kt = new double[K][len];
for (int i = 0; i < K; i++) {// 主题
double sum = 0;
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] = Math.random();
sum += theta_kt[i][j];
}
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] /= sum;
}
}
return theta_kt;
}


static double[][] init_pdn_theta_k(int D, int K) {
double[][] pdn_theta_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double val = (double) 1 / K;
for (int k = 0; k < K; k++) {// 主题
pdn_theta_k[i][k] = val;
}
}
return pdn_theta_k;
}


static double[][] init_gnk(int D, int K) {
double[][] g_n_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double sum = 0;
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] = Math.random();
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] /= sum;
}
}
return g_n_k;
}


static void out(int D, int K, int[][] matrixA, double[][] g_n_k) {
int[][] retDistribution = new int[K][K];// 文档主题的结果分布表
for (int i = 0; i < K; i++) {// 主题
for (int j = 0; j < K; j++) {// 主题
retDistribution[i][j] = 0;
}
}


for (int i = 0; i < D; i++) {// 文档
System.out.println();
for (int k = 0; k < K; k++) {// 主题
System.out.print("," + g_n_k[i][k]);
}
}
System.out.println();


for (int i = 0; i < D; i++) {// 文档
double max_g_n_k = 0;
int cur_k = 0;
for (int k = 0; k < K; k++) {// 主题
if (g_n_k[i][k] > max_g_n_k) {
max_g_n_k = g_n_k[i][k];
cur_k = k;
}
}
retDistribution[cur_k][matrixA[i][matrixA[i].length - 1]]++;
}


// 输出结果
System.out.println("=============================");
System.out.print("\t");
for (int i = 0; i < K; i++) {// 主题
System.out.print("cls" + i + "\t");
}
System.out.println();


for (int i = 0; i < K; i++) {// 主题
System.out.print("newCls" + i);
for (int j = 0; j < K; j++) {// 主题
System.out.print("\t" + retDistribution[i][j]);
}
System.out.println();
}
System.out.println("=============================");
System.out.println("the end.");
}

}




===============================================

Multi_EM



package wangfang_em;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Multi_EM {


public static void main(String[] args) {
System.out.println("start execute.");
try {
long start = System.currentTimeMillis();
run();
long end = System.currentTimeMillis();
System.out.println("execute time: " + (double) (end - start) / 1000 + " s.");
} catch (IOException e) {
e.printStackTrace();
}
}


static void run() throws IOException {
int[][] matrixA = getData(Config.MATRIX_A_PATH);
// int[][] matrixB = getData(Config.MATRIX_B_PATH);


int K = Config.K;// 主题数


int D = matrixA.length;// 文档数,最后一位存储所属的类
int X = matrixA[0].length - 1;// 词数
// int Y = matrixB[0].length - 1;// 词数


int maxItr = Config.MAX_ITR;


System.out.println("docsNumber:" + D + ", X:" + X + ", K:" + K + ", maxItr:" + maxItr);


// double[] lamda_n_T = initNRT(D, matrixA);
// double[] lamda_n_R = initNRT(D, matrixB);


double[] pi_k = initPIK(K);
double[][] theta_ktx = initTheta_kt(K, X);


double[][] g_n_k = init_gnk(D, K);


for (int itr = 0; itr < maxItr; itr++) {// 迭代
System.out.println("start itr: " + itr + " ...");


for (int k = 0; k < K; k++) {// 主题
// 更新pi
double sum_gnk = 0;
for (int i = 0; i < D; i++) {// 文档
sum_gnk += g_n_k[i][k];
}
pi_k[k] = sum_gnk / D;


// 更新theta_ktx
double fenmu = 0;
for (int x = 0; x < X; x++) {// 词
double fenzi = 1;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixA[i][x] * g_n_k[i][k];
}
fenmu += fenzi;
theta_ktx[k][x] = fenzi;
}
for (int x = 0; x < X; x++) {// 词
theta_ktx[k][x] /= fenmu;
}
}


System.out.println("    start update g_n_k ...");
// 计算g_n_k
for (int i = 0; i < D; i++) {// 文档
double max = Double.NEGATIVE_INFINITY;
for (int k = 0; k < K; k++) {// 主题,计算p(dn│theta_k )
double log_ret = 0;
for (int x = 0; x < X; x++) {
log_ret += Math.log(theta_ktx[k][x]) * matrixA[i][x];
}
if (max < log_ret) {
max = log_ret;
}
g_n_k[i][k] = log_ret;
}
double sum = 0;
for (int k = 0; k < K; k++) {// 主题，计算g(n,k)
g_n_k[i][k] = Math.exp(g_n_k[i][k] - max) * pi_k[k];
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题概率归一化
g_n_k[i][k] /= sum;
}
}


System.out.println("end itr: " + itr + " ...");
}


// 输出结果
out(D, K, matrixA, g_n_k);
}




// 读取数据
static int[][] getData(String path) throws IOException {
System.out.println("start getData " + path + " ...");
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(path)), "utf-8"));


String line;
List<String[]> ls = new ArrayList<String[]>();
int maxV = 0;
while ((line = br.readLine()) != null) {
if (!line.startsWith("@")) {
String[] es = line.split(",");
if (es.length > 1) {
if (es.length > maxV) {
maxV = es.length;
}
ls.add(es);
}
}
}


int[][] matrix = new int[ls.size()][maxV];
for (int i = 0; i < ls.size(); i++) {
String[] es = ls.get(i);
for (int j = 0; j < es.length; j++) {
int val = (int) Double.parseDouble(es[j]);
matrix[i][j] = val;
}
}
System.out.println("end getData " + path + " ...");
return matrix;
}


// // 初始lamda_n_t和lamda_r_y
// static BigInteger[] initNRT(int D, int[][] matrix) {
// BigInteger[] lamda_n = new BigInteger[D];
// int len = matrix[0].length - 1;
// for (int i = 0; i < D; i++) {
// int sum = 0;
// BigInteger fenmu = BigInteger.ONE;
// for (int j = 0; j < len; j++) {
// sum += matrix[i][j];
// fenmu = fenmu.multiply(BigInteger_JieCheng.bigFactorial(matrix[i][j]));
// }
// BigInteger fenzi = BigInteger_JieCheng.bigFactorial(sum);
// lamda_n[i] = fenzi.divide(fenmu);
// }
// return lamda_n;
// }


static double[] initPIK(int K) {
double[] pi_k = new double[K];
double sum = 0;
for (int i = 0; i < K; i++) {
pi_k[i] = Math.random();
sum += pi_k[i];
}
for (int i = 0; i < K; i++) {
pi_k[i] /= sum;
}
return pi_k;
}


static double[][] initTheta_kt(int K, int len) {
double[][] theta_kt = new double[K][len];
for (int i = 0; i < K; i++) {// 主题
double sum = 0;
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] = Math.random();
sum += theta_kt[i][j];
}
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] /= sum;
}
}
return theta_kt;
}


static double[][] init_pdn_theta_k(int D, int K) {
double[][] pdn_theta_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double val = (double) 1 / K;
for (int k = 0; k < K; k++) {// 主题
pdn_theta_k[i][k] = val;
}
}
return pdn_theta_k;
}


static double[][] init_gnk(int D, int K) {
double[][] g_n_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double sum = 0;
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] = Math.random();
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] /= sum;
}
}
return g_n_k;
}


static void out(int D, int K, int[][] matrixA, double[][] g_n_k) {
int[][] retDistribution = new int[K][K];// 文档主题的结果分布表
for (int i = 0; i < K; i++) {// 主题
for (int j = 0; j < K; j++) {// 主题
retDistribution[i][j] = 0;
}
}


for (int i = 0; i < D; i++) {// 文档
System.out.println();
for (int k = 0; k < K; k++) {// 主题
System.out.print("," + g_n_k[i][k]);
}
}
System.out.println();


for (int i = 0; i < D; i++) {// 文档
double max_g_n_k = 0;
int cur_k = 0;
for (int k = 0; k < K; k++) {// 主题
if (g_n_k[i][k] > max_g_n_k) {
max_g_n_k = g_n_k[i][k];
cur_k = k;
}
}
retDistribution[cur_k][matrixA[i][matrixA[i].length - 1]]++;
}


// 输出结果
System.out.println("=============================");
System.out.print("\t");
for (int i = 0; i < K; i++) {// 主题
System.out.print("cls" + i + "\t");
}
System.out.println();


for (int i = 0; i < K; i++) {// 主题
System.out.print("newCls" + i);
for (int j = 0; j < K; j++) {// 主题
System.out.print("\t" + retDistribution[i][j]);
}
System.out.println();
}
System.out.println("=============================");
System.out.println("the end.");
}
}





=====================================

Multi_Bernoulli_EM



package wangfang_em;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Multi_Bernoulli_EM {


public static void main(String[] args) {
System.out.println("start execute.");
try {
long start = System.currentTimeMillis();
run();
long end = System.currentTimeMillis();
System.out.println("execute time: " + (double) (end - start) / 1000 + " s.");
} catch (IOException e) {
e.printStackTrace();
}
}


static void run() throws IOException {
int[][] matrixA = getData(Config.MATRIX_A_PATH);
int[][] matrixB = getData(Config.MATRIX_B_PATH);


int K = Config.K;// 主题数


int D = matrixA.length;// 文档数,最后一位存储所属的类
int X = matrixA[0].length - 1;// 词数
int Y = matrixB[0].length - 1;// 词数


int maxItr = Config.MAX_ITR;


System.out.println("docsNumber:" + D + ", X:" + X + ", Y:" + Y + ", K:" + K + ", maxItr:" + maxItr);


// double[] lamda_n_T = initNRT(D, matrixA);
// double[] lamda_n_R = initNRT(D, matrixB);


double[] pi_k = initPIK(K);
double[][] theta_ktx = initTheta_kt(K, X);
double[][] theta_kry = initTheta_kt(K, Y);


double[][] g_n_k = init_gnk(D, K);


for (int itr = 0; itr < maxItr; itr++) {// 迭代
System.out.println("start itr: " + itr + " ...");


for (int k = 0; k < K; k++) {// 主题
// 更新pi
double sum_gnk = 0;
for (int i = 0; i < D; i++) {// 文档
sum_gnk += g_n_k[i][k];
}
pi_k[k] = sum_gnk / D;


// 更新theta_ktx
double fenmu = 0;
for (int x = 0; x < X; x++) {// 词
double fenzi = 1;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixA[i][x] * g_n_k[i][k];
}
fenmu += fenzi;
theta_ktx[k][x] = fenzi;
}
for (int x = 0; x < X; x++) {// 词
theta_ktx[k][x] /= fenmu;
}


// 更新theta_kry

for (int y = 0; y < Y; y++) {// 词
double fenzi = 1;
fenmu = 2;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixB[i][y] * g_n_k[i][k];
fenmu += matrixB[i][y];
}
theta_kry[k][y] = fenzi/fenmu;
}
}


System.out.println("    start update g_n_k ...");
// 计算g_n_k
for (int i = 0; i < D; i++) {// 文档
double max = Double.NEGATIVE_INFINITY;
for (int k = 0; k < K; k++) {// 主题,计算p(dn│theta_k )
double log_ret = 0;
for (int x = 0; x < X; x++) {
log_ret += Math.log(theta_ktx[k][x]) * matrixA[i][x];
}
for (int y = 0; y < Y; y++) {
log_ret += Math.log(theta_kry[k][y]) * matrixB[i][y];
log_ret += Math.log((1-theta_kry[k][y])) * (1-matrixB[i][y]);
}
if (max < log_ret) {
max = log_ret;
}
g_n_k[i][k] = log_ret;
}
double sum = 0;
for (int k = 0; k < K; k++) {// 主题，计算g(n,k)
g_n_k[i][k] = Math.exp(g_n_k[i][k] - max) * pi_k[k];
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题概率归一化
g_n_k[i][k] /= sum;
}
}


System.out.println("end itr: " + itr + " ...");
}


// 输出结果
out(D, K, matrixA, g_n_k);
}




// 读取数据
static int[][] getData(String path) throws IOException {
System.out.println("start getData " + path + " ...");
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(path)), "utf-8"));


String line;
List<String[]> ls = new ArrayList<String[]>();
int maxV = 0;
while ((line = br.readLine()) != null) {
if (!line.startsWith("@")) {
String[] es = line.split(",");
if (es.length > 1) {
if (es.length > maxV) {
maxV = es.length;
}
ls.add(es);
}
}
}


int[][] matrix = new int[ls.size()][maxV];
for (int i = 0; i < ls.size(); i++) {
String[] es = ls.get(i);
for (int j = 0; j < es.length; j++) {
int val = (int) Double.parseDouble(es[j]);
matrix[i][j] = val;
}
}
System.out.println("end getData " + path + " ...");
return matrix;
}


// // 初始lamda_n_t和lamda_r_y
// static BigInteger[] initNRT(int D, int[][] matrix) {
// BigInteger[] lamda_n = new BigInteger[D];
// int len = matrix[0].length - 1;
// for (int i = 0; i < D; i++) {
// int sum = 0;
// BigInteger fenmu = BigInteger.ONE;
// for (int j = 0; j < len; j++) {
// sum += matrix[i][j];
// fenmu = fenmu.multiply(BigInteger_JieCheng.bigFactorial(matrix[i][j]));
// }
// BigInteger fenzi = BigInteger_JieCheng.bigFactorial(sum);
// lamda_n[i] = fenzi.divide(fenmu);
// }
// return lamda_n;
// }


static double[] initPIK(int K) {
double[] pi_k = new double[K];
double sum = 0;
for (int i = 0; i < K; i++) {
pi_k[i] = Math.random();
sum += pi_k[i];
}
for (int i = 0; i < K; i++) {
pi_k[i] /= sum;
}
return pi_k;
}


static double[][] initTheta_kt(int K, int len) {
double[][] theta_kt = new double[K][len];
for (int i = 0; i < K; i++) {// 主题
double sum = 0;
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] = Math.random();
sum += theta_kt[i][j];
}
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] /= sum;
}
}
return theta_kt;
}


static double[][] init_pdn_theta_k(int D, int K) {
double[][] pdn_theta_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double val = (double) 1 / K;
for (int k = 0; k < K; k++) {// 主题
pdn_theta_k[i][k] = val;
}
}
return pdn_theta_k;
}


static double[][] init_gnk(int D, int K) {
double[][] g_n_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double sum = 0;
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] = Math.random();
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] /= sum;
}
}
return g_n_k;
}


static void out(int D, int K, int[][] matrixA, double[][] g_n_k) {
int[][] retDistribution = new int[K][K];// 文档主题的结果分布表
for (int i = 0; i < K; i++) {// 主题
for (int j = 0; j < K; j++) {// 主题
retDistribution[i][j] = 0;
}
}


for (int i = 0; i < D; i++) {// 文档
System.out.println();
for (int k = 0; k < K; k++) {// 主题
System.out.print("," + g_n_k[i][k]);
}
}
System.out.println();


for (int i = 0; i < D; i++) {// 文档
double max_g_n_k = 0;
int cur_k = 0;
for (int k = 0; k < K; k++) {// 主题
if (g_n_k[i][k] > max_g_n_k) {
max_g_n_k = g_n_k[i][k];
cur_k = k;
}
}
retDistribution[cur_k][matrixA[i][matrixA[i].length - 1]]++;
}


// 输出结果
System.out.println("=============================");
System.out.print("\t");
for (int i = 0; i < K; i++) {// 主题
System.out.print("cls" + i + "\t");
}
System.out.println();


for (int i = 0; i < K; i++) {// 主题
System.out.print("newCls" + i);
for (int j = 0; j < K; j++) {// 主题
System.out.print("\t" + retDistribution[i][j]);
}
System.out.println();
}
System.out.println("=============================");
System.out.println("the end.");
}
}




============================================

Bernoulli_EM


package wangfang_em;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Bernoulli_EM {


public static void main(String[] args) {
System.out.println("start execute.");
try {
long start = System.currentTimeMillis();
run();
long end = System.currentTimeMillis();
System.out.println("execute time: " + (double) (end - start) / 1000 + " s.");
} catch (IOException e) {
e.printStackTrace();
}
}


static void run() throws IOException {
int[][] matrixA = getData(Config.MATRIX_A_PATH);
// int[][] matrixB = getData(Config.MATRIX_B_PATH);


int K = Config.K;// 主题数


int D = matrixA.length;// 文档数,最后一位存储所属的类
int X = matrixA[0].length - 1;// 词数
// int Y = matrixB[0].length - 1;// 词数


int maxItr = Config.MAX_ITR;


System.out.println("docsNumber:" + D + ", X:" + X + ", K:" + K + ", maxItr:" + maxItr);


double[] pi_k = initPIK(K);
double[][] theta_ktx = initTheta_kt(K, X);


double[][] g_n_k = init_gnk(D, K);


for (int itr = 0; itr < maxItr; itr++) {// 迭代
System.out.println("start itr: " + itr + " ...");


for (int k = 0; k < K; k++) {// 主题
// 更新pi
double sum_gnk = 0;
for (int i = 0; i < D; i++) {// 文档
sum_gnk += g_n_k[i][k];
}
pi_k[k] = sum_gnk / D;


// 更新theta_ktx
for (int x = 0; x < X; x++) {// 词
double fenzi = 1;
double fenmu = 2;
for (int i = 0; i < D; i++) {// 文档
fenzi += matrixA[i][x] * g_n_k[i][k];
fenmu += matrixA[i][x];
}
theta_ktx[k][x] = fenzi/fenmu;
}
}


System.out.println("    start update g_n_k ...");
// 计算g_n_k
for (int i = 0; i < D; i++) {// 文档
double max = Double.NEGATIVE_INFINITY;
for (int k = 0; k < K; k++) {// 主题,计算p(dn│theta_k )
double log_ret = 0;
for (int x = 0; x < X; x++) {
log_ret += Math.log(theta_ktx[k][x]) * matrixA[i][x];
log_ret += Math.log((1-theta_ktx[k][x])) * (1-matrixA[i][x]);
}
if (max < log_ret) {
max = log_ret;
}
g_n_k[i][k] = log_ret;
}
double sum = 0;
for (int k = 0; k < K; k++) {// 主题，计算g(n,k)
g_n_k[i][k] = Math.exp(g_n_k[i][k] - max) * pi_k[k];
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题概率归一化
g_n_k[i][k] /= sum;
}
}


System.out.println("end itr: " + itr + " ...");
}


// 输出结果
out(D, K, matrixA, g_n_k);
}




// 读取数据
static int[][] getData(String path) throws IOException {
System.out.println("start getData " + path + " ...");
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(path)), "utf-8"));


String line;
List<String[]> ls = new ArrayList<String[]>();
int maxV = 0;
while ((line = br.readLine()) != null) {
if (!line.startsWith("@")) {
String[] es = line.split(",");
if (es.length > 1) {
if (es.length > maxV) {
maxV = es.length;
}
ls.add(es);
}
}
}


int[][] matrix = new int[ls.size()][maxV];
for (int i = 0; i < ls.size(); i++) {
String[] es = ls.get(i);
for (int j = 0; j < es.length; j++) {
int val = (int) Double.parseDouble(es[j]);
matrix[i][j] = val;
}
}
System.out.println("end getData " + path + " ...");
return matrix;
}


// // 初始lamda_n_t和lamda_r_y
// static BigInteger[] initNRT(int D, int[][] matrix) {
// BigInteger[] lamda_n = new BigInteger[D];
// int len = matrix[0].length - 1;
// for (int i = 0; i < D; i++) {
// int sum = 0;
// BigInteger fenmu = BigInteger.ONE;
// for (int j = 0; j < len; j++) {
// sum += matrix[i][j];
// fenmu = fenmu.multiply(BigInteger_JieCheng.bigFactorial(matrix[i][j]));
// }
// BigInteger fenzi = BigInteger_JieCheng.bigFactorial(sum);
// lamda_n[i] = fenzi.divide(fenmu);
// }
// return lamda_n;
// }


static double[] initPIK(int K) {
double[] pi_k = new double[K];
double sum = 0;
for (int i = 0; i < K; i++) {
pi_k[i] = Math.random();
sum += pi_k[i];
}
for (int i = 0; i < K; i++) {
pi_k[i] /= sum;
}
return pi_k;
}


static double[][] initTheta_kt(int K, int len) {
double[][] theta_kt = new double[K][len];
for (int i = 0; i < K; i++) {// 主题
double sum = 0;
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] = Math.random();
sum += theta_kt[i][j];
}
for (int j = 0; j < len; j++) {// 词
theta_kt[i][j] /= sum;
}
}
return theta_kt;
}


static double[][] init_pdn_theta_k(int D, int K) {
double[][] pdn_theta_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double val = (double) 1 / K;
for (int k = 0; k < K; k++) {// 主题
pdn_theta_k[i][k] = val;
}
}
return pdn_theta_k;
}


static double[][] init_gnk(int D, int K) {
double[][] g_n_k = new double[D][K];
for (int i = 0; i < D; i++) {// 文档
double sum = 0;
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] = Math.random();
sum += g_n_k[i][k];
}
for (int k = 0; k < K; k++) {// 主题
g_n_k[i][k] /= sum;
}
}
return g_n_k;
}


static void out(int D, int K, int[][] matrixA, double[][] g_n_k) {
int[][] retDistribution = new int[K][K];// 文档主题的结果分布表
for (int i = 0; i < K; i++) {// 主题
for (int j = 0; j < K; j++) {// 主题
retDistribution[i][j] = 0;
}
}


for (int i = 0; i < D; i++) {// 文档
System.out.println();
for (int k = 0; k < K; k++) {// 主题
System.out.print("," + g_n_k[i][k]);
}
}
System.out.println();


for (int i = 0; i < D; i++) {// 文档
double max_g_n_k = 0;
int cur_k = 0;
for (int k = 0; k < K; k++) {// 主题
if (g_n_k[i][k] > max_g_n_k) {
max_g_n_k = g_n_k[i][k];
cur_k = k;
}
}
retDistribution[cur_k][matrixA[i][matrixA[i].length - 1]]++;
}


// 输出结果
System.out.println("=============================");
System.out.print("\t");
for (int i = 0; i < K; i++) {// 主题
System.out.print("cls" + i + "\t");
}
System.out.println();


for (int i = 0; i < K; i++) {// 主题
System.out.print("newCls" + i);
for (int j = 0; j < K; j++) {// 主题
System.out.print("\t" + retDistribution[i][j]);
}
System.out.println();
}
System.out.println("=============================");
System.out.println("the end.");
}
}

zkq_1986
关注
专栏目录
肤色检测算法 - 基于二次多项式混合模型的肤色检测
wenyusuran的专栏
10-31 1488
1、二次多项式混合模型            二次多项式混合模型首先有SORIANO提出，此后CHIANG对此进行了改进。改进后的模型由两个R-G平面的二次多项式和一个圆方程构成： 　　　　　　 　　在以上三个方程的基础上，肤色区域可以通过一下规则实现：                      上述算法的参考论文：Adaptive skin color modeli
Dirichlet Multinomial Mixtures (DMM)的R实现
Christina
11-30 4176
Dirichlet Multinomial Mixtures Community typing with Dirichlet Multinomial Mixtures Dirichlet Multinomial Mixtures (DMM)是一种用于对微生物群落分析数据进行群落分型（或聚类）的概率方法。 这是一个无限的混合模型，这意味着该方法可以推断出最佳数量的群落类型。 请注意，群落类型的数量可能会随数据大小而增长。 library(microbiome) library(DirichletMu.
机器学习-EM算法\混合模型
Burtan的专栏
06-03 849
KDD 2014 “A Dirichlet Multinomial Mixture Model-based Approach for Short Text Clustering” 的主要思想
yueliangku的专栏
01-15 3205
这几天在做短文本主题发现时，考虑使用聚类算法不同一主题的文本聚集到一块，因此读了这篇论文： A Dirichlet Multinomial Mixture Model-based Approach for Short Text Clustering 在该文中，作者使用“a collapsed Gibbs Sampling algorithm for the Dirichlet Multinom
基于狄利克雷-多项式分布做文档聚类代码(dirichlet multinomial mixture model)
qy20115549的博客
03-05 3912
论文来源Yin J, Wang J. A dirichlet multinomial mixture model-based approach for short text clustering[C]//Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining.
Dirichlet Multinomial Mixture Model做短文本聚类
qy20115549的博客
03-03 3894
论文来源Yin J, Wang J. A dirichlet multinomial mixture model-based approach for short text clustering[C]//Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining.
基于模型的文本聚类算法研究_尹建华_第4章_基于狄利克雷过程多项式混合模型的文本聚类算法_51_77.caj
04-17
基于模型的文本聚类算法研究_尹建华_第4章_基于狄利克雷过程多项式混合模型的文本聚类算法_51_77.caj
多项式混合系统的近似模型
04-13
文章标题《多项式混合系统的近似模型》和其描述指明了本文研究的焦点是对混合系统（hybrid systems）的近似模拟技术。混合系统是指同时具有连续动态和离散事件的复杂系统，在机器人学、自动化控制等领域有着广泛的...
论文研究-基于Legendre正交多项式非参数混合模型的图像分割.pdf
07-22
针对有限混合模型中参数估计方法对先验假设存在过分依赖的问题，提出了一种非参数的Legendre正交多项式图像混合模型分割方法。首先，设计了一种基于Legendre正交多项式的图像非参数混合模型，并用最小均方差(MISE)...
线性切换系统的矩阵系数多项式描述模型
01-15
此外，给出的内容中还提到了一些参考文献，这些文献可能提供了矩阵系数多项式技术模型在理论上的进一步阐述和实际应用案例，可能涉及混合系统的进一步讨论，例如文献[1-4]，以及对于切换系统和混合动态系统建模的...
LDA主题模型参数推导-dirichlet-multinomial model posterior
03-10 975
LDA理论参考： http://blog.csdn.net/v_july_v/article/details/41209515 http://www.xperseverance.net/blogs/2012/03/17/ http://blog.csdn.net/yangliuy/article/details/8302599 迪拉格雷-多项式分布模型(dirichle
Dirichlet分布与Multinomial分布
ss654271961的博客
10-20 1737
Dirichlet分布其实也是采样出一个值（向量），从这个意义上来说，它其实和其它分布并无太大不同？那为什么大家都说Dirichlet分布式分布的分布呢？因为Dirichlet分布出现的场景，总是用于生成别的分布（更确切地说，总是用于生成Multinomial分布） Dirichlet分布得到的向量各个分量的和是1，这个向量可以作为Multinomial分布的参数，所以我们说Dirichlet能
狄利克雷混合模型/Stick- breaking模型/非参数先验分布-2021年12月18日
weixin_51879748的博客
12-20 596
Nature Microbiology：肠道菌群如何划分肠型
刘永鑫的博客——宏基因组公众号
01-25 1万+
题目：基于肠道菌群组成的“肠型”如何定义？ 认识肠道菌群领域的29位大佬，从熟悉他们的名字和单位开始。 作者：Paul I. Costea 1, Falk Hildebrand 1,2,3, Arumugam Manimozhiyan 4, Fredrik Bäckhed 5,6, Martin J. Blaser 7, Frederic D. Bushman 8, Willem M. de
dirichlet mixture process
xyqzki的专栏
10-13 870
仅仅是把z的选取 从以前的multinomial 分布改成了，condition on previous z与 G的分布，这个分布可以用CRP， or stick construction来刻画
r语言ggplot画两条曲线_技术贴 | R语言——肠型分析：介绍、方法
weixin_39820997的博客
11-20 838
点击蓝字↑↑↑“微生态”，轻松关注不迷路导读2011年，肠型(Enterotypes)的概念首次在《自然》杂志上由Arumugam等【1】提出，该研究发现可以将人类肠道微生物组分成稳定的3种类型，因为这3种类型不受年龄、性别、体重以及地域限制，表现出较高的稳定性，与血型具有很高的相似性，所以将其定义为肠型。后来的有的研究称发现2种肠型，也有称发现4种，这引起了国际上对于肠型概念的广泛讨论...
关于Dirichlet过程混合模型（DPMM）的理解
sysuhu的博客
01-12 1万+
由CRP构造DPMM关于中餐馆过程可见《由中餐馆过程（CRP）理解狄利克雷过程（DP）》http://blog.csdn.net/sysuhu/article/details/53725696 而Dirichlet过程混合模型（DPMM）就是把CRP中的DP整个作为某一分布的先验来处理 用图模型表示如下 这里的FF则根据具体的问题而定，一般尽量使FF与GG是共轭的，以便于计算。由S
多项式模型与多项式拟合
cjm_success的博客
08-17 1万+
3. 多项式模型 (一元多次方程) 3.1 多项式拟合 在有些数据分布中，使用一条曲线比直线能更好拟合数据，这就需要用到多项式拟合。如下图所示分布： 多项式的一般形式： y=p0xn+p1xn−1+p2xn−2+p3xn−3+...+pn y=p_{0}x^n + p_{1}x^{n-1} + p_{2}x^{n-2} + p_{3}x^{n-3} +...+p_{n} y=p0​xn+p1​xn−1+p2​xn−2+p3​xn−3+...+pn​ 多项式拟合的目的是为了找到一组 p0,p1,...,p
线性线性混合效应模型及R语言实现
热门推荐
weixin_40645816的博客
08-27 4万+
1.A very basic tutorial for performing linear mixed effects analyses（入门极品） Tutorial 1: http://www.bodowinter.com/tutorial/bw_LME_tutorial1.pdf Tutorial 2: http://www.bodowinter.com/tutorial/bw_LME_t...
基于样本图像的多项式混合反射模型及其参数测量
实验部分，作者针对金属表面进行了实际操作，通过比较由新方法生成的合成图像与实际获取的图像，结果显示，提出的多项式混合模型能够更准确地模拟和测量样本的反射特性。具体参数，如100.2960、120.5820、160.4760、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值