Implementing a new LogLinearModel-based CL classifier

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 66 matching lines @@
     """
     if epsilon is None:
       epsilon = EPSILON
     self._weights = np.array([
         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 _FeaturesMemoizedOnY(x):
+    def _Features(x):
+      """Wrap ``feature_function`` to memoize things and ensure types.
+
+      This outer wrapping takes each ``x`` to a memoized instance of
+      ``_FeaturesGivenX``. That is, for each ``x`` we return a
+      ``MemoizedFunction`` from ``Y`` to ``list(FeatureValue)``.
+      """
       fx = feature_function(x)
-      def _TypeCheckFeatures(y):
+      def _FeaturesGivenX(y):
+        """Wrap ``feature_function(x)`` to ensure appropriate types.
+
+        This inner wrapper ensures that the resulting ``FeatureValue``
+        array has the same length as the weight covector.
+        """
         fxy = fx(y)
         # N.B., we're assuming that ``len(self.weights)`` is O(1).
         assert len(fxy) == len(self.weights), TypeError(
             "vector length mismatch: %d != %d" % (len(fxy), len(self.weights)))
         return fxy
-      return MemoizedFunction(_TypeCheckFeatures)
-    self._features = MemoizedFunction(_FeaturesMemoizedOnY)
+
+      # Memoize on ``Y``, to ensure we don't need to recompute
+      # ``FeatureValue``s nor recheck the lengths.
+      return MemoizedFunction(_FeaturesGivenX)
+
+    # Memoize on ``X``, to ensure we share the memo tables on ``Y``.
+    self._features = MemoizedFunction(_Features)
 
     # 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(map(lambda feature:
-                feature.value, fxy)))))
+            self.weights.dot(np.array([feature.value for feature in fxy]))))
 
   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 180 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])