OptParams

OptParams is a Configuration-compatible case class that can be used to select optimization routines at runtime.

Configurations: 1) useStochastic=false,useL1=false: LBFGS with L2 regularization 2) useStochastic=false,useL1=true: OWLQN with L1 regularization 3) useStochastic=true,useL1=false: AdaptiveGradientDescent with L2 regularization 3) useStochastic=true,useL1=true: AdaptiveGradientDescent with L1 regularization

batchSize: size of batches to use if useStochastic and you give a BatchDiffFunction
regularization: regularization constant to use.
alpha: rate of change to use, only applies to SGD.
useL1: if true, use L1 regularization. Otherwise, use L2.
tolerance: convergence tolerance, looking at both average improvement and the norm of the gradient.
useStochastic: if false, use LBFGS or OWLQN. If true, use some variant of Stochastic Gradient Descent.

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Instance Constructors

new OptParams(batchSize: Int = 512, regularization: Double = 0.0, alpha: Double = 0.5, maxIterations: Int = 1000, useL1: Boolean = false, tolerance: Double = 1.0E-5, useStochastic: Boolean = false)

batchSize
size of batches to use if useStochastic and you give a BatchDiffFunction
regularization
regularization constant to use.
alpha
rate of change to use, only applies to SGD.
useL1
if true, use L1 regularization. Otherwise, use L2.
tolerance
convergence tolerance, looking at both average improvement and the norm of the gradient.
useStochastic
if false, use LBFGS or OWLQN. If true, use some variant of Stochastic Gradient Descent.

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
val alpha: Double

rate of change to use, only applies to SGD.
final def asInstanceOf[T0]: T0

Definition Classes
Any
val batchSize: Int

size of batches to use if useStochastic and you give a BatchDiffFunction
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterations[T](f: DiffFunction[T], init: T)(implicit vspace: MutableCoordinateSpace[T, Double]): Iterator[LBFGS.State]
def iterations[T](f: StochasticDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): Iterator[State]
def iterations[T](f: BatchDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): Iterator[State]
val maxIterations: Int
def minimize[T](f: DiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): T
def minimize[T](f: BatchDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): T
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val regularization: Double

regularization constant to use.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tolerance: Double

convergence tolerance, looking at both average improvement and the norm of the gradient.
val useL1: Boolean

if true, use L1 regularization.
if true, use L1 regularization. Otherwise, use L2.
val useStochastic: Boolean

if false, use LBFGS or OWLQN.
if false, use LBFGS or OWLQN. If true, use some variant of Stochastic Gradient Descent.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()

case class OptParams(batchSize: Int = 512, regularization: Double = 0.0, alpha: Double = 0.5, maxIterations: Int = 1000, useL1: Boolean = false, tolerance: Double = 1.0E-5, useStochastic: Boolean = false) extends Product with Serializable

Instance Constructors

new OptParams(batchSize: Int = 512, regularization: Double = 0.0, alpha: Double = 0.5, maxIterations: Int = 1000, useL1: Boolean = false, tolerance: Double = 1.0E-5, useStochastic: Boolean = false)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val alpha: Double

final def asInstanceOf[T0]: T0

val batchSize: Int

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def iterations[T](f: DiffFunction[T], init: T)(implicit vspace: MutableCoordinateSpace[T, Double]): Iterator[LBFGS.State]

def iterations[T](f: StochasticDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): Iterator[State]

def iterations[T](f: BatchDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): Iterator[State]

val maxIterations: Int

def minimize[T](f: DiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): T

def minimize[T](f: BatchDiffFunction[T], init: T)(implicit arith: MutableCoordinateSpace[T, Double]): T

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val regularization: Double

final def synchronized[T0](arg0: ⇒ T0): T0

val tolerance: Double

val useL1: Boolean

val useStochastic: Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped