Evaluate the polynomial represented by this object at the point x.
Evaluate the polynomial represented by this object at the point x.
A representation of a point. The representation is as follows: The outer indexed sequence represents groups of features in feature space generated by the same feature expander. The inner sequence is an iterable sequence of key value pairs. This representation is used because it allows efficient encoding of sparse feature spaces. For instance, we can very easily encode multi-part bag of word models as follows. Let's say the 0th index in the outer sequence represents the title of HTML documents and the 1st index represents text inside the body tags in the HTML document.
case class Doc(title: String, body: String) { def multiPartBagOfWords = IndexedSeq(tokens(title), tokens(body)) private[this] def tokens(s: String) = s.trim.toLowerCase.split("\\W+").groupBy(identity).mapValues(_.size.toDouble) } val fox = Doc("fox story", "The quick brown fox jumps over the lazy dog") val p: PolynomialEvaluationAlgo = ... p at fox.multiPartBagOfWords
this polynomial evaluated at x.
Get a NON thread-safe iterator over the nodes in the tree for a DFS ordering.
Get a NON thread-safe iterator over the nodes in the tree for a DFS ordering. Each iterator value contains the node in the tree and the depth (root has 0 depth). This iterator requires O(B * D) auxiliary space where B is the branching factor and D is the tree depth.
a NON thread-safe iterator over the nodes in the tree for a DFS ordering.
A tail-recursive variant of hSmall that won't stack overflow on deep trees.
A tail-recursive variant of hSmall that won't stack overflow on deep trees. This function is slower in empirical tests that hSmall.
an input vector
a stack of trees and current sums at those trees (replaces call stack in non-tail-recursive hSmall).
the current sum.
this polynomial evaluated at x.
Accumulate, in a depth-first way, the evaluation of the polynomial.
Accumulate, in a depth-first way, the evaluation of the polynomial.
NOTE: This algorithm is recursive (but not tail-recursive) by seems to be about 20% faster than the following tail-recursive equivalent. This is probably due to additional object creation in the tail-recursive method. Tuple2 instances must be created and the linked list containers probably needs to be created. In the non-tail recursive version, we don't do any of this and only perform arithmetic operations (aside from the iterators and the Options created in the descendant lookup).
We aren't too afraid of stack overflows because these trees will typically be shallow. This is because most use cases don't involve polynomials in thousands of variables (or of degree in the thousands). That being said, stack overflows are a real possibility (in test at a depth of ~3000). To combat this, hBig is provided but not yet integrated into the at function.
import collection.mutable.{Stack => MStack} def h3(x: IndexedSeq[Seq[(String, Double)]], s: MStack[(MapTreeLike[String, Value], Double)], z: Double): Double = { if (s.isEmpty) z else { val h = s.pop for (i <- h._1.value.applicableFeatures; p <- x(i); c <- h._1.descendants.get(p._1)) s.push((c, p._2 * h._2)) h3(x, s, z + h._1.value.weight * h._2) } }
an input vector
size of input vector (computed once for possible speed improvement).
a tree containing the information necessary to compute the higher order inner product
product of the items in the path from the root to leaf.
this polynomial evaluated at x.
Need to overload so that calling toString doesn't stack overflow like it would with the default implementation.
Need to overload so that calling toString doesn't stack overflow like it would with the default implementation.
Provides a method to evaluate polynomials given an input. Default implementation of com.eharmony.aloha.models.reg.PolynomialEvaluationAlgo.