matrix3.java

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

package rmn;

import java.util.*;
import java.lang.reflect.*;

public class Matrix3 implements Matrix {

  public double[][][] m_matrix;

  public Matrix3()
  {
  }

  public Matrix3(int nCard1, int nCard2, int nCard3)
  {
    m_matrix = new double[nCard1][nCard2][nCard3];
  }

  public Matrix3(double[][][] matrix)
  {
    m_matrix = matrix;
  }

  public Matrix3(Matrix3 matrix3)
  {
    m_matrix = new double[matrix3.m_matrix.length][][];
    for (int i = 0; i < m_matrix.length; i++) {
      m_matrix[i] = new double[matrix3.m_matrix[i].length][];
      for (int j = 0; j < m_matrix[i].length; j++) {
        m_matrix[i][j] = new double[matrix3.m_matrix[i][j].length];
        System.arraycopy(matrix3.m_matrix[i][j], 0, m_matrix[i][j], 0, 
                         m_matrix[i][j].length);
      }
    }
  }

  public Matrix getCopy()
  {
    return new Matrix3(this);
  }
  
  public Matrix newMatrix()
  {
    Matrix3 m = new Matrix3();
    m.m_matrix = new double[m_matrix.length][][];
    for (int i = 0; i < m_matrix.length; i++) {
      m.m_matrix[i] = new double[m_matrix[i].length][];
      for (int j = 0; j < m_matrix[i].length; j++)
        m.m_matrix[i][j] = new double[m_matrix[i][j].length];
    }

    return m;
  }

  public void fill(double val)
  {
    for (int i = 0; i < m_matrix.length; i++)
      for (int j = 0; j < m_matrix[i].length; j++)
        Arrays.fill(m_matrix[i][j], val);
  }

  public int size()
  {
    return 3;
  }

  public int[] getDimensions()
  {
    int[] dims = new int[size()];
    dims[0] = m_matrix.length;
    dims[1] = m_matrix[0].length;
    dims[2] = m_matrix[0][0].length;

    return dims; 
  }

  public void inc(int[] pos)
  {
    assert pos.length == size() : pos.length;

    m_matrix[pos[0]][pos[1]][pos[2]]++;
  }


  public void add_sub(Matrix matrix1, Matrix matrix2, double rate)
  {
    Matrix3 m1 =  (Matrix3) matrix1;
    Matrix3 m2 =  (Matrix3) matrix2;
    int[] dims = getDimensions();

    for (int i = 0; i < dims[0]; i++)
      for (int j = 0; j < dims[1]; j++)
        for (int k = 0; k < dims[2]; k++) {
	  double grad = (m1.m_matrix[i][j][k] - m2.m_matrix[i][j][k]) * rate;
          m_matrix[i][j][k] = m_matrix[i][j][k] * Math.exp(grad);
	}
  }


  public void add_log(Matrix matrix, int delta)
  {
    Matrix3 m =  (Matrix3) matrix;
    int[] dims = getDimensions();

    for (int i = 0; i < dims[0]; i++)
      for (int j = 0; j < dims[1]; j++)
        for (int k = 0; k < dims[2]; k++) {
	  m_matrix[i][j][k] = m_matrix[i][j][k] + delta * Math.log(m.m_matrix[i][j][k]);
	}
  }

  public Matrix exp_avg(int n)
  {
    Matrix3 m = (Matrix3) newMatrix();
    int[] dims = getDimensions();

    for (int i = 0; i < dims[0]; i++)
      for (int j = 0; j < dims[1]; j++)
        for (int k = 0; k < dims[2]; k++) {
	  m.m_matrix[i][j][k] = Math.exp(m_matrix[i][j][k] / n);
	}
    
    return m;
  }


  public void dotProduct(Matrix matrix)
  {
    Matrix3 matrix3 =  (Matrix3) matrix;
    int[] dims = getDimensions();
    int[] dimsm = matrix3.getDimensions();
    
    // dimensions should match
    for (int i = 0; i < dims.length; i++)
      assert dimsm[i] == dims[i] : dimsm[i];

    for (int i = 0; i < dims[0]; i++)
      for (int j = 0; j < dims[1]; j++)
        for (int k = 0; k < dims[2]; k++)
          m_matrix[i][j][k] = m_matrix[i][j][k] * matrix3.m_matrix[i][j][k];
  }


  public void dotProduct(double[] vector, int dim)
  {
    assert dim < size() : dim;
    int[] dims = getDimensions();
    assert vector.length == dims[dim] : vector.length;

    int idx[] = {0, 0, 0};
    for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
      for (idx[1] = 0; idx[1] < dims[1]; idx[1]++)
        for (idx[2] = 0; idx[2] < dims[2]; idx[2]++)
          m_matrix[idx[0]][idx[1]][idx[2]] = 
            m_matrix[idx[0]][idx[1]][idx[2]] * vector[idx[dim]];
  }

  public void dotQuotient(double[] vector, int dim)
  {
    assert dim < size() : dim;
    int[] dims = getDimensions();
    assert vector.length == dims[dim] : vector.length;

    int idx[] = {0, 0, 0};
    for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
      for (idx[1] = 0; idx[1] < dims[1]; idx[1]++)
        for (idx[2] = 0; idx[2] < dims[2]; idx[2]++)
          m_matrix[idx[0]][idx[1]][idx[2]] = 
            m_matrix[idx[0]][idx[1]][idx[2]] / vector[idx[dim]];
  }
  
  public double[] marginalize(int dim, boolean bMaximize)
  {
    assert dim < size() : dim;
    //    Method sumOrMax = MathUtils.getSumOrMax(bMaximize);
    int[] dims = getDimensions();    
    double[] margin = new double[dims[dim]];
    // assume positive potentials
    Arrays.fill(margin, 0);

    try {
      int idx[] = {0, 0, 0};
      for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
        for (idx[1] = 0; idx[1] < dims[1]; idx[1]++)
          for (idx[2] = 0; idx[2] < dims[2]; idx[2]++) {
	    /*
            Object[] params = {new Double(margin[idx[dim]]),
                               new Double(m_matrix[idx[0]][idx[1]][idx[2]])};
            margin[idx[dim]] = ((Double) sumOrMax.invoke(null,
							 params)).doubleValue();
	    */
	    if (bMaximize)
	      margin[idx[dim]] = Math.max(margin[idx[dim]],
					  m_matrix[idx[0]][idx[1]][idx[2]]);
	    else
	      margin[idx[dim]] += m_matrix[idx[0]][idx[1]][idx[2]];
          }
    }
    catch (Exception e) {
      System.err.println(e);
      System.exit(1);
    }
    
    return margin;
  }

  public String toString()
  {
    String strRes = new String();
    for (int i = 0; i < m_matrix.length; i++) {
      for (int j = 0; j < m_matrix[i].length; j++) {
	for (int k = 0; k < m_matrix[i][j].length; k++)
	  strRes += String.valueOf(m_matrix[i][j][k]) + " ";
	strRes += "\n";
      }
      strRes += "\n";
    }
    
    return strRes;
  }
}