edu.berkeley.nlp.math.MatrixTreeTheorem Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of berkeleyparser Show documentation
The Berkeley parser analyzes the grammatical structure of natural language using probabilistic context-free grammars (PCFGs).
The newest version!
//
//package edu.berkeley.nlp.math;
//
//import Jama.Matrix;
//import Jama.EigenvalueDecomposition;
//import Jama.SingularValueDecomposition;
//import fig.basic.Pair;
//import fig.basic.NumUtils;
//
//import java.util.Arrays;
//
//import edu.berkeley.nlp.util.Logger;
//
///**
// * User: aria42
// * Date: Jan 13, 2009
// */
//public class MatrixTreeTheorem {
//
//  /**
//   * Computes sum over labeled trees. There is assumed to be a fixed
//   * number of labels possible for each edge.
//   *
//   * logPotentials[i][j][l] represents the logPotential (i,j)
//   * for the (i,j) attachment with label l. It's safe to have
//   * -inf as a value in this array to disallow attachments
//   * or labels
//   *
//   * Returns sum over labeled trees as well as posteriors
//   * stored in result.getSecond() 
//   * @param logPotentials
//   * @return
//   */
//  public static Pair
//  computeLabeledMultiRoot(double[][][] logPotentials)
//  {
//    int n = logPotentials.length;
//    int l = logPotentials[0][0].length;
//    double[][] collapsedLogPotentials = new double[n][n];
//    for (int i = 0; i < n; i++) {
//      for (int j = 0; j < n; j++) {
//        collapsedLogPotentials[i][j] = SloppyMath.logAdd(logPotentials[i][j]);
//      }
//    }
//    Pair result = computeMultiRoot(collapsedLogPotentials);
//    double sumTrees = result.getFirst();
//    double[][] collapsedPosteriors = result.getSecond();
//    double[][][] posteriors = new double[n][n][l];
//    for (int i = 0; i < n; i++) {
//      for (int j = 0; j < n; j++) {
//        double post = collapsedPosteriors[i][j];
//        double attachSum = collapsedLogPotentials[i][j];
//        for (int k = 0; k < l; k++) {
//          double labelProb = Math.exp(logPotentials[i][j][k]-attachSum);
//          posteriors[i][j][k] = labelProb * post;
//        }
//      }
//    }
//    return Pair.newPair(sumTrees,posteriors);
//  }
//
//  /**
//   * logPotentials[i][j] is the logPotential of attaching (i,j) where
//   * i \neq j. When i==j, this represents the root potentials. Note
//   * that this version allows multiple roots so it's not suitable
//   * for dependency parsing.
//   *
//   * Returns sum of weighted trees and posteriors over attachments
//   * again root posteriors are stored on the diagonal
//   * @param logPotentials
//   * @return
//   */
//  public static Pair computeMultiRoot(double[][] logPotentials)
//  {
//    int n = logPotentials.length;
//    double[][] potentials = new double[n][];
////    double max = Double.NEGATIVE_INFINITY;
////    for (int i = 0; i < n; i++) {
////      for (int j = 0; j < n; j++) {
////        if (logPotentials[i][j] < Double.POSITIVE_INFINITY) {
////          max = Math.max(logPotentials[i][j],max);
////        }
////      }
////    }
////    for (int i = 0; i < n; i++) {
////      for (int j = 0; j < n; j++) {
////        logPotentials[i][j] -= max;
////      }
////    }
//    for (int i = 0; i < n; i++) {
//      potentials[i] = DoubleArrays.exponentiate(logPotentials[i]);
//      DoubleArrays.checkValid(potentials[i]);
//      DoubleArrays.checkNonNegative(potentials[i]);
//    }
//    double[][] laplacian = new double[n][n];
//    for (int j = 0; j < n; j++) {
//      double sum = 0.0;
//      for (int i = 0; i < n; i++) {
//        sum += potentials[i][j];
//      }
//      for (int i = 0; i < n; i++) {
//        laplacian[i][j] = i == j ? sum : -potentials[i][j];
//      }
//    }
//    DoubleArrays.checkValid(laplacian);
//    Matrix L = new Matrix(laplacian);
//    SingularValueDecomposition svd = new SingularValueDecomposition(L);
//    Matrix U = svd.getU();
//    Matrix Sigma = svd.getS();
//    for (int i = 0; i < n; i++) {
//      double s= Sigma.get(i,i);
//      Sigma.set(i,i, s > 0.0 ? 1.0/s : s);
//    }
//    Matrix V = svd.getV();
//    Matrix Linv = V.times(Sigma).times(U.transpose());
//    EigenvalueDecomposition evd = L.eig();
//    //Matrix Linv = L.inverse();
//    double[][] posteriors = new double[n][n];
//    for (int i = 0; i < n; i++) {
//      for (int j = 0; j < n; j++) {
//        if (i == j) {
//          // Root Posterior
//          posteriors[i][j] = potentials[i][i] * Linv.get(i,i);
//        } else {
//          // Non-root Posterior
//          posteriors[i][j] = potentials[i][j] * (Linv.get(j,j) - Linv.get(j,i));
//        }
//        if (posteriors[i][j] < -1.0e-10) {
//          throw new RuntimeException("Error in Matrix-Tree Posteriors");
//        }
//        posteriors[i][j] = Math.max(posteriors[i][j],1.0e-10);        
//      }
//    }
//    DoubleArrays.checkValid(posteriors);
//    double logSumTree = 0.0;
//    for (double ev : evd.getRealEigenvalues()) {
//      logSumTree += Math.log(ev);
//    }        
//    return Pair.makePair(logSumTree,posteriors);
//  }
//
//  public static void main(String[] args)
//  {
//    int n = 3;
//    int l = 2;
//    double[][]  potentials = new double[n][n];
//    for (double[] row: potentials) {
//        Arrays.fill(row,Double.NEGATIVE_INFINITY);
//    }
//    for (int i=0; i < n; ++i) potentials[i][i] = 0.0;
//    for (int i = 0; i+1 < n; i++) {
//        potentials[i][i+1] = 0.0;
//    }
//    Pair res = computeMultiRoot(potentials);
//    System.out.println("sumTrees: " + Math.exp(res.getFirst()));
//  }
//}