KernelSparkModel

abstract def clearParameters(): Unit

abstract def evaluate(config: Map[String, String]): Metrics[Double]

abstract def evaluateFold(params: DenseVector[Double])(test_data_set: RDD[LabeledPoint])(task: String): Metrics[Double]

abstract def getRegParam: Double

abstract def learn(): Unit

Learn the parameters of the model.

abstract val optimizer: RegularizedOptimizer[DenseVector[Double], DenseVector[Double], Double, RDD[LabeledPoint]]

abstract val params: DenseVector[Double]

abstract def predict(point: DenseVector[Double]): Double

Predict the value of the target variable given a point.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def _current_state: Map[String, Double]

def _hyper_parameters: List[String]

def applyFeatureMap: Unit

def applyKernel(kernel: SVMKernel[DenseMatrix[Double]], M: Int = math.sqrt(npoints).toInt): Unit

Implements the changes in the model after application of a given kernel.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val colStats: MultivariateStatisticalSummary

def crossvalidate(folds: Int, reg: Double, optionalStateFlag: Boolean = false): (Double, Double, Double)

var current_state: Map[String, Double]

A Map which stores the current state of the system.

def data: RDD[(Long, LabeledPoint)]

var effectivedims: Int

def energy(h: Map[String, Double], options: Map[String, String]): Double

Calculates the energy of the configuration, in most global optimization algorithms we aim to find an approximate value of the hyper-parameters such that this function is minimized.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var featureMap: (DenseVector[Double]) ⇒ DenseVector[Double]

The non linear feature mapping implicitly defined by the kernel applied, this is initialized to an identity map.

var featuredims: Int

def finalize(): Unit

val g: RDD[(Long, LabeledPoint)]

The training data

final def getClass(): Class[_]

def getXYEdges: RDD[LabeledPoint]

def hashCode(): Int

var hyper_parameters: List[String]

Stores the names of the hyper-parameters

def initParams(): DenseVector[Double]

final def isInstanceOf[T0]: Boolean

val logger: Logger

val nPoints: Long

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def npoints: Long

def optimumSubset(M: Int): Unit

Calculate an approximation to the subset of size M with the maximum entropy.

def parameters(): DenseVector[Double]

Get the value of the parameters of the model.

def persist(state: Map[String, Double]): Unit

var points: List[Long]

This variable stores the indexes of the prototype points of the data set.

var processed_g: RDD[(Long, LabeledPoint)]

var prototypes: List[DenseVector[Double]]

def setBatchFraction(f: Double): KernelSparkModel.this.type

def setLearningRate(alpha: Double): KernelSparkModel.this.type

def setMaxIterations(i: Int): KernelSparkModel.this.type

def setMiniBatchFraction(f: Double): KernelSparkModel.this.type

def setRegParam(r: Double): KernelSparkModel.this.type

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

val task: String

def toString(): String

def trainTest(test: List[Long]): (RDD[LabeledPoint], RDD[LabeledPoint])

def updateParameters(param: DenseVector[Double]): Unit

implicit val vecField: VectorField

final def wait(): Unit

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

final def wait(arg0: Long): Unit