StochasticGradientDescent

Instance Constructors

new StochasticGradientDescent(defaultStepSize: Double, maxIter: Int, tolerance: Double = 1E-5, fvalMemory: Int = 100)(implicit vspace: NormedModule[T, Double])

Type Members

abstract type History

Any history the derived minimization function needs to do its updates.
Any history the derived minimization function needs to do its updates. typically an approximation to the second derivative/hessian matrix.

Definition Classes
FirstOrderMinimizer
type State = FirstOrderMinimizer.State[T, Info, History]

Definition Classes
FirstOrderMinimizer

Abstract Value Members

abstract def initialHistory(f: StochasticDiffFunction[T], init: T): History

Attributes
protected
Definition Classes
FirstOrderMinimizer
abstract def updateHistory(newX: T, newGrad: T, newVal: Double, f: StochasticDiffFunction[T], oldState: State): History

Attributes
protected
Definition Classes
FirstOrderMinimizer

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
def adjust(newX: T, newGrad: T, newVal: Double): (Double, T)

Attributes
protected
Definition Classes
FirstOrderMinimizer
def adjustFunction(f: StochasticDiffFunction[T]): StochasticDiffFunction[T]

Attributes
protected
Definition Classes
FirstOrderMinimizer
final def asInstanceOf[T0]: T0

Definition Classes
Any
def calculateObjective(f: StochasticDiffFunction[T], x: T, history: History): (Double, T)

Attributes
protected
Definition Classes
FirstOrderMinimizer
def chooseDescentDirection(state: State, fn: StochasticDiffFunction[T]): T

Attributes
protected
Definition Classes
StochasticGradientDescent → FirstOrderMinimizer
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
val convergenceCheck: ConvergenceCheck[T]

Definition Classes
FirstOrderMinimizer
val defaultStepSize: Double
def determineStepSize(state: State, f: StochasticDiffFunction[T], dir: T): Double

Choose a step size scale for this iteration.
Choose a step size scale for this iteration.
Default is eta / math.pow(state.iter + 1,2.0 / 3.0)

Definition Classes
StochasticGradientDescent → FirstOrderMinimizer
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def infiniteIterations(f: StochasticDiffFunction[T], state: State): Iterator[State]

Definition Classes
FirstOrderMinimizer
def initialState(f: StochasticDiffFunction[T], init: T): State

Attributes
protected
Definition Classes
FirstOrderMinimizer
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterations(f: StochasticDiffFunction[T], init: T): Iterator[State]

Definition Classes
FirstOrderMinimizer
def logger: LazyLogger

Attributes
protected
Definition Classes
SerializableLogging
val maxIter: Int
def minimize(f: StochasticDiffFunction[T], init: T): T

Definition Classes
FirstOrderMinimizer → Minimizer
def minimizeAndReturnState(f: StochasticDiffFunction[T], init: T): State

Definition Classes
FirstOrderMinimizer
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def takeStep(state: State, dir: T, stepSize: Double): T

Projects the vector x onto whatever ball is needed.
Projects the vector x onto whatever ball is needed. Can also incorporate regularization, or whatever.
Default just takes a step

Attributes
protected
Definition Classes
StochasticGradientDescent → FirstOrderMinimizer
def toString(): String

Definition Classes
AnyRef → Any
implicit val vspace: NormedModule[T, Double]

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

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: object StochasticGradientDescent | package optimize

abstract class StochasticGradientDescent[T] extends FirstOrderMinimizer[T, StochasticDiffFunction[T]] with SerializableLogging

Instance Constructors

new StochasticGradientDescent(defaultStepSize: Double, maxIter: Int, tolerance: Double = 1E-5, fvalMemory: Int = 100)(implicit vspace: NormedModule[T, Double])

Type Members

abstract type History

type State = FirstOrderMinimizer.State[T, Info, History]

Abstract Value Members

abstract def initialHistory(f: StochasticDiffFunction[T], init: T): History

abstract def updateHistory(newX: T, newGrad: T, newVal: Double, f: StochasticDiffFunction[T], oldState: State): History

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def adjust(newX: T, newGrad: T, newVal: Double): (Double, T)

def adjustFunction(f: StochasticDiffFunction[T]): StochasticDiffFunction[T]

final def asInstanceOf[T0]: T0

def calculateObjective(f: StochasticDiffFunction[T], x: T, history: History): (Double, T)

def chooseDescentDirection(state: State, fn: StochasticDiffFunction[T]): T

def clone(): AnyRef

val convergenceCheck: ConvergenceCheck[T]

val defaultStepSize: Double

def determineStepSize(state: State, f: StochasticDiffFunction[T], dir: T): Double

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

def infiniteIterations(f: StochasticDiffFunction[T], state: State): Iterator[State]

def initialState(f: StochasticDiffFunction[T], init: T): State

final def isInstanceOf[T0]: Boolean

def iterations(f: StochasticDiffFunction[T], init: T): Iterator[State]

def logger: LazyLogger

val maxIter: Int

def minimize(f: StochasticDiffFunction[T], init: T): T

def minimizeAndReturnState(f: StochasticDiffFunction[T], init: T): State

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def takeStep(state: State, dir: T, stepSize: Double): T

def toString(): String

implicit val vspace: NormedModule[T, Double]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

Deprecated Value Members

def finalize(): Unit

Inherited from FirstOrderMinimizer[T, StochasticDiffFunction[T]]

Inherited from SerializableLogging

Inherited from Serializable

Inherited from Serializable

Inherited from Minimizer[T, StochasticDiffFunction[T]]

Inherited from AnyRef

Inherited from Any

Ungrouped