matrix2.java

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

package rmn;

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

public class Matrix2 implements Matrix {

  public double[][] m_matrix;

  public Matrix2()
  {
  }

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

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

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

  public Matrix getCopy()
  {
    return new Matrix2(this);
  }
  
  public Matrix newMatrix()
  {
    Matrix2 m = new Matrix2();
    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];

    return m;
  }

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

  public int size()
  {
    return 2;
  }

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

    return dims; 
  }

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

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


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

    for (int i = 0; i < dims[0]; i++)
      for (int j = 0; j < dims[1]; j++) {
	double grad = (m1.m_matrix[i][j] - m2.m_matrix[i][j]) * rate;
        m_matrix[i][j] = m_matrix[i][j] * Math.exp(grad);
	assert !Double.isNaN(m_matrix[i][j]) : grad;
	assert !Double.isInfinite(m_matrix[i][j]) : grad;
      }
  }

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

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

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

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


  public void dotProduct(Matrix matrix)
  {
    Matrix2 matrix2 =  (Matrix2) matrix;
    int[] dims = getDimensions();
    int[] dimsm = matrix2.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++) {
        m_matrix[i][j] = m_matrix[i][j] * matrix2.m_matrix[i][j];
	assert !Double.isNaN(m_matrix[i][j]) : matrix2.m_matrix[i][j];
	assert !Double.isInfinite(m_matrix[i][j]) : matrix2.m_matrix[i][j];
      }
  }


  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};
    for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
      for (idx[1] = 0; idx[1] < dims[1]; idx[1]++) {
	double old = m_matrix[idx[0]][idx[1]];
        m_matrix[idx[0]][idx[1]] = m_matrix[idx[0]][idx[1]] * vector[idx[dim]];
	assert !Double.isNaN(m_matrix[idx[0]][idx[1]]);
	assert !Double.isInfinite(m_matrix[idx[0]][idx[1]]);
      }
  }

  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};
    for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
      for (idx[1] = 0; idx[1] < dims[1]; idx[1]++) {
        m_matrix[idx[0]][idx[1]] = m_matrix[idx[0]][idx[1]] / vector[idx[dim]];
	assert vector[idx[dim]] != 0;
	assert !Double.isNaN(m_matrix[idx[0]][idx[1]]);
	assert !Double.isInfinite(m_matrix[idx[0]][idx[1]]);
      }
  }
  
  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 - ? compare with learning results
    Arrays.fill(margin, 0);

    try {
      int idx[] = {0, 0};
      for (idx[0] = 0; idx[0] < dims[0]; idx[0]++)
        for (idx[1] = 0; idx[1] < dims[1]; idx[1]++) {
	  /*
          Object[] params = {new Double(margin[idx[dim]]),
                             new Double(m_matrix[idx[0]][idx[1]])};
          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]]);
	  else
	    margin[idx[dim]] += m_matrix[idx[0]][idx[1]];
	  
	  assert !Double.isNaN(margin[idx[dim]]);
	  assert !Double.isInfinite(margin[idx[dim]]);
        }
    }
    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++)
	strRes += String.valueOf(m_matrix[i][j]) + " ";
      strRes += "\n";
    }

    return strRes;
  }

}