baumwelch算法

❶ 怎么将baum-welch算法运用于室内定位csdn

怎么将baum-welch算法运用于室内定位csdn
这是一段程序中的代码：
int randomNumber=(int)(Math.random()*8)+1;
所给出的注释是：得到一个1到8之间的随机整数。开始的时候不是很懂，于是翻书、上网找资料，但是得到的结果都是一样的。Math.random()的作用是得到0-1之间的随机数。那么是如何实现的呢？
仔细想一想其实并不是很复杂：Math.random()的取值应该是0-1（事实上取不到0和1）之间的随机小数，乘以8之后应该是0-8之间的随机小数，也就是0.****到7.****之间的小数（大于0而小于8），经过int类型转换之后，应该是0-7之间的随机整数，所以"+1"之后就会得到1－8之间的

❷ Baum-Welch是什么

鲍姆-韦尔奇
这是两个人
杰克·韦尔奇 1935年11月19日生于马萨诸塞州萨兰姆市，1957年获得马萨诸塞州大学化学工程学士学位，1960年获得伊利诺斯大学化学工程博士学位。
鲍姆这个人不大清楚
HMM模型中的C语言有种Baum-Welch算法 非常有名 翻译的时候翻译为中文名我想就可以了

❸ 怎么判断 baum-welch算法收敛

1：先判断是否收敛。 2：如果收敛，且为交错级数，则绝对收敛。 其实就是交错级数如果加绝对值收敛则为条件收敛，如果交错级数不加绝对值也收敛，则为绝对收敛。

❹ 如何证明并直观理解Baum-Welch算法中这一等式

事实

❺ 哪些算法让你感觉醍醐灌顶

整数因子分解的Pallord-Rho算法。差不多是O(n^0.25)效率，n是数的大小（所以对位数的话就指数级别了）
这个算法本身其实到还不算醍醐灌顶。重点在其中的一个优化：在一个环中如果一个人以1的速度另一个人以2的速度（同向），那么他们必然相遇。虽然简单，但是异常漂亮^^

我觉得, 醍醐灌顶的, 当属 并查集和动态规划. 并查集的路径压缩 至今我认为是我看过里最简洁最优美的设计. 而动态规划, 在我心里是一种很务实, 很有教育意义的算法, "步步最优并非结果最优", "Trade－off", 等等． 这两个, 对我而言, 确实是醍醐灌顶的.

❻ barra em算法 估计 什么参数

baum-welch算法是一种对hmm模型做参数估计的方法，是EM算法的一个特例。
前向后向算法是已知模型和序列求概率的算法，也是用于训练的Baum-Welch算法的循环中的一个步骤。

❼ 哪些算法曾让你感觉醍醐灌顶

贝叶斯定理
比如这样一个问题：你喜欢上一个人的概率，你觉得一个人某方面好的概率，你喜欢上一个人然后觉得这个人某方面好的概率，你觉得一个人某方面好然后喜欢上这个人的概率，这4个之间有什么关系呢？
用数学语言表达：P(喜欢上一个人), P(觉得一个人某方面好), P(觉得这个人某方面好|喜欢上一个人) 和 P(喜欢上这个人|觉得一个人某方面好) 有什么关系呢？
我们生活中遇到的很多概率其实都是条件概率/后验概率(在某一条件下成立的事件的概率)，贝叶斯定理揭示了不同的条件概率之间的关系: )
一瞬间，感觉让你发现了世界运行了某些奥秘
KMP非常优美，SIFT 图像匹配算法很强大，plsa语义相似度计算也让我震撼，不过最让我震撼的还是mathematica里的fullsimplify背后的算法。
Fullsimplify这玩意能搞定很多人都搞不定的公式，我说的搞不定是指该问题本身人可以在三五步之内求解，但却是很难求解的问题，例如某些三角函数的积分需要巧妙地作换元积分才能得解。
从思想上看，最深刻的是递归，以及求泛函极值的最小作用量。基于这两种思想的算法，比如快排、HMM中的Baum-Welch，都是精美的算法，但背后的思想根基并非首创。动态规划、蒙特卡洛类的算法也属此列。
此外，有“道法自然”意味的模拟退火、蚁群、遗传、粒子群这些，思想方法上有创新，但是算法设计上与神经网络、SVM、HMM相比，就略显粗糙。

❽ baumwelch算法用到数据了吗

我简单地介绍了隐马尔科夫模型HMM，并且重点介绍了HMM的三个问题中的第一个，即概率计算问题。首先回顾一下这三个问题都是什么以及解决每个问题的主流算法：

概率计算问题即模型评价问题——前向算法和后向算法
学习问题即参数估计问题——Baum-Welch算法
预测问题即解码问题——Viterbi算法
在上一篇概率计算问题的最后，我列出了几个用前向概率和后向概率表示的一些有意义的概率值和期望的计算，它们的直接意义就是用于表示学习问题和预测问题公式推导中复杂的中间结果的表示。所以，要想彻底搞懂Baum-Welch算法和Viterbi算法算法，就必须清楚地明白这些概率和期望到底是怎么计算出来的。

然而，本博文并不打算将这两个算法全部的公式推导写下来，那太繁杂了。如果想窥探这两个算法的细节，直接看李航博士的《统计学习方法》对应的内容就好了。本文只是将这两个算法推导中的一些隐晦的地方做一个通俗的解释，希望能给像我一样数学功底一般的朋友带来帮助。

❾ 谁做过 EM算法 java实现

参考：

packagenlp;
/**
*@authorOrisun
*date2011-10-22
*/
importjava.util.ArrayList;

publicclassBaumWelch{

intM;//隐藏状态的种数
intN;//输出活动的种数
double[]PI;//初始状态概率矩阵
double[][]A;//状态转移矩阵
double[][]B;//混淆矩阵

ArrayList<Integer>observation=newArrayList<Integer>();//观察到的集合
ArrayList<Integer>state=newArrayList<Integer>();//中间状态集合
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};//测试用的隐藏状态序列
intT=32;//序列长度为32

double[][]alpha=newdouble[T][];//向前变量
doublePO;
double[][]beta=newdouble[T][];//向后变量
double[][]gamma=newdouble[T][];
double[][][]xi=newdouble[T-1][][];

//初始化参数。Baum-Welch得到的是局部最优解，所以初始参数直接影响解的好坏
publicvoidinitParameters(){
M=2;
N=2;
PI=newdouble[M];
PI[0]=0.5;
PI[1]=0.5;
A=newdouble[M][];
B=newdouble[M][];
for(inti=0;i<M;i++){
A[i]=newdouble[M];
B[i]=newdouble[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(intt=0;t<T;t++){
alpha[t]=newdouble[M];
beta[t]=newdouble[M];
gamma[t]=newdouble[M];
}
for(intt=0;t<T-1;t++){
xi[t]=newdouble[M][];
for(inti=0;i<M;i++)
xi[t][i]=newdouble[M];
}
}

//更新向前变量
publicvoipdateAlpha(){
for(inti=0;i<M;i++){
alpha[0][i]=PI[i]*B[i][observation.indexOf(out_seq[0])];
}
for(intt=1;t<T;t++){
for(inti=0;i<M;i++){
alpha[t][i]=0;
for(intj=0;j<M;j++){
alpha[t][i]+=alpha[t-1][j]*A[j][i];
}
alpha[t][i]*=B[i][observation.indexOf(out_seq[t])];
}
}
}

//更新观察序列出现的概率，它在一些公式中当分母
publicvoipdatePO(){
for(inti=0;i<M;i++)
PO+=alpha[T-1][i];
}

//更新向后变量
publicvoipdateBeta(){
for(inti=0;i<M;i++){
beta[T-1][i]=1;
}
for(intt=T-2;t>=0;t--){
for(inti=0;i<M;i++){
for(intj=0;j<M;j++){
beta[t][i]+=A[i][j]
*B[j][observation.indexOf(out_seq[t+1])]
*beta[t+1][j];
}
}
}
}

//更新xi
publicvoipdateXi(){
for(intt=0;t<T-1;t++){
doublefrac=0.0;
for(inti=0;i<M;i++){
for(intj=0;j<M;j++){
frac+=alpha[t][i]*A[i][j]
*B[j][observation.indexOf(out_seq[t+1])]
*beta[t+1][j];
}
}
for(inti=0;i<M;i++){
for(intj=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
publicvoipdateGamma(){
for(intt=0;t<T-1;t++){
doublefrac=0.0;
for(inti=0;i<M;i++){
frac+=alpha[t][i]*beta[t][i];
}
//doublefrac=PO;
for(inti=0;i<M;i++){
gamma[t][i]=alpha[t][i]*beta[t][i]/frac;
}
//for(inti=0;i<M;i++){
//gamma[t][i]=0;
//for(intj=0;j<M;j++)
//gamma[t][i]+=xi[t][i][j];
//}
}
}

//更新状态概率矩阵
publicvoipdatePI(){
for(inti=0;i<M;i++)
PI[i]=gamma[0][i];
}

//更新状态转移矩阵
publicvoipdateA(){
for(inti=0;i<M;i++){
doublefrac=0.0;
for(intt=0;t<T-1;t++){
frac+=gamma[t][i];
}
for(intj=0;j<M;j++){
doubledem=0.0;
//for(intt=0;t<T-1;t++){
//dem+=xi[t][i][j];
//for(intk=0;k<M;k++)
//frac+=xi[t][i][k];
//}
for(intt=0;t<T-1;t++){
dem+=xi[t][i][j];
}
A[i][j]=dem/frac;
}
}
}

//更新混淆矩阵
publicvoipdateB(){
for(inti=0;i<M;i++){
doublefrac=0.0;
for(intt=0;t<T;t++)
frac+=gamma[t][i];
for(intj=0;j<N;j++){
doubledem=0.0;
for(intt=0;t<T;t++){
if(out_seq[t]==observation.get(j))
dem+=gamma[t][i];
}
B[i][j]=dem/frac;
}
}
}

//运行Baum-Welch算法
publicvoidrun(){
initParameters();
intiter=22;//迭代次数
while(iter-->0){
//E-Step
updateAlpha();
//updatePO();
updateBeta();
updateGamma();
updatePI();
updateXi();
//M-Step
updateA();
updateB();
}
}

publicstaticvoidmain(String[]args){
BaumWelchbw=newBaumWelch();
bw.run();
System.out.println("训练后的初始状态概率矩阵：");
for(inti=0;i<bw.M;i++)
System.out.print(bw.PI[i]+"	");
System.out.println();
System.out.println("训练后的状态转移矩阵：");
for(inti=0;i<bw.M;i++){
for(intj=0;j<bw.M;j++){
System.out.print(bw.A[i][j]+"	");
}
System.out.println();
}
System.out.println("训练后的混淆矩阵：");
for(inti=0;i<bw.M;i++){
for(intj=0;j<bw.N;j++){
System.out.print(bw.B[i][j]+"	");
}
System.out.println();
}
}
}