[Predator] Making the Y sets conditional for loglinear models

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 33 matching lines @@
   give to each feature from the feature itself, and (b) they allow us
   to keep adding features at will without needing to worry about the
   fiddly details needed for it to be a probability model.
 
   Throughout the documentation we use the following conventional
   terminology. The independent variable (aka: the given data which
   sets up the classification problem) is called ``X``, where particular
   values for that variable called ``x``. The dependent variable (aka:
   the answers/labels returned by classification) is called ``Y``,
   where particular values for that random variable called ``y``. The
-  partition function is called ``Z``. And, somewhat non-conventionally,
+  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):
     """Construct a new model with the given weights and feature function.
@@ skipping 144 matching lines @@
       A ``MemoizedFunction`` of type ``Y -> float``.
     """
     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 entire set ``Y``.
+  require a specification of the subsets of ``Y`` for each ``x``.
   """
-  def __init__(self, Y, feature_function, weights, epsilon=None):
+  def __init__(self, Y_given_X, feature_function, weights, epsilon=None):
     """Construct a new probabilistic model.
 
     Args:
-      Y (iterable): the entire range of values for the independent
-        variable. This is needed for computing the partition function.
+      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.
       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)
 
-    self._Y = frozenset(Y)
+    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])
+      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."""
     super(LogLinearModel, self).ClearWeightBasedMemos()
     self._zetas.ClearMemos()
 
   def Z(self, x):
     """The normal-domain conditional partition-function given ``x``.
 
@@ skipping 56 matching lines @@
       An ``np.ndarray`` of ``float`` called the "expected value". N.B.,
       the particular array returned may not actually be one that the
       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])
+    return vsum([prob_given_x(y) * f(y) for y in self._Y(x)])