Re-applying reverted changes for regression confidence check + fix: ConfidenceScoretakes flat lists

tools/auto_bisect/bisect_results.py

 # Copyright 2014 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 os
 
 import bisect_utils
 import math_utils
 import source_control
@@ skipping 91 matching lines @@
     if 0 < confidence < bisect_utils.HIGH_CONFIDENCE:
       warnings.append('Confidence is not high. Try bisecting again '
                       'with increased repeat_count, larger range, or '
                       'on another metric.')
     if not confidence:
       warnings.append('Confidence score is 0%. Try bisecting again on '
                       'another platform or another metric.')
     return warnings
 
   @staticmethod
-  def ConfidenceScore(good_results_lists, bad_results_lists,
+  def ConfidenceScore(sample1, sample2,
                       accept_single_bad_or_good=False):
     """Calculates a confidence score.
 
     This score is a percentage which represents our degree of confidence in the
     proposition that the good results and bad results are distinct groups, and
     their differences aren't due to chance alone.
 
 
     Args:
-      good_results_lists: A list of lists of "good" result numbers.
-      bad_results_lists: A list of lists of "bad" result numbers.
+      sample1: A flat list of "good" result numbers.
+      sample2: A flat list of "bad" result numbers.
       accept_single_bad_or_good: If True, computes confidence even if there is
           just one bad or good revision, otherwise single good or bad revision
           always returns 0.0 confidence. This flag will probably get away when
           we will implement expanding the bisect range by one more revision for
           such case.
 
     Returns:
       A number in the range [0, 100].
     """
     # If there's only one item in either list, this means only one revision was
     # classified good or bad; this isn't good enough evidence to make a
     # decision. If an empty list was passed, that also implies zero confidence.
     if not accept_single_bad_or_good:
-      if len(good_results_lists) <= 1 or len(bad_results_lists) <= 1:
+      if len(sample1) <= 1 or len(sample2) <= 1:
         return 0.0
 
-    # Flatten the lists of results lists.
-    sample1 = sum(good_results_lists, [])
-    sample2 = sum(bad_results_lists, [])
-
     # If there were only empty lists in either of the lists (this is unexpected
     # and normally shouldn't happen), then we also want to return 0.
     if not sample1 or not sample2:
       return 0.0
 
     # The p-value is approximately the probability of obtaining the given set
     # of good and bad values just by chance.
     _, _, p_value = ttest.WelchsTTest(sample1, sample2)
     return 100.0 * (1.0 - p_value)
 
@@ skipping 10 matching lines @@
       A list of [current_rev, previous_rev, confidence] for other places where
       there may have been a regression.
     """
     other_regressions = []
     previous_values = []
     prev_state = None
     for revision_state in revision_states:
       if revision_state.value:
         current_values = revision_state.value['values']
         if previous_values:
-          confidence = cls.ConfidenceScore(previous_values, [current_values],
+          confidence_params = (sum(previous_values, []),
+                               sum([current_values], []))
+          confidence = cls.ConfidenceScore(*confidence_params,
                                            accept_single_bad_or_good=True)
           mean_of_prev_runs = math_utils.Mean(sum(previous_values, []))
           mean_of_current_runs = math_utils.Mean(current_values)
 
           # Check that the potential regression is in the same direction as
           # the overall regression. If the mean of the previous runs < the
           # mean of the current runs, this local regression is in same
           # direction.
           prev_greater_than_current = mean_of_prev_runs > mean_of_current_runs
           is_same_direction = (prev_greater_than_current if
@@ skipping 61 matching lines @@
     if math.isnan(regression_size):
       regression_size = 'zero-to-nonzero'
 
     regression_std_err = math.fabs(math_utils.PooledStandardError(
         [working_mean, broken_mean]) /
         max(0.0001, min(mean_of_good_runs, mean_of_bad_runs))) * 100.0
 
     # Give a "confidence" in the bisect. At the moment we use how distinct the
     # values are before and after the last broken revision, and how noisy the
     # overall graph is.
-    confidence = cls.ConfidenceScore(working_means, broken_means)
+    confidence_params = (sum(working_means, []), sum(broken_means, []))
+    confidence = cls.ConfidenceScore(*confidence_params)
 
     bad_greater_than_good = mean_of_bad_runs > mean_of_good_runs
 
     return {'regression_size': regression_size,
             'regression_std_err': regression_std_err,
             'confidence': confidence,
             'bad_greater_than_good': bad_greater_than_good}