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

appengine/findit/crash/loglinear/feature.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.
 
 from collections import namedtuple
 import math
 
 import libs.math.logarithms as lmath
 
 
@@ skipping 120 matching lines @@
     thinks the ``y`` should be blamed or should not be depends on the sign
     of the value and the sign of the weight given to this feature.) As
     special cases, a value of negative infinity means "do not blame this
     ``y`` no matter what any other features say", and a value of positive
     infinity means "definitely blame this ``y`` no matter what any other
     features say". Both of those special values should be used sparingly,
     since they override the model's ability to combine multiple sources of
     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()}