@Override public double[] gradientAt(double[] x) { checkDimension(x); double[] gradient = f.gradientAt(x); if (l2Cost > 0) { for (int i = 0; i < x.length; i++) { gradient[i] += 2 * l2Cost * x[i]; } } return gradient; }
/** * Initial linear search object for L1-regularization. */ public static LineSearchResult getInitialObjectForL1( double valueAtX, double[] gradAtX, double[] pseudoGradAtX, double[] x) { return getInitialObject(valueAtX, gradAtX, pseudoGradAtX, x, new double[x.length], 0); }
public static LineSearchResult getInitialObject( double valueAtX, double[] gradAtX, double[] pseudoGradAtX, double[] x, double[] signX, int fctEvalCount) { return new LineSearchResult(0.0, 0.0, valueAtX, new double[x.length], gradAtX, pseudoGradAtX, new double[x.length], x, signX, fctEvalCount); } }
@Test public void testLineSearchDeterminesSaneStepLength2() { Function objectiveFunction = new QuadraticFunction2(); // given double[] testX = new double[] { -2 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { 1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertTrue(succCond); }
@Test public void testLineSearchDeterminesSaneStepLength1() { Function objectiveFunction = new QuadraticFunction1(); // given double[] testX = new double[] { 0 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { 1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertTrue(succCond); }
@Test public void testQuadraticFunction() { QNMinimizer minimizer = new QNMinimizer(); Function f = new QuadraticFunction(); double[] x = minimizer.minimize(f); double minValue = f.valueAt(x); Assert.assertEquals(x[0], 1.0, 1e-5); Assert.assertEquals(x[1], 5.0, 1e-5); Assert.assertEquals(minValue, 10.0, 1e-10); }
@Test public void testRosenbrockFunction() { QNMinimizer minimizer = new QNMinimizer(); Function f = new Rosenbrock(); double[] x = minimizer.minimize(f); double minValue = f.valueAt(x); Assert.assertEquals(x[0], 1.0, 1e-5); Assert.assertEquals(x[1], 1.0, 1e-5); Assert.assertEquals(minValue, 0, 1e-10); }
public AbstractModel doTrain(DataIndexer indexer) throws IOException { int iterations = getIterations(); return trainModel(iterations, indexer); }
@Override public double valueAt(double[] x) { checkDimension(x); double value = f.valueAt(x); if (l2Cost > 0) { value += l2Cost * ArrayMath.innerProduct(x, x); } return value; }
public double[] eval(String[] context, double[] probs) { return eval(context, null, probs); }
@Override public int getDimension() { return f.getDimension(); }
@Deprecated @Override public boolean isValid() { try { validate(); return true; } catch (IllegalArgumentException e) { return false; } }
public QNModel constructModel() throws IOException { String[] outcomeLabels = getOutcomes(); int[][] outcomePatterns = getOutcomePatterns(); String[] predLabels = getPredicates(); Context[] params = getParameters(outcomePatterns); return new QNModel(params, predLabels, outcomeLabels); } }
@Test public void testLineSearchFailsWithWrongDirection2() { Function objectiveFunction = new QuadraticFunction2(); // given double[] testX = new double[] { -2 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { -1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }
@Test public void testLineSearchFailsWithWrongDirection1() { Function objectiveFunction = new QuadraticFunction1(); // given double[] testX = new double[] { 0 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { -1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }
/** * Initial linear search object. */ public static LineSearchResult getInitialObject( double valueAtX, double[] gradAtX, double[] x) { return getInitialObject(valueAtX, gradAtX, null, x, null, 0); }
@Test public void testLineSearchFailsWithWrongDirection4() { Function objectiveFunction = new QuadraticFunction2(); // given double[] testX = new double[] { 2 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { 1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }
@Test public void testLineSearchFailsWithWrongDirection3() { Function objectiveFunction = new QuadraticFunction1(); // given double[] testX = new double[] { 4 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { 1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }
@Test public void testLineSearchFailsAtMinimum2() { Function objectiveFunction = new QuadraticFunction2(); // given double[] testX = new double[] { 0 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { 1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }
@Test public void testLineSearchFailsAtMinimum1() { Function objectiveFunction = new QuadraticFunction2(); // given double[] testX = new double[] { 0 }; double testValueX = objectiveFunction.valueAt(testX); double[] testGradX = objectiveFunction.gradientAt(testX); double[] testDirection = new double[] { -1 }; // when LineSearchResult lsr = LineSearchResult.getInitialObject(testValueX, testGradX, testX); LineSearch.doLineSearch(objectiveFunction, testDirection, lsr, 1.0); double stepSize = lsr.getStepSize(); // then boolean succCond = TOLERANCE < stepSize && stepSize <= 1; Assert.assertFalse(succCond); Assert.assertEquals(0.0, stepSize, TOLERANCE); }