Object

org.pmml4s.model

MissingValueStrategy

Related Doc: package model

Permalink

object MissingValueStrategy extends Enumeration

Defines a strategy for dealing with missing values.

Linear Supertypes
Enumeration, Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. MissingValueStrategy
  2. Enumeration
  3. Serializable
  4. Serializable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type MissingValueStrategy = Value

    Permalink
  2. class Val extends Value with Serializable

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
    Annotations
    @SerialVersionUID()
  3. abstract class Value extends Ordered[Value] with Serializable

    Permalink
    Definition Classes
    Enumeration
    Annotations
    @SerialVersionUID()
  4. class ValueSet extends AbstractSet[Value] with SortedSet[Value] with SortedSetLike[Value, ValueSet] with Serializable

    Permalink
    Definition Classes
    Enumeration

Value Members

  1. final def !=(arg0: Any): Boolean

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

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

    Permalink
    Definition Classes
    AnyRef → Any
  4. final def Value(i: Int, name: String): Value

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  5. final def Value(name: String): Value

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  6. final def Value(i: Int): Value

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  7. final def Value: Value

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  8. val aggregateNodes: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  9. final def apply(x: Int): Value

    Permalink
    Definition Classes
    Enumeration
  10. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  11. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. val defaultChild: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  13. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  14. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  15. def finalize(): Unit

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

    Permalink
    Definition Classes
    AnyRef → Any
  17. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  18. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  19. val lastPrediction: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  20. final def maxId: Int

    Permalink
    Definition Classes
    Enumeration
  21. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  22. var nextId: Int

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  23. var nextName: Iterator[String]

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  24. val none: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  25. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  26. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  27. val nullPrediction: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  28. def readResolve(): AnyRef

    Permalink
    Attributes
    protected
    Definition Classes
    Enumeration
  29. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  30. def toString(): String

    Permalink
    Definition Classes
    Enumeration → AnyRef → Any
  31. def values: ValueSet

    Permalink
    Definition Classes
    Enumeration
  32. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  33. final def wait(arg0: Long, arg1: Int): Unit

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

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  35. val weightedConfidence: Value

    Permalink

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction.

    - lastPrediction: If a Node's predicate evaluates to UNKNOWN while traversing the tree, evaluation is stopped and the current winner is returned as the final prediction. - nullPrediction: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, abort the scoring process and give no prediction. - defaultChild: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, evaluate the attribute defaultChild which gives the child to continue traversing with. Requires the presence of the attribute defaultChild in every non-leaf Node. - weightedConfidence: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, the confidences for each class is calculated from scoring it and each of its sibling Nodes in turn (excluding any siblings whose predicates evaluate to FALSE). The confidences returned for each class from each sibling Node that was scored are weighted by the proportion of the number of records in that Node, then summed to produce a total confidence for each class. The winner is the class with the highest confidence. Note that weightedConfidence should be applied recursively to deal with situations where several predicates within the tree evaluate to UNKNOWN during the scoring of a case. - aggregateNodes: If a Node's predicate value evaluates to UNKNOWN while traversing the tree, we consider evaluation of the Node's predicate being TRUE and follow this Node. In addition, subsequent Nodes to the initial Node are evaluated as well. This procedure is applied recursively for each Node being evaluated until a leaf Node is reached. All leaf Nodes being reached by this procedure are aggregated such that for each value attribute of such a leaf Node's ScoreDistribution element the corresponding recordCount attribute values are accumulated. The value associated with the highest recordCount accumulated through this procedure is predicted. The basic idea of missingValueStrategy aggregateNodes is to aggregate all leaf Nodes which may be reached by a record with one or more missing values considering all possible values. Strategy aggregateNodes calculates a virtual Node and predicts a score according to this virtual Node. Requires the presence of attribute recordCount in all ScoreDistribution elements. - none: Comparisons with missing values other than checks for missing values always evaluate to FALSE. If no rule fires, then use the noTrueChildStrategy to decide on a result. This option requires that missing values be handled after all rules at the Node have been evaluated. Note: In contrast to lastPrediction, evaluation is carried on instead of stopping immediately upon first discovery of a Node who's predicate value cannot be determined due to missing values.

  36. final def withName(s: String): Value

    Permalink
    Definition Classes
    Enumeration

Inherited from Enumeration

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped