SeparableStationaryKernel

Instance Constructors

new SeparableStationaryKernel(firstKernel: Kernel, otherKernel: Kernel)

firstKernel
The kernel given by K1, it is assumed that the user inputs a valid stationary kernel of type Kernel
otherKernel
The kernel given by K2, it is assumed that the user inputs a valid stationary kernel of type Kernel

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def *(c: Double): LocalScalarKernel[I]

Returns the kernel multiplied by a positive constant: k_new = k*c
Returns the kernel multiplied by a positive constant: k_new = k*c

Definition Classes
LocalScalarKernel
def *[T <: LocalScalarKernel[I]](otherKernel: T)(implicit ev: ClassTag[I]): CompositeCovariance[I]

Create composite kernel k = k₁ * k₂
Create composite kernel k = k₁ * k₂
otherKernel
The kernel to multiply to the current one.
returns
The kernel k defined above.

Definition Classes
LocalScalarKernel
def +[T <: LocalScalarKernel[I]](otherKernel: T)(implicit ev: ClassTag[I]): CompositeCovariance[I]

Create composite kernel k = k₁ + k₂
Create composite kernel k = k₁ + k₂
param otherKernel The kernel to add to the current one. return The kernel k defined above.

Definition Classes
LocalScalarKernel
def :*[T1](otherKernel: LocalScalarKernel[T1]): KroneckerProductKernel[I, T1]

Construct the kronecker product kernel
Construct the kronecker product kernel

Definition Classes
LocalScalarKernel
def :+[T1](otherKernel: LocalScalarKernel[T1]): CompositeCovariance[(I, T1)]

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

Definition Classes
AnyRef → Any
def >[K <: GenericRBFKernel[I]](otherKernel: K): CompositeCovariance[I]

Construct a 2 layer kernel K = k1 > rbf
Construct a 2 layer kernel K = k1 > rbf

Definition Classes
LocalScalarKernel
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asPipe: DataPipe[Map[String, Double], LocalScalarKernel[I]]

Get a pipeline which when given a particular configuration of hyper-parameters returns this kernel function set with that configuration.
Get a pipeline which when given a particular configuration of hyper-parameters returns this kernel function set with that configuration.

Definition Classes
LocalScalarKernel
def block(h: String*): Unit

Definition Classes
MultiplicativeCovariance → CovarianceFunction
def block_all_hyper_parameters: Unit

Definition Classes
CovarianceFunction
var blocked_hyper_parameters: List[String]

Definition Classes
CovarianceFunction
def buildBlockedCrossKernelMatrix[S <: Seq[I]](dataset1: S, dataset2: S): PartitionedMatrix

Definition Classes
LocalScalarKernel
def buildBlockedKernelMatrix[S <: Seq[I]](mappedData: S, length: Long): PartitionedPSDMatrix

Definition Classes
LocalScalarKernel
def buildCrossKernelMatrix[S <: Seq[I]](dataset1: S, dataset2: S): DenseMatrix[Double]

Definition Classes
MultiplicativeCovariance → LocalScalarKernel → CovarianceFunction
def buildKernelMatrix[S <: Seq[I]](mappedData: S, length: Int): KernelMatrix[DenseMatrix[Double]]

Definition Classes
MultiplicativeCovariance → LocalScalarKernel → CovarianceFunction
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
var colBlocking: Int

Definition Classes
LocalScalarKernel
def effective_hyper_parameters: List[String]

Definition Classes
CovarianceFunction
def effective_state: Map[String, Double]

Definition Classes
CovarianceFunction
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def evaluate(x: I, y: I): Double

Definition Classes
CovarianceFunction → Kernel
def evaluateAt(config: Map[String, Double])(x: I, y: I): Double

Definition Classes
SeparableStationaryKernel → MultiplicativeCovariance → LocalSVMKernel → CovarianceFunction
val fID: String

Definition Classes
MultiplicativeCovariance
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val firstKernel: Kernel

The kernel given by K1, it is assumed that the user inputs a valid stationary kernel of type Kernel
The kernel given by K1, it is assumed that the user inputs a valid stationary kernel of type Kernel

Definition Classes
SeparableStationaryKernel → MultiplicativeCovariance
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getKernelConfigs(config: Map[String, Double]): (Map[String, Double], Map[String, Double])

Attributes
protected
Definition Classes
MultiplicativeCovariance
def getKernelHyp(s: Seq[String]): (Seq[String], Seq[String])

Attributes
protected
Definition Classes
MultiplicativeCovariance
def gradient(x: I, y: I): Map[String, Double]

Definition Classes
CovarianceFunction
def gradientAt(config: Map[String, Double])(x: I, y: I): Map[String, Double]

Definition Classes
SeparableStationaryKernel → MultiplicativeCovariance → LocalSVMKernel → CovarianceFunction
def hashCode(): Int

Definition Classes
AnyRef → Any
val hyper_parameters: List[String]

Definition Classes
MultiplicativeCovariance → CovarianceFunction
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val otherKernel: Kernel

The kernel given by K2, it is assumed that the user inputs a valid stationary kernel of type Kernel
The kernel given by K2, it is assumed that the user inputs a valid stationary kernel of type Kernel

Definition Classes
SeparableStationaryKernel → MultiplicativeCovariance
var rowBlocking: Int

Definition Classes
LocalScalarKernel
val sID: String

Definition Classes
MultiplicativeCovariance
def setBlockSizes(s: (Int, Int)): Unit

Definition Classes
LocalScalarKernel
def setHyperParameters(h: Map[String, Double]): SeparableStationaryKernel.this.type

Definition Classes
MultiplicativeCovariance → CovarianceFunction
var state: Map[String, Double]

Definition Classes
CovarianceFunction
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

Related Doc: package kernels

class SeparableStationaryKernel[I, Kernel <: StationaryKernel[I, Double, DenseMatrix[Double]] with LocalScalarKernel[I]] extends MultiplicativeCovariance[I]

Instance Constructors

new SeparableStationaryKernel(firstKernel: Kernel, otherKernel: Kernel)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(c: Double): LocalScalarKernel[I]

def *[T <: LocalScalarKernel[I]](otherKernel: T)(implicit ev: ClassTag[I]): CompositeCovariance[I]

def +[T <: LocalScalarKernel[I]](otherKernel: T)(implicit ev: ClassTag[I]): CompositeCovariance[I]

def :*[T1](otherKernel: LocalScalarKernel[T1]): KroneckerProductKernel[I, T1]

def :+[T1](otherKernel: LocalScalarKernel[T1]): CompositeCovariance[(I, T1)]

final def ==(arg0: Any): Boolean

def >[K <: GenericRBFKernel[I]](otherKernel: K): CompositeCovariance[I]

final def asInstanceOf[T0]: T0

def asPipe: DataPipe[Map[String, Double], LocalScalarKernel[I]]

def block(h: String*): Unit

def block_all_hyper_parameters: Unit

var blocked_hyper_parameters: List[String]

def buildBlockedCrossKernelMatrix[S <: Seq[I]](dataset1: S, dataset2: S): PartitionedMatrix

def buildBlockedKernelMatrix[S <: Seq[I]](mappedData: S, length: Long): PartitionedPSDMatrix

def buildCrossKernelMatrix[S <: Seq[I]](dataset1: S, dataset2: S): DenseMatrix[Double]

def buildKernelMatrix[S <: Seq[I]](mappedData: S, length: Int): KernelMatrix[DenseMatrix[Double]]

def clone(): AnyRef

var colBlocking: Int

def effective_hyper_parameters: List[String]

def effective_state: Map[String, Double]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluate(x: I, y: I): Double

def evaluateAt(config: Map[String, Double])(x: I, y: I): Double

val fID: String

def finalize(): Unit

val firstKernel: Kernel

final def getClass(): Class[_]

def getKernelConfigs(config: Map[String, Double]): (Map[String, Double], Map[String, Double])

def getKernelHyp(s: Seq[String]): (Seq[String], Seq[String])

def gradient(x: I, y: I): Map[String, Double]

def gradientAt(config: Map[String, Double])(x: I, y: I): Map[String, Double]

def hashCode(): Int

val hyper_parameters: List[String]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val otherKernel: Kernel

var rowBlocking: Int

val sID: String

def setBlockSizes(s: (Int, Int)): Unit

def setHyperParameters(h: Map[String, Double]): SeparableStationaryKernel.this.type

var state: Map[String, Double]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from MultiplicativeCovariance[I]

Inherited from CompositeCovariance[I]

Inherited from LocalSVMKernel[I]

Inherited from LocalScalarKernel[I]

Inherited from CovarianceFunction[I, Double, DenseMatrix[Double]]

Inherited from Kernel[I, Double]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped