FineTunableTheta tunedTheta = rae.train(params);// 根据参数和数据训练神经网络权重      tunedTheta.Dump(params.ModelFile);      System.out.println("RAE trained. The model file is saved in "          + params.ModelFile);　　　 // 特征抽取器      RAEFeatureExtractor fe = new RAEFeatureExtractor(params.EmbeddingSize,          tunedTheta, params.AlphaCat, params.Beta, params.CatSize,          params.Dataset.Vocab.size(), rae.f);　　　　// 获取训练数据      List<LabeledDatum<Double, Integer>> classifierTrainingData = http://www.mamicode.com/fe"Train Accuracy :" + TrainAccuracy.toString());

public interface Minimizer<T extends DifferentiableFunction> {  /**   * Attempts to find an unconstrained minimum of the objective   * <code>function</code> starting at <code>initial</code>, within   * <code>functionTolerance</code>.   *   * @param function          the objective function   * @param functionTolerance a <code>double</code> value   * @param initial           a initial feasible point   * @return Unconstrained minimum of function   */  double[] minimize(T function, double functionTolerance, double[] initial);  double[] minimize(T function, double functionTolerance, double[] initial, int maxIterations);}

public interface DifferentiableFunction extends Function {  double[] derivativeAt(double[] x);}public interface Function {  int dimension();  double valueAt(double[] x);}

/** * This code is part of the Stanford NLP Toolkit. *  *  * An implementation of L-BFGS for Quasi Newton unconstrained minimization. *  * The general outline of the algorithm is taken from: <blockquote> <i>Numerical * Optimization</i> (second edition) 2006 Jorge Nocedal and Stephen J. Wright * </blockquote> A variety of different options are available. *  * <h3>LINESEARCHES</h3> *  * BACKTRACKING: This routine simply starts with a guess for step size of 1. If * the step size doesn‘t supply a sufficient decrease in the function value the * step is updated through step = 0.1*step. This method is certainly simpler, * but doesn‘t allow for an increase in step size, and isn‘t well suited for * Quasi Newton methods. *  * MINPACK: This routine is based off of the implementation used in MINPACK. * This routine finds a point satisfying the Wolfe conditions, which state that * a point must have a sufficiently smaller function value, and a gradient of * smaller magnitude. This provides enough to prove theoretically quadratic * convergence. In order to find such a point the linesearch first finds an * interval which must contain a satisfying point, and then progressively * reduces that interval all using cubic or quadratic interpolation. *  *  * SCALING: L-BFGS allows the initial guess at the hessian to be updated at each * step. Standard BFGS does this by approximating the hessian as a scaled * identity matrix. To use this method set the scaleOpt to SCALAR. A better way * of approximate the hessian is by using a scaling diagonal matrix. The * diagonal can then be updated as more information comes in. This method can be * used by setting scaleOpt to DIAGONAL. *  *  * CONVERGENCE: Previously convergence was gauged by looking at the average * decrease per step dividing that by the current value and terminating when * that value because smaller than TOL. This method fails when the function * value approaches zero, so two other convergence criteria are used. The first * stores the initial gradient norm |g0|, then terminates when the new gradient * norm, |g| is sufficiently smaller: i.e., |g| < eps*|g0| the second checks * if |g| < eps*max( 1 , |x| ) which is essentially checking to see if the * gradient is numerically zero. *  * Each of these convergence criteria can be turned on or off by setting the * flags: <blockquote><code> * private boolean useAveImprovement = true; * private boolean useRelativeNorm = true; * private boolean useNumericalZero = true; * </code></blockquote> *  * To use the QNMinimizer first construct it using <blockquote><code> * QNMinimizer qn = new QNMinimizer(mem, true) * </code> * </blockquote> mem - the number of previous estimate vector pairs to store, * generally 15 is plenty. true - this tells the QN to use the MINPACK * linesearch with DIAGONAL scaling. false would lead to the use of the criteria * used in the old QNMinimizer class. */

public abstract class MemoizedDifferentiableFunction implements DifferentiableFunction {	protected double[] prevQuery, gradient;	protected double value;	protected int evalCount;		protected void initPrevQuery()	{		prevQuery = new double[ dimension() ];	}		protected boolean requiresEvaluation(double[] x)	{		if(DoubleArrays.equals(x,prevQuery))			return false;				System.arraycopy(x, 0, prevQuery, 0, x.length);		evalCount++;			return true;	}		@Override	public double[] derivativeAt(double[] x){		if(DoubleArrays.equals(x,prevQuery))			return gradient;		valueAt(x);		return gradient;	}}