Java Optimizable.ByGradientValue方法代码示例

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public boolean someUnsupportedTrain (ACRF acrf,
                      InstanceList trainingList,
                      InstanceList validationList,
                      InstanceList testSet,
                      ACRFEvaluator eval,
                      int numIter)
{

  Optimizable.ByGradientValue macrf = createOptimizable (acrf, trainingList);
  train (acrf, trainingList, validationList, testSet, eval, 5, macrf);
  ACRF.Template[] tmpls = acrf.getTemplates ();
  for (int ti = 0; ti < tmpls.length; ti++)
    tmpls[ti].addSomeUnsupportedWeights (trainingList);
  logger.info ("Some unsupporetd weights initialized.  Training...");
  return train (acrf, trainingList, validationList, testSet, eval, numIter, macrf);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public boolean train (ACRF acrf, InstanceList trainingList, InstanceList validationList, InstanceList testSet,
                      ACRFEvaluator eval, int numIter, Optimizable.ByGradientValue macrf)
{
  if (wrongWrongType == NO_WRONG_WRONG) {
    return super.train (acrf, trainingList, validationList, testSet, eval, numIter, macrf);
  } else {
    Maxable bipwMaxable = (Maxable) macrf;
    // add wrong wrongs after 5 iterations
    logger.info ("BiconditionalPiecewiseACRFTrainer: Initial training");
    super.train (acrf, trainingList, validationList, testSet, eval, wrongWrongIter, macrf);
    FileUtils.writeGzippedObject (new File (outputPrefix, "initial-acrf.ser.gz"), acrf);
    logger.info ("BiconditionalPiecewiseACRFTrainer: Adding wrong-wrongs");
    bipwMaxable.addWrongWrong (trainingList);
    logger.info ("BiconditionalPiecewiseACRFTrainer: Adding wrong-wrongs");
    boolean converged = super.train (acrf, trainingList, validationList, testSet, eval, numIter, macrf);
    reportTrainingLikelihood (acrf, trainingList);
    return converged;
  }
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public void testGetSetParameters() {
	int inputVocabSize = 100;
	int numStates = 5;
	Alphabet inputAlphabet = new Alphabet();
	for (int i = 0; i < inputVocabSize; i++)
		inputAlphabet.lookupIndex("feature" + i);
	Alphabet outputAlphabet = new Alphabet();
	CRF crf = new CRF(inputAlphabet, outputAlphabet);
	String[] stateNames = new String[numStates];
	for (int i = 0; i < numStates; i++)
		stateNames[i] = "state" + i;
	crf.addFullyConnectedStates(stateNames);
	CRFTrainerByLabelLikelihood crft = new CRFTrainerByLabelLikelihood(crf);
	Optimizable.ByGradientValue mcrf = crft
			.getOptimizableCRF(new InstanceList(null));
	TestOptimizable.testGetSetParameters(mcrf);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public void testSpaceSerializable () throws IOException, ClassNotFoundException
{
  Pipe p = makeSpacePredictionPipe ();
  InstanceList training = new InstanceList (p);
  training.addThruPipe (new ArrayIterator (data));

  MEMM memm = new MEMM (p, null);
  memm.addFullyConnectedStatesForLabels ();
  memm.addStartState();
  memm.setWeightsDimensionAsIn(training);
 MEMMTrainer memmt = new MEMMTrainer (memm);
  memmt.train (training, 10);

  MEMM memm2 = (MEMM) TestSerializable.cloneViaSerialization (memm);

  Optimizable.ByGradientValue mcrf1 = memmt.getOptimizableMEMM(training);
  double val1 = mcrf1.getValue ();
  Optimizable.ByGradientValue mcrf2 = memmt.getOptimizableMEMM(training);
  double val2 = mcrf2.getValue ();

  assertEquals (val1, val2, 1e-5);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
/**
 * Tests that getValue and getValueGradient are consistent.
 * Tests for consistency at <tt>params = 0</tt> and at
 *  <tt> params = -0.0001 * grad(f)</tt>
 *  @see #testValueAndGradientCurrentParameters testValueAndGradientCurrentParameters
 * @throws IllegalStateException If the test fails.
 */
public static boolean	testValueAndGradient (Optimizable.ByGradientValue maxable)
{
	double[] parameters = new double [maxable.getNumParameters()];
	MatrixOps.setAll (parameters, 0.0);
	maxable.setParameters (parameters);
	testValueAndGradientCurrentParameters (maxable);
	MatrixOps.setAll (parameters, 0.0);
	double[] delta = new double[maxable.getNumParameters()];
	maxable.getValueGradient (delta);
	logger.info ("Gradient two-Norm = "+MatrixOps.twoNorm(delta));
	logger.info ("  max parameter change = "+(MatrixOps.infinityNorm(delta) * -0.001));
	MatrixOps.timesEquals (delta, -0.0001);
	MatrixOps.plusEquals (parameters, delta);
	maxable.setParameters (parameters);
	testValueAndGradientCurrentParameters (maxable);
	return true;
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
boolean train (ACRF acrf,
InstanceList training,
InstanceList validation,
InstanceList testing,
ACRFEvaluator eval,
int numIter,
Optimizable.ByGradientValue macrf);
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
/**
 * @param crf CRF whose parameters we wish to estimate.
 * @param opts Optimizable.ByGradientValue objective functions. 
 * 
 * Parameters are estimated by maximizing the sum of the individual
 * objective functions.
 */
public CRFOptimizableByGradientValues (CRF crf, Optimizable.ByGradientValue[] opts) {
	this.crf = crf;
	this.optimizables = opts;
	this.cachedGradient = new double[crf.parameters.getNumFactors()];
	this.cachedValueWeightsStamp = -1;
	this.cachedGradientWeightsStamp = -1;
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public ConjugateGradient (Optimizable.ByGradientValue function, double initialStepSize)
{
  this.initialStepSize = initialStepSize;
  this.optimizable = function;
  this.lineMaximizer = new BackTrackLineSearch (function);
  //Alternative:
  //this.lineMaximizer = new GradientBracketLineOptimizer (function);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public void testRandomMaximizable ()
{
	MaxEntTrainer trainer = new MaxEntTrainer();
	Alphabet fd = dictOfSize (6);
	String[] classNames = new String[] {"class0", "class1"};
	InstanceList ilist = new InstanceList (new Randoms(1), fd, classNames, 20);
	Optimizable.ByGradientValue maxable = trainer.getOptimizable (ilist);
	TestOptimizable.testValueAndGradient (maxable);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public Optimizable.ByGradientValue getOptimizable (InstanceList trainingList) {
  if (ge == null) {
    ge = new MaxEntOptimizableByGE(trainingList,constraints,classifier);
    ge.setTemperature(temperature);
    ge.setGaussianPriorVariance(gaussianPriorVariance);
  }
  return ge;
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
/**
 * Tests that getValue and getValueGradient are consistent 
 *   at a random parameter setting.
 *  @see #testValueAndGradientCurrentParameters testValueAndGradientCurrentParameters
 * @throws IllegalStateException If the test fails.
 */
public static boolean testValueAndGradientRandomParameters 
(Optimizable.ByGradientValue maxable, Random r)
{
	double[] params = new double [maxable.getNumParameters()];
	for (int i = 0; i < params.length; i++) {
		params[i] = r.nextDouble ();
		if (r.nextBoolean ()) 
			params [i] = -params[i];
	}
	maxable.setParameters (params);
	testValueAndGradientCurrentParameters (maxable);
	return true;
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public boolean train (ACRF acrf,
                      InstanceList trainingList,
                      InstanceList validationList,
                      InstanceList testSet,
                      ACRFEvaluator eval,
                      int numIter)
{
  Optimizable.ByGradientValue macrf = createOptimizable (acrf, trainingList);
  return train (acrf, trainingList, validationList, testSet,
          eval, numIter, macrf);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public void testSetGetParameters ()
{
		MaxEntTrainer trainer = new MaxEntTrainer();
	Alphabet fd = dictOfSize (6);
	String[] classNames = new String[] {"class0", "class1", "class2"};
	InstanceList ilist = new InstanceList (new Randoms(1), fd, classNames, 20);
	Optimizable.ByGradientValue maxable = trainer.getOptimizable (ilist);
	TestOptimizable.testGetSetParameters (maxable);
}
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
public void testSpaceMaximizable ()
  {
    Pipe p = makeSpacePredictionPipe ();
    InstanceList training = new InstanceList (p);
//    String[] data = { TestMEMM.data[0], }; // TestMEMM.data[1], TestMEMM.data[2], TestMEMM.data[3], };
//    String[] data = { "ab" };
    training.addThruPipe (new ArrayIterator (data));

//    CRF4 memm = new CRF4 (p, null);
    MEMM memm = new MEMM (p, null);
    memm.addFullyConnectedStatesForLabels ();
    memm.addStartState();
    memm.setWeightsDimensionAsIn(training);
    
	  MEMMTrainer memmt = new MEMMTrainer (memm);
//    memm.gatherTrainingSets (training); // ANNOYING: Need to set up per-instance training sets
    memmt.train (training, 1);  // Set weights dimension, gathers training sets, etc.

//    memm.print();
//    memm.printGradient = true;
//    memm.printInstanceLists();

//    memm.setGaussianPriorVariance (Double.POSITIVE_INFINITY);
    Optimizable.ByGradientValue mcrf = memmt.getOptimizableMEMM(training);
    TestOptimizable.setNumComponents (150);
    TestOptimizable.testValueAndGradient (mcrf);
  }
 

import cc.mallet.optimize.Optimizable; //导入方法依赖的package包/类
double getLikelihood (MEMMTrainer memmt, InstanceList data) {
	Optimizable.ByGradientValue mcrf = memmt.getOptimizableMEMM(data);
	// Do this elaborate thing so that crf.cachedValueStale is forced true
	double[] params = new double [mcrf.getNumParameters()];
	mcrf.getParameters (params);
	mcrf.setParameters (params);
	return mcrf.getValue ();
}