[Predator] Fix weight flaky loglinear training test.

appengine/findit/crash/loglinear/weight.py

 # Copyright 2017 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
 
 from crash.loglinear.feature import MetaFeatureValue
 from libs.meta_object import Element
 from libs.meta_object import MetaDict
 
@@ skipping 51 matching lines @@
     return math.fabs(self._value)**2
 
   def IsZero(self, epsilon):
     return math.fabs(self._value) <= epsilon
 
 
 class MetaWeight(MetaDict):
   """Dict-like class mapping features in ``Metafeature`` to their weights."""
 
   def IsZero(self, epsilon):
-    """A MetaWeight is zero only when all the sub weights are zeros."""
+    if not self._value:
+      return True
+
     return all(weight.IsZero(epsilon) for weight in self.itervalues())
 
   def DropZeroWeights(self, epsilon=0.):
     """Drops all zero weights."""
+    # Make all sub meta weights drop their zero weights.
+    for weight in self.itervalues():
+      if not weight.is_element:
+        weight.DropZeroWeights(epsilon=epsilon)
+
     self._value = {name: weight for name, weight in self.iteritems()
-                  if not weight.IsZero(epsilon)}
+                   if not weight.IsZero(epsilon)}
 
   def __len__(self):
     return len(self._value)
 
   def __mul__(self, meta_feature):
     """``MetaWeight`` can multiply with ``MetaFeatureValue``."""
-    assert len(self) == len(meta_feature), Exception(

[Sharu Jiang, 2017/03/14 05:06:13]

This assertion should be deleted. Because the ``DropZeroWeights`` will drop all
zeros in meta weight, which will make the length of the ``meta_weight``
different from the length of ``meta_feature``.

In
https://cs.chromium.org/chromium/infra/appengine/findit/crash/loglinear/test/...,
line 55.

If the trained weight happens to be 0 (the training set is randomly generated,
so the training results vary every time), the length of meta weight would be 0,
however the length of meta feature is still 1, the assertion will fail.

-        'MetaWeight can only multiply with ``MetaFeatureValue`` with the '
-        'same length')
-
-    # MetaWeight is a dense representation of a sparse array.
+    # MetaWeight is a dense representation of a sparse array. So MetaWeight and
+    # MetaFeature don't necessarily have the same length.
     return math.fsum(meta_feature[name] * weight
                      for name, weight in self.iteritems())
 
   __rmul__ = __mul__
 
   def __eq__(self, other):
     if len(self) != len(other):
       return False
 
     for key, value in self.iteritems():
@@ skipping 21 matching lines @@
   @property
   def quadrance(self):
     """The square of the l2 norm of the meta weight.
 
     This value is often more helpful to have direct access to, as it
     avoids the need for non-rational functions (e.g., sqrt) and shows up
     as its own quantity in many places. Also, computing it directly avoids
     the error introduced by squaring the square-root of an IEEE-754 float.
     """
     return math.fsum(weight.quadrance for weight in self.itervalues())