[Predator] Fix weight flaky loglinear training test.

appengine/findit/crash/loglinear/test/weight_test.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 unittest
 
 from crash.loglinear.feature import MetaFeatureValue
 from crash.loglinear.weight import MetaWeight
 from crash.loglinear.weight import Weight
 
@@ skipping 42 matching lines @@
 
 class MetaWeightTest(unittest.TestCase):
   """Tests class ``MetaWeight``."""
 
   def testMultiply(self):
     """Tests overloading operators ``__mul__`` and ``__rmul__``"""
     self.assertEqual(MetaWeight({'f1': Weight(0.8), 'f2': Weight(0.4)}) *
                      MetaFeatureValue('f', {'f1': 2., 'f2': 1.}), 2.)
     self.assertEqual(MetaFeatureValue('f', {'f1': 0.8, 'f2': 0.4}) *
                      MetaWeight({'f1': Weight(2.), 'f2': Weight(1.)}), 2.)
-    with self.assertRaisesRegexp(Exception,

[stgao, 2017/03/14 04:34:33]

So you mentioned in the bug "when the trained weights have zeros, assertion
exceptions will raise". But in this testcase, do we use randomly-generated
trained weights? If not, I'm wondering how this became flaky? Is it because of
precision issue in floating point wen compared to zero?

[Sharu Jiang, 2017/03/14 05:09:17]

No, the flaky test is ``testTrainWeights`` in training_test.py. It is because
the training data set of loglinear model is randomly generated.

-                                 ('MetaWeight can only multiply with '
-                                  '``MetaFeatureValue`` '
-                                  'with the same length')):
-      dummy_result = MetaWeight({'f1': 0.8, 'f2': 0.4}) * MetaFeatureValue(
-          'f', {'f1': 2.})
+
+    self.assertEqual(
+        MetaWeight({'f1': Weight(0.8), 'f3': Weight(0.0)}) *
+        MetaFeatureValue('f', {'f1': Weight(2.), 'f2': Weight(9),
+                               'f3': Weight(10)}),
+        1.6)
 
   def testIter(self):
     """Tests overloading operator ``__iter__``."""
     weights = {'a': Weight(0.2), 'b': Weight(0.4), 'c': Weight(3.2)}
     meta_weight = MetaWeight(weights)
     self.assertSetEqual(set(iter(meta_weight)), set(iter(weights)))
     for key, value in meta_weight.iteritems():
       self.assertEqual(value, weights[key])
 
   def testLen(self):
@@ skipping 34 matching lines @@
     """Tests ``l1`` property."""
     self.assertEqual(MetaWeight({'a': Weight(0.3), 'b': Weight(0.2)}).l1, 0.5)
     self.assertEqual(MetaWeight({'a': Weight(0.3), 'b': Weight(-0.3)}).l1, 0.6)
 
   def testquadrance(self):
     """Tests ``quadrance`` property."""
     self.assertEqual(MetaWeight({'a': Weight(0.3),
                                  'b': Weight(0.2)}).quadrance, 0.13)
     self.assertEqual(MetaWeight({'a': Weight(0.3),
                                  'b': Weight(-0.3)}).quadrance, 0.18)