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

appengine/findit/crash/loglinear/feature.py

Index: appengine/findit/crash/loglinear/feature.py
diff --git a/appengine/findit/crash/loglinear/feature.py b/appengine/findit/crash/loglinear/feature.py
index 20cda371f4b9ab7c92d40f972f748ebddb8a1f76..b0ff22a18795163d529bfd5ba016c166a9413d8f 100644
--- a/appengine/findit/crash/loglinear/feature.py
+++ b/appengine/findit/crash/loglinear/feature.py
@@ -138,3 +138,26 @@ class Feature(object):
     information and decide the cuplrit based on all the evidence together.
     """
     raise NotImplementedError()
+
+
+class FeatureFunction(object):
+  """Given a dict of scalar-valued functions, return an dict-valued function.
+
+  Properties:
+    fs (list of functions): A collection of curried functions ``X -> Y -> A``.

[wrengr, 2017/01/11 20:38:30]

Type of ``fs`` should be an iterable of ``Feature`` objects. And since w're
making this a class rather than a generic function, you might as well say
``FeatureValue`` rather than ``A``.

Also, note that if we start with an iterator(Feature), there's no way to share
work among the different features. So this shouldn't be the only way we have of
constructing a ``FeatureFunction``. In general, a FeatureFunction can be *any*
function of type X -> Y -> dict(FeatureValue) [1]. There are a bunch of
different ways to construct such a function, not just by gluing together a list
of Features (e.g., we could also glue together a list of FeatureFunctions to get
a single FeatureFunction; thus FeatureFunction is also what we've been calling a
"metafeature"). This is why I had ToFeatureFunction as a standalone function
rather than as a class.

[1]: or per crbug.com/680207, any function of type X -> Y -> FeatureName ->
FeatureValue. We might possibly want to amend that with a frozenset(FeatureName)
so that we know all possible keys of our "lazy dict", since that may come in
handy for creating new FeatureFunction objects from old ones; however it is
unnecessary for scoring purposes.

[Sharu Jiang, 2017/01/12 01:41:38]

Acknowledged.

+    That is, given a particular ``x`` they return a function ``Y -> A``. N.B.
+    each function should have a name property.
+  """
+  def __init__(self, fs):
+    self._fs = fs
+
+  def __call__(self, x):
+    """Fuction mapping ``X -> Y -> dict(A.name to A).
+
+    Returns:
+      A function ``X -> Y -> dict(A.name to A)`` where for all ``x``, ``y``, and
+     for a feature f in fs, we have
+      ``ToFeatureFunction(fs)(x)(y)[f.name] == f(x)(y)``.

[wrengr, 2017/01/11 20:38:30]

the name "ToFeatureFunction"is no longer used anywhere, so you should rephrase
this to: ``FeatureFunction(fs)(x)(y)[i] == fs[i](x)(y)``

[Sharu Jiang, 2017/01/12 01:41:38]

Done.

+    """
+    name_to_fx = {f.name: f(x) for f in self._fs}
+    return lambda y: {name: fx(y) for name, fx in name_to_fx.iteritems()}