ConstrainedClassifier

Instance Constructors

new ConstrainedClassifier(onClassifier: LBJLearnerEquivalent)(implicit tType: ClassTag[T], headType: ClassTag[HEAD])

Type Members

type LEFT = T
type RIGHT = HEAD

Abstract Value Members

abstract def subjectTo: LfsConstraint[HEAD]

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 __allowableValues: List[String]
def apply(example: AnyRef): String

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

Definition Classes
Any
def buildWithConstraint(inferenceCondition: InferenceCondition[T, HEAD])(t: T): String
def buildWithConstraint(infer: InferenceCondition[T, HEAD], cls: Learner)(t: T): String
def className: String
val classifier: Classifier

Definition Classes
ConstrainedClassifier → LBJClassifierEquivalent
def clone(): AnyRef

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

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

Definition Classes
AnyRef → Any
def filter(t: T, head: HEAD): Boolean

The function is used to filter the generated candidates from the head object; remember that the inference starts from the head object.
The function is used to filter the generated candidates from the head object; remember that the inference starts from the head object. This function finds the objects of type T which are connected to the target object of type HEAD. If we don't define filter, by default it returns all objects connected to HEAD. The filter is useful for the JointTraining when we go over all global objects and generate all contained object that serve as examples for the basic classifiers involved in the JoinTraining. It is possible that we do not want to use all possible candidates but some of them, for example when we have a way to filter the negative candidates, this can come in the filter.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findHead(x: T): Option[HEAD]
def getCandidates(head: HEAD): Seq[T]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getClassSimpleNameForClassifier: String
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit val headType: ClassTag[HEAD]
lazy val internalLogger: Logger

Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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

final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val onClassifier: LBJLearnerEquivalent
val pathToHead: Option[Edge[T, HEAD]]

The pathToHead returns only one object of type HEAD, if there are many of them i.e.
The pathToHead returns only one object of type HEAD, if there are many of them i.e. Iterable[HEAD] then it simply returns the head of the Iterable
def solver: ILPSolver
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit val tType: ClassTag[T]
def test(testData: Iterable[T] = null, outFile: String = null, outputGranularity: Int = 0, exclude: String = ""): Results

Test with given data, use internally
Test with given data, use internally
testData
if the collection of data (which is and Iterable of type T) is not given it is derived from the data model based on its type
outFile
The file to write the predictions (can be null)
exclude
it is the label that we want to exclude for 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 (label, (f1,precision,recall))
def test(): Results

Test Constrained Classifier with automatically derived test instances.
Test Constrained Classifier with automatically derived test instances.
returns
List of (label, (f1,precision,recall))
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 Docs: object ConstrainedClassifier | package classifier

abstract class ConstrainedClassifier[T <: AnyRef, HEAD <: AnyRef] extends LBJClassifierEquivalent with Logging

Instance Constructors

new ConstrainedClassifier(onClassifier: LBJLearnerEquivalent)(implicit tType: ClassTag[T], headType: ClassTag[HEAD])

Type Members

type LEFT = T

type RIGHT = HEAD

Abstract Value Members

abstract def subjectTo: LfsConstraint[HEAD]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def __allowableValues: List[String]

def apply(example: AnyRef): String

final def asInstanceOf[T0]: T0

def buildWithConstraint(inferenceCondition: InferenceCondition[T, HEAD])(t: T): String

def buildWithConstraint(infer: InferenceCondition[T, HEAD], cls: Learner)(t: T): String

def className: String

val classifier: Classifier

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(t: T, head: HEAD): Boolean

def finalize(): Unit

def findHead(x: T): Option[HEAD]

def getCandidates(head: HEAD): Seq[T]

final def getClass(): Class[_]

def getClassSimpleNameForClassifier: String

def hashCode(): Int

implicit val headType: ClassTag[HEAD]

lazy val internalLogger: Logger

final def isInstanceOf[T0]: Boolean

object logger

object loggerConfig

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val onClassifier: LBJLearnerEquivalent

val pathToHead: Option[Edge[T, HEAD]]

def solver: ILPSolver

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

implicit val tType: ClassTag[T]

def test(testData: Iterable[T] = null, outFile: String = null, outputGranularity: Int = 0, exclude: String = ""): Results

def test(): Results

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Logging

Inherited from LBJClassifierEquivalent

Inherited from AnyRef

Inherited from Any

Ungrouped