org.pmml4s.model

MissingValueStrategy

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
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type MissingValueStrategy = Value

  2. class Val extends Value with Serializable

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

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

    Definition Classes
    Enumeration

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

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

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. final def Value(i: Int, name: String): Value

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

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

    Attributes
    protected
    Definition Classes
    Enumeration
  9. final def Value: Value

    Attributes
    protected
    Definition Classes
    Enumeration
  10. val aggregateNodes: Value

    - 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.

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

    Definition Classes
    Enumeration
  12. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  13. def clone(): AnyRef

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

    - 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.

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

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

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

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

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

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

    Definition Classes
    Any
  21. val lastPrediction: Value

    - 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.

  22. final def maxId: Int

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

    Definition Classes
    AnyRef
  24. var nextId: Int

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

    Attributes
    protected
    Definition Classes
    Enumeration
  26. val none: Value

    - 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.

  27. final def notify(): Unit

    Definition Classes
    AnyRef
  28. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  29. val nullPrediction: Value

    - 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.

  30. def readResolve(): AnyRef

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

    Definition Classes
    AnyRef
  32. def toString(): String

    Definition Classes
    Enumeration → AnyRef → Any
  33. def values: ValueSet

    Definition Classes
    Enumeration
  34. final def wait(): Unit

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

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

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

    - 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.

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

    Definition Classes
    Enumeration

Inherited from Enumeration

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped