def _RegressionSizeScore(values, step_index):
"""Returns the "regression size" score at the given point."""
left, right = values[:step_index], values[step_index:]
step_size = abs(math_utils.Mean(left) - math_utils.Mean(right))
if not step_size:
return 0.0
distance = _DistanceFromStep(values, step_index)
if not distance:
return float('inf')
return step_size / distance
def testNormalize_ResultMeanIsZeroAndStdDevIsOne(self):
# When a data series is normalized, it is guaranteed that the result
# should have a mean of 0.0 and a standard deviation and variance of 1.0.
_, y_values = zip(*_QUITE_STEPPISH)
normalized = find_step._Normalize(y_values)
self.assertAlmostEqual(0.0, math_utils.Mean(normalized))
self.assertAlmostEqual(1.0, math_utils.StandardDeviation(normalized))
def _ExtractValueAndError(trace):
"""Returns the value and measure of error from a chartjson trace dict.
Args:
trace: A dict that has one "result" from a performance test, e.g. one
"value" in a Telemetry test, with the keys "trace_type", "value", etc.
Returns:
A pair (value, error) where |value| is a float and |error| is some measure
of variance used to show error bars; |error| could be None.
Raises:
BadRequestError: Data format was invalid.
"""
trace_type = trace.get('type')
if trace_type == 'scalar':
value = trace.get('value')
if value is None and trace.get('none_value_reason'):
return float('nan'), 0
try:
return float(value), 0
except:
raise BadRequestError('Expected scalar value, got: %r' % value)
if trace_type == 'list_of_scalar_values':
values = trace.get('values')
if not isinstance(values, list) and values is not None:
# Something else (such as a single scalar, or string) was given.
raise BadRequestError('Expected list of scalar values, got: %r' %
values)
if not values or None in values:
# None was included or values is None; this is not an error if there
# is a reason.
if trace.get('none_value_reason'):
return float('nan'), float('nan')
raise BadRequestError('Expected list of scalar values, got: %r' %
values)
if not all(_IsNumber(v) for v in values):
raise BadRequestError('Non-number found in values list: %r' %
values)
value = math_utils.Mean(values)
std = trace.get('std')
if std is not None:
error = std
else:
error = math_utils.StandardDeviation(values)
return value, error
if trace_type == 'histogram':
return _GeomMeanAndStdDevFromHistogram(trace)
raise BadRequestError('Invalid value type in chart object: %r' %
trace_type)
def testMean_ShortList_SameAsAlternativeImplementation(self):
alternate_mean = lambda xs: sum(xs) / float(len(xs))
self.assertEqual(alternate_mean([-1, 0.12, 0.72, 3.3, 8, 32, 439]),
math_utils.Mean([-1, 0.12, 0.72, 3.3, 8, 32, 439]))
def testMean_ShortList(self):
self.assertEqual(0.5, math_utils.Mean([-3, 0, 1, 4]))
def testMean_OneValue(self):
self.assertEqual(3.0, math_utils.Mean([3]))
def testMean_EmptyInput_ReturnsNan(self):
self.assertTrue(math.isnan(math_utils.Mean([])))
def _MakeSampleStats(sample):
"""Calculates relevant stats for a sample and makes a SampleStats object."""
return SampleStats(math_utils.Mean(sample), math_utils.Variance(sample),
len(sample))
def _StepFunctionValues(values, step_index):
"""Makes values for a step function corresponding to |values|."""
left, right = values[:step_index], values[step_index:]
step_left = len(left) * [math_utils.Mean(left)]
step_right = len(right) * [math_utils.Mean(right)]
return step_left + step_right
def _Normalize(values):
"""Makes a series with the same shape but with variance = 1, mean = 0."""
mean = math_utils.Mean(values)
zeroed = [x - mean for x in values]
stddev = math_utils.StandardDeviation(zeroed)
return [math_utils.Divide(x, stddev) for x in zeroed]
