potentialor.java

是实现关系型贝叶斯网络一中机器学习算法

package rmn;

import java.util.*;

public class PotentialOr extends Potential {

  // first assigned variable is always the "or" variable
  // rest of assigned variables are the "or" arguments

  public PotentialOr(PotentialFactory pf)
  {
    super(pf);
  }


  public boolean sendMsgToVars(boolean bMaximize)
  {
    boolean bConverged = true;

    // locate potential weights
    Matrix2 matrix = (Matrix2) getWeightMatrix();
    double[][] weights = matrix.m_matrix;

    // locate "or" variable, create message
    Variable varOr = m_vars[0];
    double[] msgOr = varOr.newMessage();

    // compute compressed sum-products
    double msg_0 = 1.0;
    for (int v = 1; v < m_vars.length; v++) {
      Variable varArg = m_vars[v];
      double[] matArg = varArg.getOldMessage(this);
      msg_0 = msg_0 * matArg[0];
    }
    double msg_1 = 1.0 - msg_0;

    // compute "or" variable messages
    msgOr[0] = msg_0 * weights[0][0] + msg_1 * weights[0][1];
    msgOr[1] = msg_0 * weights[1][0] + msg_1 * weights[1][1];

    MathUtils.normalize(msgOr);
    setMessage(0, msgOr);

    // need more time?
    if (!MathUtils.approxeq(getMessage(0), getOldMessage(0), FactorGraph.TOLERANCE))
      bConverged = false;
    
    // compute "or" arguments messages
    double[] oldOr = varOr.getOldMessage(this);
    for (int v = 1; v < m_vars.length; v++) {
      Variable varArg = m_vars[v];
      double[] matArg = varArg.getOldMessage(this);
      double m_0;
      if (matArg[0] != 0)
	m_0 = msg_0 / matArg[0];
      else {
	m_0 = 1.0;
	for (int vv = 1; vv < m_vars.length; vv++)
	  if (vv != v) {
	    Variable varvar = m_vars[vv];
	    double[] matmat = varvar.getOldMessage(this);
	    m_0 = m_0 * matmat[0];
	  }
      }
      double m_1 = 1 - m_0;
      
      // compute variable messages
      double msgArg[]= varArg.newMessage();
      msgArg[0] = 
	m_0 * oldOr[0] * weights[0][0] + m_1 * oldOr[0] * weights[0][1] +
	m_0 * oldOr[1] * weights[1][0] + m_1 * oldOr[1] * weights[1][1];
      msgArg[1] = 
	m_0 * oldOr[0] * weights[0][1] + m_1 * oldOr[0] * weights[0][1] +
	m_0 * oldOr[1] * weights[1][1] + m_1 * oldOr[1] * weights[1][1];

      MathUtils.normalize(msgArg);
      setMessage(v, msgArg); 

      // need more time?
      if (!MathUtils.approxeq(getMessage(v), getOldMessage(v), FactorGraph.TOLERANCE))
	bConverged = false;
    }
    
    return bConverged;
  }
  

}