SGDWithAdaGradAndFOBOS (Stanford JavaNLP API)

java.lang.Object
- edu.stanford.nlp.optimization.SGDWithAdaGradAndFOBOS<T>

All Implemented Interfaces:

HasEvaluators, Minimizer<T>
```
public class SGDWithAdaGradAndFOBOS<T extends DiffFunction>
extends java.lang.Object
implements Minimizer<T>, HasEvaluators
```
Stochastic Gradient Descent With AdaGrad and FOBOS in batch mode. Optionally, user can also turn on AdaDelta via option "useAdaDelta" Similar to SGDMinimizer, regularization is done in the minimizer, not in the objective function. This version is not efficient for online setting. For online variant, consider implementing SparseAdaGradMinimizer.java

Author:

Mengqiu Wang

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SGDWithAdaGradAndFOBOS.Prior

Nested Classes
Modifier and Type	Class and Description
`static class`	`SGDWithAdaGradAndFOBOS.Prior`

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`alpha`
`protected int`	`bSize`
`double[]`	`diag`
`protected java.util.Random`	`gen`
`protected double`	`initRate`
`protected double`	`lambda`
`protected long`	`maxTime`
`protected int`	`numPasses`
`protected boolean`	`quiet`
`java.util.List<double[]>`	`sList`
`protected double[]`	`x`
`java.util.List<double[]>`	`yList`

Constructor Summary

Constructors
Constructor and Description
`SGDWithAdaGradAndFOBOS(double initRate, double lambda, int numPasses)`
`SGDWithAdaGradAndFOBOS(double initRate, double lambda, int numPasses, int batchSize)`
`SGDWithAdaGradAndFOBOS(double initRate, double lambda, int numPasses, int batchSize, java.lang.String priorType, double alpha, boolean useAdaDelta, boolean useAdaDiff, double adaGradEps, double adaDeltaRho)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected java.lang.String`	`getName()`
`double[]`	`minimize(DiffFunction function, double functionTolerance, double[] initial)` Attempts to find an unconstrained minimum of the objective `function` starting at `initial`, accurate to within `functionTolerance` (normally implemented as a multiplier of the range value to give range tolerance).
`double[]`	`minimize(DiffFunction f, double functionTolerance, double[] initial, int maxIterations)` Attempts to find an unconstrained minimum of the objective `function` starting at `initial`, accurate to within `functionTolerance` (normally implemented as a multiplier of the range value to give range tolerance), but running only for at most `maxIterations` iterations.
`protected void`	`say(java.lang.String s)`
`protected void`	`sayln(java.lang.String s)`
`void`	`setEvaluators(int iters, Evaluator[] evaluators)`
`void`	`setHessSampleSize(int hessSize)`
`void`	`setTerminateOnEvalImprovementNumOfEpoch(int terminateOnEvalImprovementNumOfEpoch)`
`void`	`shutUp()`
`void`	`suppressTestPrompt(boolean suppressTestPrompt)`
`void`	`terminateOnAvgImprovement(boolean toTerminate, double tolerance)`
`void`	`terminateOnEvalImprovement(boolean toTerminate)`
`boolean`	`toContinue(double[] x, double currEval)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

x
```
protected double[] x
```

initRate
```
protected double initRate
```

lambda
```
protected double lambda
```

alpha
```
protected double alpha
```

quiet
```
protected boolean quiet
```

numPasses
```
protected final int numPasses
```

bSize
```
protected int bSize
```

yList
```
public java.util.List<double[]> yList
```

sList
```
public java.util.List<double[]> sList
```

diag
```
public double[] diag
```

gen
```
protected java.util.Random gen
```

maxTime
```
protected long maxTime
```

Constructor Detail

SGDWithAdaGradAndFOBOS

public SGDWithAdaGradAndFOBOS(double initRate,
                              double lambda,
                              int numPasses)

SGDWithAdaGradAndFOBOS

public SGDWithAdaGradAndFOBOS(double initRate,
                              double lambda,
                              int numPasses,
                              int batchSize)

SGDWithAdaGradAndFOBOS

public SGDWithAdaGradAndFOBOS(double initRate,
                              double lambda,
                              int numPasses,
                              int batchSize,
                              java.lang.String priorType,
                              double alpha,
                              boolean useAdaDelta,
                              boolean useAdaDiff,
                              double adaGradEps,
                              double adaDeltaRho)

Method Detail
- setHessSampleSize
```
public void setHessSampleSize(int hessSize)
```
- terminateOnEvalImprovement
```
public void terminateOnEvalImprovement(boolean toTerminate)
```
- terminateOnAvgImprovement
```
public void terminateOnAvgImprovement(boolean toTerminate,
                                      double tolerance)
```
- suppressTestPrompt
```
public void suppressTestPrompt(boolean suppressTestPrompt)
```
- setTerminateOnEvalImprovementNumOfEpoch
```
public void setTerminateOnEvalImprovementNumOfEpoch(int terminateOnEvalImprovementNumOfEpoch)
```
- toContinue
```
public boolean toContinue(double[] x,
                          double currEval)
```
- shutUp
```
public void shutUp()
```
- getName
```
protected java.lang.String getName()
```
- setEvaluators
```
public void setEvaluators(int iters,
                          Evaluator[] evaluators)
```
  Specified by:
  
  setEvaluators in interface HasEvaluators
- minimize
```
public double[] minimize(DiffFunction function,
                         double functionTolerance,
                         double[] initial)
```
  Description copied from interface: Minimizer
  
  Attempts to find an unconstrained minimum of the objective function starting at initial, accurate to within functionTolerance (normally implemented as a multiplier of the range value to give range tolerance).
  
  Specified by:
  
  minimize in interface Minimizer<T extends DiffFunction>
  
  Parameters:
  
  function - The objective function
  
  functionTolerance - A double value
  
  initial - An initial feasible point
  
  Returns:
  
  Unconstrained minimum of function
- minimize
```
public double[] minimize(DiffFunction f,
                         double functionTolerance,
                         double[] initial,
                         int maxIterations)
```
  Description copied from interface: Minimizer
  
  Attempts to find an unconstrained minimum of the objective function starting at initial, accurate to within functionTolerance (normally implemented as a multiplier of the range value to give range tolerance), but running only for at most maxIterations iterations.
  
  Specified by:
  
  minimize in interface Minimizer<T extends DiffFunction>
  
  Parameters:
  
  f - The objective function
  
  functionTolerance - A double value
  
  initial - An initial feasible point
  
  maxIterations - Maximum number of iterations
  
  Returns:
  
  Unconstrained minimum of function
- sayln
```
protected void sayln(java.lang.String s)
```
- say
```
protected void say(java.lang.String s)
```

Class SGDWithAdaGradAndFOBOS<T extends DiffFunction>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

x

initRate

lambda

alpha

quiet

numPasses

bSize

yList

sList

diag

gen

maxTime

Constructor Detail

SGDWithAdaGradAndFOBOS

SGDWithAdaGradAndFOBOS

SGDWithAdaGradAndFOBOS

Method Detail

setHessSampleSize

terminateOnEvalImprovement

terminateOnAvgImprovement

suppressTestPrompt

setTerminateOnEvalImprovementNumOfEpoch

toContinue

shutUp

getName

setEvaluators

minimize

minimize

sayln

say