1. 关于这个模型就去看
https://www.cnblogs.com/pinard/p/6991852.html
这篇博客吧...我主要是将这个它的那个案例画了一张图
案例代码:
package com.company;
import java.util.Stack;
public class HHMPreditionModel {
public static final String whiteBall = "白球";
public static final String redBall = "红球";
/**
* 状态转移概率
*/
public double[][] hideProbMatrix;
/**
* 观测状态概率
*/
public double[][] viewStateMatrix;
/**
* 初始状态
*/
public double[] initState;
/**
* 观测状态
*/
public HPMpoint[] viewStatue;
/**
* 状态集合,在HMM这个例子中指的就是取出来的三个箱子
*/
public HPMpoint[] stateSet;
public double[] getViewProb(String color){
double[] probSet = new double[stateSet.length];
if (color == "白球"){
for (int i =0;i<stateSet.length;i++){
probSet[i] = viewStateMatrix[i][1];
}
}
if (color == "红球"){
for (int i =0;i<stateSet.length;i++){
probSet[i] = viewStateMatrix[i][0];
}
}
return probSet;
}
public void initData(){
hideProbMatrix = new double[][]{
{0.5,0.2,0.3},
{0.3,0.5,0.2},
{0.2,0.3,0.5}
};
viewStateMatrix = new double[][]{
{0.5,0.5},
{0.4,0.6},
{0.7,0.3}
};
initState = new double[]{0.2,0.4,0.4};
viewStatue = new HPMpoint[]{
new HPMpoint().setColor("红球").setIndex(0),
new HPMpoint().setColor("白球").setIndex(1),
new HPMpoint().setColor("红球").setIndex(2)
};
stateSet = new HPMpoint[]{
new HPMpoint().setBoxes("箱子1").setIndex(0),
new HPMpoint().setBoxes("箱子2").setIndex(1),
new HPMpoint().setBoxes("箱子3").setIndex(2)
};
}
public HPMpoint[] layerOP(int layer,HPMpoint[] lastLayer){
HPMpoint[] preLayer = new HPMpoint[lastLayer.length];
for (int i =0;i<preLayer.length;i++){
preLayer[i] = new HPMpoint().setBoxes(lastLayer[i].boxes)
.setBoxesType(lastLayer[i].boxesType);
double[] viewProbSet = getViewProb(viewStatue[layer].color);
/**
* 1.这里的i代表的是求当前的箱子
* 2.当前箱子需要前面三个箱子同时进行受孕(传递隐藏概率)
* 3.hideProbMatrix的每一行也就是hideProbMatrix[i]代表的是给0,1,2号箱子受孕的集合
* 举个例子,我们现在让当前的0号箱子被受孕,也就是需要
* hideProbMatrix[0][0]
* hideProbMatrix[1][0]
* hideProbMatrix[2][0]
* 对这个箱子进行受孕
* 可以描述为hideProbMatrix[j][i]
*/
double maxProb = 0;
double viewProb = viewProbSet[i];
HPMpoint preditModel = new HPMpoint();
for (int j = 0;j<lastLayer.length;j++){
double hideProp = hideProbMatrix[j][i];
double inheritProb = lastLayer[j].prob*hideProp;
if (maxProb<inheritProb){
maxProb = inheritProb;
preditModel = lastLayer[j];
}
}
System.out.println("layer 继承概率:"+(float)maxProb+"<><><>"+(float)viewProb);
preLayer[i].setProb(0,0,
maxProb*viewProb).setLastLayer(lastLayer)
.setBoxes(preditModel.boxes);
}
return preLayer;
}
public HPMpoint[] genNextViewLayer(HPMpoint parent){
HPMpoint[] temp = new HPMpoint[viewStatue.length];
/**
* 观测概率
*/
double[] viewProbSet = getViewProb(viewStatue[parent.viewSteps+1].color);
/**
* 隐藏概率
*/
double[] hideProbSet = hideProbMatrix[parent.boxesType];
for (int i =0;i<stateSet.length;i++){
// System.out.println("---观测概率"+viewProbSet[i]);
// System.out.println("---隐藏概率"+hideProbSet[i]);
temp[i] = new HPMpoint().
setBoxes(stateSet[i].boxes)
.setIndex(stateSet[i].index)
.setProb(viewProbSet[stateSet[i].index],
hideProbSet[stateSet[i].index],
viewProbSet[stateSet[i].index]*hideProbSet[stateSet[i].index]*parent.prob
).setViewSteps(parent.viewSteps+1)
.setParent(parent);
}
return temp;
}
public HPMpoint[] initViewLayer(int viewSteps){
HPMpoint[] temp = new HPMpoint[stateSet.length];
HPMpoint viewPoint = viewStatue[viewSteps];
double[] viewProbSet = getViewProb(viewStatue[viewSteps].color);
double[] hideProbSet = initState;
for (int i =0;i<temp.length;i++){
System.out.println("观测概率"+viewProbSet[i]);
temp[i] = new HPMpoint().setProb(viewProbSet[i],hideProbSet[i],
viewProbSet[i]*hideProbSet[i]
).setBoxes(stateSet[i].boxes).setViewSteps(viewSteps).setBoxesType(i)
;
}
return temp;
}
public HPMpoint layerMaxPoint(HPMpoint[] layer){
HPMpoint pre = layer[0];
for (int i =0;i<layer.length;i++){
System.out.println(layer[i].prob);
if (pre.prob<layer[i].prob){
pre = layer[i];
}
}
return pre;
}
public static void main(String[] arg){
HHMPreditionModel md = new HHMPreditionModel();
md.initData();
HPMpoint[] layer1 = md.initViewLayer(0);
HPMpoint[] layer2 = md.layerOP(1,layer1);
HPMpoint[] layer3 = md.layerOP(2,layer2);
HPMpoint layerMax = md.layerMaxPoint(layer3);
Stack answerStack = new Stack();
/**
* 动态规划max
*/
while (layerMax!= null){
answerStack.push(layerMax);
System.out.println(layerMax.boxes);
if (layerMax.lastLayer== null){
break;
}
layerMax = md.layerMaxPoint(layerMax.lastLayer);
}
System.out.println(answerStack.size());
}
}
class HPMpoint{
public String color;
public int index;
public String boxes;
public int boxesType;
public HPMpoint[] lastLayer;
public HPMpoint setLastLayer(HPMpoint[] la){
this.lastLayer = la;
return this;
}
public HPMpoint setBoxesType(int boxesType){
this.boxesType = boxesType;
return this;
}
public HPMpoint setParent(HPMpoint parent){
this.parent = parent;
return this;
}
/**
* 观测概率
*/
public double viewProb;
/**
* 隐藏概率
*/
public double hideProb;
/**
* 最终概率
*/
public double prob;
/**
*
* 第几次观测,和观测数据有关
*/
public int viewSteps;
public HPMpoint setViewSteps(int viewSteps){
this.viewSteps = viewSteps;
return this;
}
/**
*
* @param viewProb 观测概率
* @param hideProb 隐藏概率
* @param prob 最终概率
* @return
*/
public HPMpoint setProb(double viewProb,double hideProb,double prob){
this.viewProb = viewProb;
this.hideProb = hideProb;
this.prob = prob;
return this;
}
public HPMpoint(){
}
public HPMpoint setBoxes(String v1){
this.boxes = v1;
return this;
}
public HPMpoint setColor(String v1){
this.color = v1;
return this;
}
public HPMpoint parent;
public HPMpoint setIndex(int index){
this.index = index;
return this;
}
}