Learnable

Instance Constructors

new Learnable(node: Node[T], parameters: Parameters = new Learner.Parameters)(implicit tag: ClassTag[T])

node
Node instance associated with the learnable model.
parameters
Parameters for the Learner used
tag
ClassTag of the type of data stored in node

Abstract Value Members

abstract val classifier: Learner

classifier need to be defined by the user
classifier need to be defined by the user

Definition Classes
Learnable → LBJLearnerEquivalent → LBJClassifierEquivalent
abstract def label: Property[T]

Label property for users classifier

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 apply(example: AnyRef): String

syntactic sugar to create simple calls to the function
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def combinedProperties: CombinedDiscreteProperty[T]

filter out the label from the features
def crossValidation(k: Int, splitPolicy: SplitPolicy = SplitPolicy.random, prediction: Property[T] = null, groundTruth: Property[T] = null, exclude: String = "", outputGranularity: Int = 0): Seq[Results]

Run k fold cross validation using the training data.
Run k fold cross validation using the training data. The strategy to split the instances can be set to SplitPolicy.random, SplitPolicy.sequential, SplitPolicy.kth or SplitPolicy.manual if the data splitting policy is not 'Manual', the number of folds must be greater than 1. Otherwise it's value doesn't really matter.
k
number of folds
splitPolicy
strategy to split the instances into k folds.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def feature: List[Property[T]]
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def getClassNameForClassifier: String
def getClassSimpleNameForClassifier: String
def getExampleArray(example: Any): Array[AnyRef]

Definition Classes
LBJLearnerEquivalent
def getLabelLexicon: Lexicon

Definition Classes
LBJLearnerEquivalent
def getLabeler: Classifier

Definition Classes
LBJLearnerEquivalent
def hashCode(): Int

Definition Classes
AnyRef → Any
lazy val internalLogger: Logger

Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var isTraining: Boolean
def lbpFeatures: Classifier
def lcFilePath: URL
def learn(iteration: Int, data: Iterable[T]): Unit
def learn(iteration: Int = 10, parser: Parser)(implicit dummyImplicit: DummyImplicit): Unit
def learn(iteration: Int): Unit
def learnWithDerivedInstances(numIterations: Int, featureVectors: Iterable[FeatureVector]): Unit
def lexFilePath: URL
def load(): Unit
def load(lcFile: URL, lexFile: URL): Unit
def load(lcFile: String, lexFile: String): Unit

Loads the model and lexicon for the classifier.
Loads the model and lexicon for the classifier. Looks up in the local file system and the files are not found, looks up in the classpath JARs.
lcFile
The path of the model file
lexFile
The path of the lexicon file
object logger

Definition Classes
Logging

object loggerConfig

Simple logback configuration.

Simple logback configuration. Hopefully this will be discoverable by just typing loggerConfig.[TAB]

Examples: format: OFF

loggerConfig.Logger("org.apache.spark").setLevel(Level.WARN)

loggerConfig.Logger().addAppender(
  loggerConfig.newPatternLayoutEncoder("%-5level [%thread]: %message%n"),
  loggerConfig.newConsoleAppender
)

format: ON

Definition Classes: Logging

var modelDir: String
var modelSuffix: String

If you have multiple versions/variations of the same classifier, you can set the following variable, in order to save each variation on different files with different suffixes
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nextOf(properties: List[Property[T]]): Property[T]
def nextWithIn[U <: AnyRef](datamodel: DataModel, properties: List[Property[T]])(implicit uTag: ClassTag[U]): Property[T]
val node: Node[T]

Node instance associated with the learnable model.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def on(t: AnyRef): LHSFirstOrderEqualityWithValueLBP

Definition Classes
LBJLearnerEquivalent
val parameters: Parameters

Parameters for the Learner used
def prevOf(properties: List[Property[T]]): Property[T]
def prevWithIn[U <: AnyRef](datamodel: DataModel, property: Property[T]*)(implicit uTag: ClassTag[U]): Property[T]
def printlnModel(): Unit

This function prints a summary of the classifier
def save(): Unit
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def test(testParser: Parser, prediction: Property[T], groundTruth: Property[T], exclude: String, outputGranularity: Int): Results
def test(testData: Iterable[T] = null, prediction: Property[T] = null, groundTruth: Property[T] = null, exclude: String = ""): Results

Test with given data, use internally
Test with given data, use internally
testData
if the collection of data is not given it is derived from the data model based on its type
prediction
it is the property that we want to evaluate it if it is null then the prediction of the classifier is the default
groundTruth
it is the property that we want to evaluate the prediction against it, if it is null then the gold label derived from the classifier is used
exclude
it is the label that we want to exclude fro evaluation, this is useful for evaluating the multi-class classifiers when we need to measure overall F1 instead of accuracy and we need to exclude the negative class
returns
List of Results
def test(): Results

Test with the test data, retrieve internally
Test with the test data, retrieve internally
returns
a Results object
def testContinuous(testData: Iterable[T] = null): Unit

Test with real-valued (continuous) data.
Test with real-valued (continuous) data. Runs Spearman's and Pearson's correlations.
testData
The continuous data to test on
def toString(): String

Definition Classes
AnyRef → Any
def trainingInstances: Iterable[T]
val useCache: Boolean

Whether to use caching
def using(properties: List[Property[T]]): List[Property[T]]
def using(properties: Property[T]*): List[Property[T]]
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( ... )
def window(before: Int, after: Int)(properties: List[Property[T]]): Property[T]
def windowWithin[U <: AnyRef](datamodel: DataModel, before: Int, after: Int, properties: List[Property[T]])(implicit uTag: ClassTag[U], tTag: ClassTag[T]): Property[T]

A windows of properties
A windows of properties
before
always negative (or 0)
after
always positive (or 0)

Related Doc: package classifier

abstract class Learnable[T <: AnyRef] extends LBJLearnerEquivalent with Logging

Instance Constructors

new Learnable(node: Node[T], parameters: Parameters = new Learner.Parameters)(implicit tag: ClassTag[T])

Abstract Value Members

abstract val classifier: Learner

abstract def label: Property[T]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(example: AnyRef): String

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combinedProperties: CombinedDiscreteProperty[T]

def crossValidation(k: Int, splitPolicy: SplitPolicy = SplitPolicy.random, prediction: Property[T] = null, groundTruth: Property[T] = null, exclude: String = "", outputGranularity: Int = 0): Seq[Results]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def feature: List[Property[T]]

def finalize(): Unit

def forget(): Unit

final def getClass(): Class[_]

def getClassNameForClassifier: String

def getClassSimpleNameForClassifier: String

def getExampleArray(example: Any): Array[AnyRef]

def getLabelLexicon: Lexicon

def getLabeler: Classifier

def hashCode(): Int

lazy val internalLogger: Logger

final def isInstanceOf[T0]: Boolean

var isTraining: Boolean

def lbpFeatures: Classifier

def lcFilePath: URL

def learn(iteration: Int, data: Iterable[T]): Unit

def learn(iteration: Int = 10, parser: Parser)(implicit dummyImplicit: DummyImplicit): Unit

def learn(iteration: Int): Unit

def learnWithDerivedInstances(numIterations: Int, featureVectors: Iterable[FeatureVector]): Unit

def lexFilePath: URL

def load(): Unit

def load(lcFile: URL, lexFile: URL): Unit

def load(lcFile: String, lexFile: String): Unit

object logger

object loggerConfig

var modelDir: String

var modelSuffix: String

final def ne(arg0: AnyRef): Boolean

def nextOf(properties: List[Property[T]]): Property[T]

def nextWithIn[U <: AnyRef](datamodel: DataModel, properties: List[Property[T]])(implicit uTag: ClassTag[U]): Property[T]

val node: Node[T]

final def notify(): Unit

final def notifyAll(): Unit

def on(t: AnyRef): LHSFirstOrderEqualityWithValueLBP

val parameters: Parameters

def prevOf(properties: List[Property[T]]): Property[T]

def prevWithIn[U <: AnyRef](datamodel: DataModel, property: Property[T]*)(implicit uTag: ClassTag[U]): Property[T]

def printlnModel(): Unit

def save(): Unit

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

def test(testParser: Parser, prediction: Property[T], groundTruth: Property[T], exclude: String, outputGranularity: Int): Results

def test(testData: Iterable[T] = null, prediction: Property[T] = null, groundTruth: Property[T] = null, exclude: String = ""): Results

def test(): Results

def testContinuous(testData: Iterable[T] = null): Unit

def toString(): String

def trainingInstances: Iterable[T]

val useCache: Boolean

def using(properties: List[Property[T]]): List[Property[T]]

def using(properties: Property[T]*): List[Property[T]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def window(before: Int, after: Int)(properties: List[Property[T]]): Property[T]

def windowWithin[U <: AnyRef](datamodel: DataModel, before: Int, after: Int, properties: List[Property[T]])(implicit uTag: ClassTag[U], tTag: ClassTag[T]): Property[T]

Inherited from Logging

Inherited from LBJLearnerEquivalent

Inherited from LBJClassifierEquivalent

Inherited from AnyRef

Inherited from Any

Ungrouped