[Predator] Making the Y sets conditional for loglinear models

appengine/findit/crash/loglinear/training.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.
 
 import math
 import numpy as np
 # N.B., ``np.array`` can't take generators; you must pass explicit lists.
 import scipy.optimize as spo
 
 from crash.loglinear.model import LogLinearModel
 from libs.math.vectors import vsum
 # N.B., ``vsum`` can't take generators; you must pass explicit lists.
 
 
 class TrainableLogLinearModel(LogLinearModel):
   """A loglinear model with some labelled data set for training the weights."""
 
-  def __init__(self, Y, training_data, feature_function, initial_weights,
-               epsilon=None):
+  def __init__(self, Y_given_X, training_data, feature_function,
+               initial_weights, epsilon=None):
     """
     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``.
       training_data (iterable): a collection of ``(x, y)`` pairs where
         ``y`` is the known-correct label for ``x``.
       feature_function: A function from ``X`` to ``Y`` to a list of
         ``float``. N.B., the length of the list must be the same for all
         ``x`` and ``y``, and must be the same as the length of the list
         of weights.
       initial_weights (list of float): the pre-training coefficients
         for how much we believe components of the feature vector. This
         provides the seed for training; this starting value shouldn't
         affect the final weights obtained by training (thanks to
         convexity), but will affect how long it takes for training
         to converge.
       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(TrainableLogLinearModel, self).__init__(
-        Y, feature_function, initial_weights, epsilon)
+        Y_given_X, feature_function, initial_weights, epsilon)
     self._training_data = training_data
 
     self._observed_feature_vector = vsum([
         self.FeaturesAsNumPyArray(x)(y)
         for x, y in self._training_data])
 
   # Even though this is identical to the superclass definition, we must
   # re-provide it in order to define the setter.
   @property
   def weights(self):
@@ skipping 117 matching lines @@
           '\n\tCurrent objective gradient: %s'
           '\n\tIterations: %d'
           '\n\tFunction evaluations: %d'
           '\n\tGradient evaluations: %d'
           % (result.message, result.fun, result.jac, result.nit, result.nfev,
              result.njev))
 
     # This shouldn't really be necessary, since we're resetting it
     # directly during training; but just to be safe/sure.
     self.weights = result.x