[Predator] Move ``SingleFeatureScore`` to LLM.

appengine/findit/crash/loglinear/model.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # TODO(http://crbug.com/669639): there are lots of ways to make the code
 # in this file better. We avoid having separate todos per task; instead
 # see that meta-issue ticket.
 
 import math
 import numpy as np
@@ skipping 42 matching lines @@
   where particular values for that random variable called ``y``. The
   partition function is called ``Z``. And (somewhat non-conventionally)
   we will call the log of the partition function ``zeta``.
 
   This class is distinct from ``LogLinearModel`` in that we do not require
   a specification of ``Y``. This class is sufficient for determining
   which ``y`` is the most likely, though it can only return a "score"
   rather than returning a probability per se.
   """
 
-  def __init__(self, feature_function, weights, epsilon=None):
+  def __init__(self, feature_function, weights, feature_to_weight,
+               epsilon=None):

[wrengr, 2017/01/09 19:31:51]

given the dict of weights the list is redundant. For clarity I'd rather keep the
"weights" name for describing the dict

     """Construct a new model with the given weights and feature function.
 
     Args:
       feature_function: A function ``X -> Y -> list(FeatureValue)``. N.B.,
         for all ``x`` and ``y`` the length of ``feature_function(x)(y)``
         must be the same as the length of ``weights``.
       weights (list of float): coefficients for how important we consider
         each component of the feature vector for deciding which ``y``
         to blame.
+      feature_to_weight (dict of float): the weights for the features. The keys
+        of the dictionary are the names of the feature that weight is
+        for. We take this argument as a dict rather than as a list so that
+        callers needn't worry about what order to provide the weights in.
       epsilon (float): The absolute-error threshold for considering a
         weight to be "equal to zero". N.B., this should be a positive
         number, as we will compare it against the absolute value of
         each weight.
     """
     if epsilon is None:
       epsilon = EPSILON
+
+    self._feature_to_weight = feature_to_weight
     self._weights = np.array([

[wrengr, 2017/01/09 19:31:52]

Once we no longer take the list of weights, this will need to be autovivified
somehow. The order of feature names is defined by the final result of
feature_function. Of course, we can't get at the order of that list without
providing the X and Y arguments; so it'd make the most sense to change the
feature_function to be an instance of a class/interface which specifies both the
X -> Y -> list(FV) function as well as the list(str) of feature names. Notably,
this introduces the constraint that all features must have unique names, which
LLM didn't require previously (though SingleFeatureScore did/does assume it).

         w if isinstance(w, float) and math.fabs(w) >= epsilon else 0.
         for w in weights])
 
     self._quadrance = None
 
     # TODO(crbug.com/674752): we need better names for ``self._features``.
     def _Features(x):
       """Wrap ``feature_function`` to memoize things and ensure types.
 
       This outer wrapping takes each ``x`` to a memoized instance of
@@ skipping 23 matching lines @@
     # TODO(crbug.com/674752): we need better names for ``self._scores``.
     # N.B., this is just the inner product of ``self.weights``
     # against ``self._features(x)``. If we can compute this in some
     # more efficient way, we should. In particular, we will want to
     # make the weights sparse, in which case we need to use a sparse
     # variant of the dot product.
     self._scores = MemoizedFunction(lambda x:
         self._features(x).map(lambda fxy:
             self.weights.dot(np.array([feature.value for feature in fxy]))))
 
+  def SingleFeatureScore(self, feature_value):
+    """Returns the score (aka weighted value) of a ``FeatureValue``.
+
+    This function assumes the report's stacktrace has already had any necessary
+    preprocessing (like filtering or truncating) applied.
+
+    Args:
+      feature_value (FeatureValue): the feature value to check.
+
+    Returns:
+      The score of the feature value.
+    """
+    return feature_value.value * self._feature_to_weight.get(
+        feature_value.name, 0.)
+
   def ClearWeightBasedMemos(self):
     """Clear all the memos that depend on the weight covector."""
     self._quadrance = None
     self._scores.ClearMemos()
 
   def ClearAllMemos(self):
     """Clear all memos, even those independent of the weight covector."""
     self.ClearWeightBasedMemos()
     self._features.ClearMemos()
 
@@ skipping 77 matching lines @@
     return self._scores(x)
 
 
 class LogLinearModel(UnnormalizedLogLinearModel):
   """A loglinear probability model.
 
   This class is distinct from ``UnnormalizedLogLinearModel`` in that
   we can provide probabilities (not just scores). However, to do so we
   require a specification of the subsets of ``Y`` for each ``x``.
   """
-  def __init__(self, Y_given_X, feature_function, weights, epsilon=None):
+  def __init__(self, Y_given_X, feature_function, weights, feature_to_weight,
+               epsilon=None):
     """Construct a new probabilistic model.
 
     Args:
       Y_given_X: a function from ``X`` to an iterable object giving the
         subset of ``Y`` which has non-zero probability given the
         ``x``. When in doubt about whether some ``y`` has zero probability
         or not, it is always safe/correct to return a larger subset of
         ``Y`` (it'll just take more computation time is all). This is
         needed for computing the partition function and expectation. N.B.,
         we do not actually need to know/enumerate of *all* of ``Y``,
         only the subsets for each ``x``.
       feature_function: A function ``X -> Y -> list(float)``. N.B.,
         for all ``x`` and ``y`` the length of ``feature_function(x)(y)``
         must be the same as the length of ``weights``.
       weights (list of float): coefficients for how important we consider
         each component of the feature vector for deciding which ``y``
         to blame.

[wrengr, 2017/01/09 19:31:52]

documentation wasn't updated; though see my previous comments.

       epsilon (float): The absolute-error threshold for considering a
         weight to be "equal to zero". N.B., this should be a positive
         number, as we will compare it against the absolute value of
         each weight.
     """
-    super(LogLinearModel, self).__init__(feature_function, weights, epsilon)
+    super(LogLinearModel, self).__init__(feature_function, weights,
+                                         feature_to_weight, epsilon)
 
     self._Y = Y_given_X
 
     def _LogZ(x):
       score_given_x = self._scores(x)
       return logsumexp([score_given_x(y) for y in self._Y(x)])
     self._zetas = MemoizedFunction(_LogZ)
 
   def ClearWeightBasedMemos(self):
     """Clear all the memos that depend on the weight covector."""
@@ skipping 64 matching lines @@
       function returns; rather, it's a sort of average of all the results
       returned. For more information you can take a look at Wikipedia
       <https://en.wikipedia.org/wiki/Expected_value>.
     """
     prob_given_x = self.Probability(x)
     # N.B., the ``*`` below is vector scaling! If we want to make this
     # method polymorphic in the return type of ``f`` then we'll need an
     # API that provides both scaling and ``vsum``.
     return vsum([prob_given_x(y) * f(y) for y in self._Y(x)])