卜若的代码笔记-算法系列-第2个算法案例分析：HHM预测模型分析

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;
    }



}