import cc.mallet.grmm.learning.ACRFEvaluator; //导入依赖的package包/类
public boolean incrementalTrain (ACRF acrf,
                                 InstanceList training,
                                 InstanceList validation,
                                 InstanceList testing,
                                 ACRFEvaluator eval,
                                 int numIter)
{
  long stime = new Date ().getTime ();
  for (int i = 0; i < SIZE.length; i++) {
    InstanceList subset = training.split (new double[]
            {SIZE[i], 1 - SIZE[i]})[0];
    logger.info ("Training on subset of size " + subset.size ());
    Optimizable.ByGradientValue subset_macrf = createOptimizable (acrf, subset);
    train (acrf, training, validation, null, eval,
            SUBSET_ITER, subset_macrf);
    logger.info ("Subset training " + i + " finished...");
  }
  long etime = new Date ().getTime ();
  logger.info ("All subset training finished.  Time = " + (etime - stime) + " ms.");
  return train (acrf, training, validation, testing, eval, numIter);
}
 

import cc.mallet.grmm.learning.ACRFEvaluator; //导入依赖的package包/类
/**
 * @return true means stop, false means keep going (opposite of evaluators... ugh!)
 */
protected boolean callEvaluator (ACRF acrf, InstanceList trainingList, InstanceList validationList,
                               InstanceList testSet, int iter, ACRFEvaluator eval)
{
  if (eval == null) return false;  // If no evaluator specified, keep going blindly

  eval.setOutputPrefix (outputPrefix);

  // don't cache test set
  boolean wasCached = acrf.isCacheUnrolledGraphs ();
  acrf.setCacheUnrolledGraphs (false);

  Timing timing = new Timing ();

  if (!eval.evaluate (acrf, iter+1, trainingList, validationList, testSet)) {
    logger.info ("ACRF trainer: evaluator returned false. Quitting.");
    timing.tick ("Evaluation time (iteration "+iter+")");
    return true;
  }

  timing.tick ("Evaluation time (iteration "+iter+")");

  // set test set caching back to normal
  acrf.setCacheUnrolledGraphs (wasCached);
  return false;
}
 

import cc.mallet.grmm.learning.ACRFEvaluator; //导入依赖的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.grmm.learning.ACRFEvaluator; //导入依赖的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.grmm.learning.ACRFEvaluator; //导入依赖的package包/类
public void test (ACRF acrf, InstanceList testing, ACRFEvaluator[] evals)
{
  List pred = acrf.getBestLabels (testing);
  for (int i = 0; i < evals.length; i++) {
    evals[i].setOutputPrefix (outputPrefix);
    evals[i].test (testing, pred, "Testing");
  }
}
 

import cc.mallet.grmm.learning.ACRFEvaluator; //导入依赖的package包/类
public boolean evaluate (ACRF acrf, int iter, InstanceList training, InstanceList validation, InstanceList testing)
{
  boolean ret = true;
  for (Iterator it = evals.iterator (); it.hasNext ();) {
    ACRFEvaluator evaluator = (ACRFEvaluator) it.next ();
    // Return false (i.e., stop training) if any sub-evaluator does.
    ret = ret && evaluator.evaluate (acrf, iter, training, validation, testing);
  }
  return ret;
}
 

import cc.mallet.grmm.learning.ACRFEvaluator; //导入依赖的package包/类
public void test (InstanceList gold, List returned, String description)
{
  for (Iterator it = evals.iterator (); it.hasNext ();) {
    ACRFEvaluator eval =  (ACRFEvaluator) it.next ();
    eval.test (gold, returned, description);
  }
}