You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opennlp.apache.org by jo...@apache.org on 2012/10/04 14:24:19 UTC
svn commit: r1394009 -
/opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java
Author: joern
Date: Thu Oct 4 12:24:19 2012
New Revision: 1394009
URL: http://svn.apache.org/viewvc?rev=1394009&view=rev
Log:
OPENNLP-338 unit test dependency with DataIndexer removed. Thanks to Hyosup Shim for providing a patch.
Modified:
opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java
Modified: opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java
URL: http://svn.apache.org/viewvc/opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java?rev=1394009&r1=1394008&r2=1394009&view=diff
==============================================================================
--- opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java (original)
+++ opennlp/trunk/opennlp-maxent/src/test/java/opennlp/maxent/quasinewton/LogLikelihoodFunctionTest.java Thu Oct 4 12:24:19 2012
@@ -21,6 +21,9 @@ import static org.junit.Assert.assertNot
import static org.junit.Assert.assertTrue;
import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
import opennlp.model.DataIndexer;
import opennlp.model.OnePassRealValueDataIndexer;
@@ -120,12 +123,9 @@ public class LogLikelihoodFunctionTest {
LogLikelihoodFunction objectFunction = new LogLikelihoodFunction(testDataIndexer);
// when
double[] gradientAtInitialPoint = objectFunction.gradientAt(objectFunction.getInitialPoint());
- double[] expectedGradient = new double[] { 20, 8.5, -14, -17, -9, -20, -8.5, 14, 17, 9 };
+ double[] expectedGradient = new double[] { -9, -14, -17, 20, 8.5, 9, 14, 17, -20, -8.5 };
// then
- assertTrue(expectedGradient.length == gradientAtInitialPoint.length);
- for (int i = 0; i < expectedGradient.length; i++) {
- assertEquals(expectedGradient[i], gradientAtInitialPoint[i], TOLERANCE01);
- }
+ assertTrue(compareDoubleArray(expectedGradient, gradientAtInitialPoint, testDataIndexer, TOLERANCE01));
}
@Test
@@ -135,15 +135,89 @@ public class LogLikelihoodFunctionTest {
DataIndexer testDataIndexer = new OnePassRealValueDataIndexer(rvfes1,1);
LogLikelihoodFunction objectFunction = new LogLikelihoodFunction(testDataIndexer);
// when
- double[] nonInitialPoint = new double[] { 2, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
- double[] gradientAtInitialPoint = objectFunction.gradientAt(nonInitialPoint);
+ double[] nonInitialPoint = new double[] { 0.2, 0.5, 0.2, 0.5, 0.2,
+ 0.5, 0.2, 0.5, 0.2, 0.5 };
+ double[] gradientAtNonInitialPoint =
+ objectFunction.gradientAt(dealignDoubleArrayForTestData(nonInitialPoint,
+ testDataIndexer.getPredLabels(),
+ testDataIndexer.getOutcomeLabels()));
double[] expectedGradient =
- new double[] { 6.19368E-09, -3.04514E-16, 7.48224E-09, -7.15239E-09, 4.14274E-09,
- -6.19368E-09, 0.0, -7.48225E-09, 7.15239E-09, -4.14274E-09};
+ new double[] { -0.311616214, -0.211771052, -1.324041847, 0.93340278, 0.317407069,
+ 0.311616214, 0.211771052, 1.324041847, -0.93340278, -0.317407069 };
// then
- assertTrue(expectedGradient.length == gradientAtInitialPoint.length);
- for (int i = 0; i < expectedGradient.length; i++) {
- assertEquals(expectedGradient[i], gradientAtInitialPoint[i], TOLERANCE01);
+ assertTrue(compareDoubleArray(expectedGradient, gradientAtNonInitialPoint, testDataIndexer, TOLERANCE01));
+ }
+
+ private double[] alignDoubleArrayForTestData(double[] expected, String[] predLabels, String[] outcomeLabels) {
+ double[] aligned = new double[predLabels.length * outcomeLabels.length];
+
+ String[] sortedPredLabels = predLabels.clone();
+ String[] sortedOutcomeLabels = outcomeLabels.clone();
+ Arrays.sort(sortedPredLabels);
+ Arrays.sort(sortedOutcomeLabels);
+
+ Map<String, Integer> invertedPredIndex = new HashMap<String, Integer>();
+ Map<String, Integer> invertedOutcomeIndex = new HashMap<String, Integer>();
+ for (int i = 0; i < predLabels.length; i++) {
+ invertedPredIndex.put(predLabels[i], i);
+ }
+ for (int i = 0; i < outcomeLabels.length; i++) {
+ invertedOutcomeIndex.put(outcomeLabels[i], i);
+ }
+
+ for (int i = 0; i < sortedOutcomeLabels.length; i++) {
+ for (int j = 0; j < sortedPredLabels.length; j++) {
+ aligned[i * sortedPredLabels.length + j] = expected[invertedOutcomeIndex
+ .get(sortedOutcomeLabels[i])
+ * sortedPredLabels.length
+ + invertedPredIndex.get(sortedPredLabels[j])];
+ }
+ }
+ return aligned;
+ }
+
+ private double[] dealignDoubleArrayForTestData(double[] expected,
+ String[] predLabels, String[] outcomeLabels) {
+ double[] dealigned = new double[predLabels.length * outcomeLabels.length];
+
+ String[] sortedPredLabels = predLabels.clone();
+ String[] sortedOutcomeLabels = outcomeLabels.clone();
+ Arrays.sort(sortedPredLabels);
+ Arrays.sort(sortedOutcomeLabels);
+
+ Map<String, Integer> invertedPredIndex = new HashMap<String, Integer>();
+ Map<String, Integer> invertedOutcomeIndex = new HashMap<String, Integer>();
+ for (int i = 0; i < predLabels.length; i++) {
+ invertedPredIndex.put(predLabels[i], i);
+ }
+ for (int i = 0; i < outcomeLabels.length; i++) {
+ invertedOutcomeIndex.put(outcomeLabels[i], i);
+ }
+
+ for (int i = 0; i < sortedOutcomeLabels.length; i++) {
+ for (int j = 0; j < sortedPredLabels.length; j++) {
+ dealigned[invertedOutcomeIndex.get(sortedOutcomeLabels[i])
+ * sortedPredLabels.length
+ + invertedPredIndex.get(sortedPredLabels[j])] = expected[i
+ * sortedPredLabels.length + j];
+ }
+ }
+
+ return dealigned;
+ }
+
+ private boolean compareDoubleArray(double[] expected, double[] actual, DataIndexer indexer, double tolerance) {
+ double[] alignedActual = alignDoubleArrayForTestData(actual, indexer.getPredLabels(), indexer.getOutcomeLabels());
+
+ if (expected.length != alignedActual.length) {
+ return false;
+ }
+
+ for (int i = 0; i < alignedActual.length; i++) {
+ if (Math.abs(alignedActual[i] - expected[i]) > tolerance) {
+ return false;
+ }
}
+ return true;
}
}