brushfire

Type Members

1. case class AccuracyError[L, M]()(implicit m: Monoid[M]) extends FrequencyError[L, M, (M, M)] with Product with Serializable

   

2. case class AnnotatedTree[K, V, T, A](root: Node[K, V, T, A]) extends Product with Serializable

   

3. case class BinnedBinaryError[M]()(implicit evidence$1: Monoid[M]) extends FrequencyError[Boolean, M, Map[Int, (M, M)]] with Product with Serializable

   

4. type BranchLabel[K, V, A] = (K, Predicate[V], A)

   

5. case class BrierScoreError[L, M]()(implicit num: Numeric[M]) extends FrequencyError[L, M, AveragedValue] with Product with Serializable

   

6. case class ConfusionMatrix(truePositives: Double, trueNegatives: Double, falsePositives: Double, falseNegatives: Double) extends Product with Serializable

   

7. case class Continuous[C](continuous: C) extends Dispatched[Nothing, Nothing, C, Nothing] with Product with Serializable

   

8. case class DepthFirstTreeTraversal[Tree, K, V, T, A](reorder: Reorder[A])(implicit treeOps: FullBinaryTreeOps[Tree, BranchLabel[K, V, A], LeafLabel[T, A]], ord: Ordering[V]) extends TreeTraversal[Tree, K, V, T, A] with Product with Serializable

   

9. sealed trait Dispatched[+A, +B, +C, +D] extends AnyRef

   

10. trait Error[T, P, E] extends AnyRef

    

    Computes some kind of error by comparing the trees' predictions to the validation set

11. final case class Fallback[A, B](value: B) extends WithFallback[A, B] with Product with Serializable

    

12. trait FrequencyError[L, M, E] extends Error[Map[L, M], Map[L, Double], E]

    

    FrequencyError sets up the most common case when dealing with discrete distributions: - compute and sum errors separately for each component of the actual distribution - provide a zero for when predictions or actuals are missing

13. class FullBinaryTreeOpsForAnnotatedTree[K, V, T, A] extends FullBinaryTreeOps[AnnotatedTree[K, V, T, A], (K, Predicate[V], A), (Int, T, A)]

    

14. type LeafLabel[T, A] = (Int, T, A)

    

15. case class LeafNode[K, V, T, A](index: Int, target: T, annotation: A) extends Node[K, V, T, A] with Product with Serializable

    

16. case class LimitedTreeTraversal[Tree, K, V, T, A](traversal: TreeTraversal[Tree, K, V, T, A], limit: Int) extends TreeTraversal[Tree, K, V, T, A] with Product with Serializable

    

17. sealed abstract class Node[K, V, T, A] extends AnyRef

    

18. case class Nominal[B](nominal: B) extends Dispatched[Nothing, B, Nothing, Nothing] with Product with Serializable

    

19. case class Ordinal[A](ordinal: A) extends Dispatched[A, Nothing, Nothing, Nothing] with Product with Serializable

    

20. sealed abstract class Predicate[V] extends Product with Serializable

    

    A Predicate is a function which accepts or rejects feature values.

    A Predicate is a function which accepts or rejects feature values.

    Given a value of type V, apply() will return a Boolean indicating whether the predicate matches or not.

    There are six types of predicates:

    • IsEq(c): x == c
    • NotEq(c): x != c
    • Lt(c): x < c
    • LtEq(c): x <= c
    • Gt(c): x > c
    • GtEq(c): x >= c

    Predicates can be negated using !, and can be transformed using map. Evaluating a predicate requires an Ordering, but this constraint is not enforced during construction, only when apply() is invoked.

21. final case class Preferred[A, B](value: A) extends WithFallback[A, B] with Product with Serializable

    

22. trait Reorder[A] extends AnyRef

    

    Simple data type that provides rules to order nodes during traversal.

    Simple data type that provides rules to order nodes during traversal.

    In some cases subtypes of Reorder will also wraps RNG state, for instances that need to randomly select instances. Thus, Reorder is not guaranteed to be referentially-transparent. Fresh instances should be used with each traversal.

    Reorder will also continue to recurse into a given structure using a provided callback method.

    The reason that the node type is provided to apply (instead of Reorder) has to do with how generic trees are specified. Since TreeOps uses path-dependent types to specify node types, the current design is a bit of a kludge that makes it easy to get the types right when handling a Reorder instance to a TreeTraversal instance (which is parameterized on a generic tree type).

23. case class Sparse[D](sparse: D) extends Dispatched[Nothing, Nothing, Nothing, D] with Product with Serializable

    

24. case class SplitNode[K, V, T, A](key: K, predicate: Predicate[V], leftChild: Node[K, V, T, A], rightChild: Node[K, V, T, A], annotation: A) extends Node[K, V, T, A] with Product with Serializable

    

25. type Tree[K, V, T] = AnnotatedTree[K, V, T, Unit]

    

26. trait TreeTraversal[Tree, K, V, T, A] extends AnyRef

    

    A TreeTraversal provides a way to find all of the leaves in a tree that some row can evaluate to.

    A TreeTraversal provides a way to find all of the leaves in a tree that some row can evaluate to. Specifically, there may be cases where multiple predicates in a single split node return true for a given row (eg missing features). A tree traversal chooses which paths to go down (which may be all of them) and the order in which they are traversed.

27. trait Voter[T, P] extends AnyRef

    

    Combines multiple targets into a single prediction *

28. sealed abstract class WithFallback[A, B] extends AnyRef

    

    Allows for typeclasses to be requested, but for fallbacks to be used if the preferred typeclass isn't available.

    Allows for typeclasses to be requested, but for fallbacks to be used if the preferred typeclass isn't available. For example, if you'd prefer a Group because the algorithm will run faster, but can make do with a Monoid you could use an implicit like implicit ev: Group[A] WithFallback Monoid[A].

29. trait WithFallbackLow extends AnyRef