diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..fee0094 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,34 @@ +# Contributing to bootstrapped +We want to make contributing to this project as easy and transparent as +possible. + +## Pull Requests +We actively welcome your pull requests. + +1. Fork the repo and create your branch from `master`. +2. If you've added code that should be tested, add tests. +3. If you've changed APIs, update the documentation. +4. Ensure the test suite passes. +5. Make sure your code lints. +6. If you haven't already, complete the Contributor License Agreement ("CLA"). + +## Contributor License Agreement ("CLA") +In order to accept your pull request, we need you to submit a CLA. You only need +to do this once to work on any of Facebook's open source projects. + +Complete your CLA here: + +## Issues +We use GitHub issues to track public bugs. Please ensure your description is +clear and has sufficient instructions to be able to reproduce the issue. + +Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe +disclosure of security bugs. In those cases, please go through the process +outlined on that page and do not file a public issue. + +## Coding Style +Please use pylint with the default settings. + +## License +By contributing to bootstrapped, you agree that your contributions will be licensed +under its BSD license. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8d67865 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +BSD License + +For bootstrapped software + +Copyright (c) 2016-present, Facebook, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/LICENSE-examples b/LICENSE-examples new file mode 100644 index 0000000..1de7813 --- /dev/null +++ b/LICENSE-examples @@ -0,0 +1,11 @@ +Copyright (c) 2016-present, Facebook, Inc. All rights reserved. + +The examples provided by Facebook are for non-commercial testing and evaluation +purposes only. Facebook reserves all rights not expressly granted. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/PATENTS b/PATENTS new file mode 100644 index 0000000..63e4788 --- /dev/null +++ b/PATENTS @@ -0,0 +1,33 @@ +Additional Grant of Patent Rights Version 2 + +"Software" means the bootstrapped software distributed by Facebook, Inc. + +Facebook, Inc. ("Facebook") hereby grants to each recipient of the Software +("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable +(subject to the termination provision below) license under any Necessary +Claims, to make, have made, use, sell, offer to sell, import, and otherwise +transfer the Software. For avoidance of doubt, no license is granted under +Facebook’s rights in any patent claims that are infringed by (i) modifications +to the Software made by you or any third party or (ii) the Software in +combination with any software or other technology. + +The license granted hereunder will terminate, automatically and without notice, +if you (or any of your subsidiaries, corporate affiliates or agents) initiate +directly or indirectly, or take a direct financial interest in, any Patent +Assertion: (i) against Facebook or any of its subsidiaries or corporate +affiliates, (ii) against any party if such Patent Assertion arises in whole or +in part from any software, technology, product or service of Facebook or any of +its subsidiaries or corporate affiliates, or (iii) against any party relating +to the Software. Notwithstanding the foregoing, if Facebook or any of its +subsidiaries or corporate affiliates files a lawsuit alleging patent +infringement against you in the first instance, and you respond by filing a +patent infringement counterclaim in that lawsuit against that party that is +unrelated to the Software, the license granted hereunder will not terminate +under section (i) of this paragraph due to such counterclaim. + +A "Necessary Claim" is a claim of a patent owned by Facebook that is +necessarily infringed by the Software standing alone. + +A "Patent Assertion" is any lawsuit or other action alleging direct, indirect, +or contributory infringement or inducement to infringe any patent, including a +cross-claim or counterclaim. diff --git a/README.md b/README.md new file mode 100644 index 0000000..d4f87c3 --- /dev/null +++ b/README.md @@ -0,0 +1,74 @@ +# bootstrapped - confidence intervals made easy + +**bootstrapped** is a Python library that allows you to build confidence intervals from data. This is useful in a variety of contexts - including during ad-hoc a/b test analysis. + +## Motivating Example - A/B Test +Imagine we own a website and think changing the color of a 'subscribe' button will improve signups. One method to measure the improvement is to conduct an A/B test where we show 50% of people the old version and 50% of the people the new version. We can use the bootstrap to understand how much the button color improves responses and give us the error bars associated with the test - this will give us lower and upper bounds on how good we should expect the change to be! + +## The Gist - Mean of a Sample +Given a sample of data - we can generate a bunch of new samples by 're-sampling' from what we have gathered. We calculate the mean for each generated sample. We can use the means from the generated samples to understand the variation in the larger population and can construct error bars for the true mean. + +## bootstrapped - Benefits + * Efficient computation of confidence intervals + * Functions to handle single populations and a/b tests + * Functions to understand [statistical power](https://en.wikipedia.org/wiki/Statistical_power) + * Multithreaded support support to speed-up bootstrap computations + * Dense and sparse array support + +## Example Usage +```python +import numpy as np +import bootstrapped.bootstrap as bs +import bootstrapped.stats_functions as bs_stats + +mean = 100 +stdev = 10 + +population = np.random.normal(loc=mean, scale=stdev, size=50000) + +# take 1k 'samples' from the larger population +samples = population[:1000] + +print(bs.bootstrap(samples, stat_func=bs_stats.mean)) +>> 100.08 (99.46, 100.69) + +print(bs.bootstrap(samples, stat_func=bs_stats.std)) +>> 9.49 (9.92, 10.36) +``` +#### Extended Examples +* [Bootstrap Intro](https://github.com/facebookincubator/bootstrapped/blob/master/examples/bootstrap_intro.ipynb) +* [Bootstrap A/B Testing](https://github.com/facebookincubator/bootstrapped/blob/master/examples/bootstrap_ab_testing.ipynb) +* More notebooks can be found in the [examples/](https://github.com/facebookincubator/bootstrapped/tree/master/examples) directory + +## Requirements +**bootstrapped** requires numpy. The power analysis functions require matplotlib and pandas. + +## Installation +```bash +# clone bootstrapped +cd bootstrapped +pip install -r requirements.txt +python setup.py install +``` + +## How bootstrapped works +**bootstrapped** provides pivotal (aka emperical) based confidence intervals based on bootstrap re-sampling with replacement. The percentile method is also available. + +For more information please see: + +1. [Bootstrap confidence intervals](https://ocw.mit.edu/courses/mathematics/18-05-introduction-to-probability-and-statistics-spring-2014/readings/MIT18_05S14_Reading24.pdf) (good intro) +2. [An introduction to Bootstrap Methods](http://www.stat-athens.aueb.gr/~karlis/lefkada/boot.pdf) +3. [The Bootstrap, Advanced Data Analysis](http://www.stat.cmu.edu/~cshalizi/402/lectures/08-bootstrap/lecture-08.pdf) +4. [When the bootstrap dosen't work](http://notstatschat.tumblr.com/post/156650638586/when-the-bootstrap-doesnt-work) +5. (book) [An Introduction to the Bootstrap](https://www.amazon.com/Introduction-Bootstrap-Monographs-Statistics-Probability/dp/0412042312/) +6. (book) [Bootstrap Methods and their Application](https://www.amazon.com/Bootstrap-Application-Statistical-Probabilistic-Mathematics-ebook/dp/B00D2WQ02U/) + +See the CONTRIBUTING file for how to help out. + +#### Contributors +Spencer Beecher, Don van der Drift, David Martin, Lindsay Vass, Sergey Goder, Benedict Lim, and Matt Langner. + +Special thanks to Eytan Bakshy. + +## License +**bootstrapped** is BSD-licensed. We also provide an additional patent grant. diff --git a/bootstrapped/__init__.py b/bootstrapped/__init__.py new file mode 100644 index 0000000..f83d651 --- /dev/null +++ b/bootstrapped/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. diff --git a/bootstrapped/bootstrap.py b/bootstrapped/bootstrap.py new file mode 100644 index 0000000..25cecdc --- /dev/null +++ b/bootstrapped/bootstrap.py @@ -0,0 +1,403 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. +'''Functions that allow one to create bootstrapped confidence intervals''' +from __future__ import print_function +from __future__ import absolute_import +from __future__ import division +from __future__ import unicode_literals + +import numpy as _np +import multiprocessing as _multiprocessing +import scipy.sparse as _sparse + + +class BootstrapResults(object): + def __init__(self, lower_bound, value, upper_bound): + self.lower_bound = lower_bound + self.upper_bound = upper_bound + self.value = value + + def __str__(self): + return '{1} ({0}, {2})'.format(self.lower_bound, self.value, + self.upper_bound) + + def __repr__(self): + return self.__str__() + + def _apply(self, other, func): + return BootstrapResults(func(self.lower_bound, other), + func(self.value, other), + func(self.upper_bound, other)) + + def __add__(self, other): + return self._apply(float(other), lambda x, other: other + x) + + def __radd__(self, other): + return self._apply(float(other), lambda x, other: other + x) + + def __sub__(self, other): + return self._apply(float(other), lambda x, other: x - other) + + def __rsub__(self, other): + return self._apply(float(other), lambda x, other: other - x) + + def __mul__(self, other): + return self._apply(float(other), lambda x, other: x * other) + + def __rmul__(self, other): + return self._apply(float(other), lambda x, other: x * other) + + +def _get_confidence_interval(bootstrap_dist, stat_val, alpha, is_pivotal): + '''Get the bootstrap confidence interval for a given distribution. + Args: + bootstrap_distribution: numpy array of bootstrap results from + bootstrap_distribution() or bootstrap_ab_distribution() + stat_val: The overall statistic that this method is attempting to + calculate error bars for. + alpha: The alpha value for the confidence intervals. + is_pivotal: if true, use the pivotal method. if false, use the + percentile method. + ''' + if is_pivotal: + low = 2 * stat_val - _np.percentile(bootstrap_dist, 100 * (1 - alpha / 2.)) + val = stat_val + high = 2 * stat_val - _np.percentile(bootstrap_dist, 100 * (alpha / 2.)) + else: + low = _np.percentile(bootstrap_dist, 100 * (alpha / 2.)) + val = _np.percentile(bootstrap_dist, 50) + high = _np.percentile(bootstrap_dist, 100 * (1 - alpha / 2.)) + + return BootstrapResults(low, val, high) + + +def _generate_distributions(values, num_iterations): + if values is None: + return None + if isinstance(values, _sparse.csr_matrix): + # in the sparse case we dont actually need to bootstrap + # the full sparse array since most values are 0 + # instead for each bootstrap iteration we: + # 1. generate B number of non-zero entries to sample from the + # binomial distribution + # 2. resample with replacement the non-zero entries from values + # B times + # 3. create a new sparse array with the B resamples, zero otherwise + data = values.data + + results = [] + + pop_size = values.shape[1] + non_sparse_size = data.shape[0] + + p = non_sparse_size * 1.0 / pop_size + + for _ in range(num_iterations): + ids = _np.random.choice( + non_sparse_size, + _np.random.binomial(pop_size, p), + replace=True, + ) + + d = _sparse.csr_matrix( + ( + data[ids], + (_np.zeros_like(ids), _np.arange(len(ids))) + ), + shape=(1, pop_size), + ) + + results.append(d) + return _sparse.vstack(results) + elif isinstance(values, _sparse.spmatrix): + raise ValueError(('The only supported sparse matrix type is ' + 'scipy.sparse.csr_matrix')) + + else: + ids = _np.random.choice( + values.shape[0], + (num_iterations, values.shape[0]), + replace=True, + ) + return values[ids] + + +def _compute_stat(num, denom, stat_func): + result = stat_func(num) + if denom is not None: + result /= stat_func(denom) + return result + + +def _bootstrap_sim(values, stat_func, denominator_values, num_iterations, + iteration_batch_size): + '''Returns simulated bootstrap distribution. + See bootstrap() funciton for arg descriptions. + ''' + + num_iterations = int(num_iterations) + iteration_batch_size = int(iteration_batch_size) + + results = [] + + for rng in range(0, num_iterations, iteration_batch_size): + max_rng = min(iteration_batch_size, num_iterations - rng) + + v = _generate_distributions(values, max_rng) + d_v = _generate_distributions(denominator_values, max_rng) + + stat = _compute_stat(v, d_v, stat_func) + + results.extend(stat) + + return _np.array(results) + + +def _bootstrap_distribution(values, stat_func, denominator_values, + num_iterations, iteration_batch_size, num_threads): + '''Returns the simulated bootstrap distribution computed in (optinally) + @num_threads threads. See bootstrap() for arg descriptions. + + Returns: + A numpy array of bootstrap simulations. + ''' + if iteration_batch_size is None: + iteration_batch_size = num_iterations + + num_iterations = int(num_iterations) + iteration_batch_size = int(iteration_batch_size) + + num_threads = int(num_threads) + + if num_threads == -1: + num_threads = _multiprocessing.cpu_count() + + if num_threads <= 1: + results = _bootstrap_sim(values, stat_func, denominator_values, + num_iterations, iteration_batch_size) + else: + pool = _multiprocessing.Pool(num_threads) + + iter_per_job = _np.ceil(num_iterations * 1.0 / num_threads) + + results = [] + for _ in range(num_threads): + r = pool.apply_async(_bootstrap_sim, (values, stat_func, + denominator_values, iter_per_job, + iteration_batch_size)) + results.append(r) + + results = _np.hstack([res.get() for res in results]) + + return results + + +def bootstrap(values, stat_func, denominator_values=None, alpha=0.05, + num_iterations=10000, iteration_batch_size=None, + is_pivotal=True, num_threads=1): + '''Returns bootstrap estimate. + Args: + values: numpy array (or scipy.sparse.csr_matrix) of values to bootstrap + stat_func: statistic to bootstrap. We provide several default functions: + * stat_functions.mean + * stat_functions.sum + * stat_functions.std + denominator_values: optional array that does division after the + statistic is aggregated. This lets you compute group level division + statistics. One corresponding entry per record in @values. + Example: + SUM(value) / SUM(denom) instead of MEAN(value / denom) + + Ex. Cost Per Click + cost per click across a group + SUM(revenue) / SUM(clicks) + mean cost per click for each + MEAN(revenue / clicks) + alpha: alpha value representing the confidence interval. + Defaults to 0.05, i.e., 95th-CI. + num_iterations: number of bootstrap iterations to run. The higher this + number the more sure you can be about the stability your bootstrap. + By this - we mean the returned interval should be consistent across + runs for the same input. This also consumes more memory and makes + analysis slower. Defaults to 10000. + iteration_batch_size: The bootstrap sample can generate very large + matrices. This argument limits the memory footprint by + batching bootstrap rounds. If unspecified the underlying code + will produce a matrix of len(values) x num_iterations. If specified + the code will produce sets of len(values) x iteration_batch_size + (one at a time) until num_iterations have been simulated. + Defaults to no batching. + is_pivotal: if true, use the pivotal method for bootstrapping confidence + intervals. If false, use the percentile method. + num_threads: The number of therads to use. This speeds up calculation of + the bootstrap. Defaults to 1. If -1 is specified then + multiprocessing.cpu_count() is used instead. + Returns: + BootstrapResults representing CI and estimated value. + ''' + results = _bootstrap_distribution(values, stat_func, denominator_values, + num_iterations, iteration_batch_size, + num_threads) + value = _compute_stat( + values, + denominator_values, + stat_func + )[0] + + return _get_confidence_interval(results, value, alpha, is_pivotal) + + +def _bootstrap_ab_sim(test, ctrl, stat_func, compare_func, test_denominator, + ctrl_denominator, num_iterations, iteration_batch_size, + scale_test_by): + '''Returns simulated bootstrap distribution for an a/b test. + See bootstrap_ab() funciton for arg descriptions. + ''' + results = [] + + num_iterations = int(num_iterations) + iteration_batch_size = int(iteration_batch_size) + + for rng in range(0, num_iterations, iteration_batch_size): + max_rng = min(rng + iteration_batch_size, num_iterations) - rng + + t_v = _generate_distributions(test, max_rng) + t_d_v = _generate_distributions(test_denominator, max_rng) + + c_v = _generate_distributions(ctrl, max_rng) + c_d_v = _generate_distributions(ctrl_denominator, max_rng) + + test_stat = _compute_stat(t_v, t_d_v, stat_func) + ctrl_stat = _compute_stat(c_v, c_d_v, stat_func) + + stat = compare_func(test_stat * scale_test_by, ctrl_stat) + + results.extend(stat) + + return _np.array(results) + + +def _bootstrap_ab_distribution(test, ctrl, stat_func, compare_func, + test_denominator, ctrl_denominator, + num_iterations, iteration_batch_size, + scale_test_by, num_threads): + '''Returns the simulated bootstrap distribution computed in (optinally) + @num_threads threads. See bootstrap_ab() funciton for arg descriptions. + + Returns: + A numpy array of bootstrap a/b test simulations. + ''' + # both test_denominator and ctrl_denominator must be specified at the same + # time. + if (test_denominator is not None) ^ (ctrl_denominator is not None): + raise ValueError(('test_denominator and ctrl_denominator must both ' + 'be specified')) + + if iteration_batch_size is None: + iteration_batch_size = num_iterations + + num_threads = int(num_threads) + + if num_threads == -1: + num_threads = _multiprocessing.cpu_count() + + if num_threads <= 1: + results = _bootstrap_ab_sim(test, ctrl, stat_func, compare_func, + test_denominator, ctrl_denominator, + num_iterations, iteration_batch_size, + scale_test_by) + else: + pool = _multiprocessing.Pool(num_threads) + + iter_per_job = _np.ceil(num_iterations * 1.0 / num_threads) + + results = [] + for _ in range(num_threads): + r = pool.apply_async(_bootstrap_ab_sim, (test, ctrl, stat_func, + compare_func, test_denominator, + ctrl_denominator, iter_per_job, + iteration_batch_size, scale_test_by)) + results.append(r) + + results = _np.hstack([res.get() for res in results]) + + return results + + +def bootstrap_ab(test, ctrl, stat_func, compare_func, test_denominator=None, + ctrl_denominator=None, alpha=0.05, num_iterations=10000, + iteration_batch_size=None, scale_test_by=1.0, + is_pivotal=True, num_threads=1): + '''Returns bootstrap confidence intervals for an A/B test. + + Args: + test: numpy array (or scipy.sparse.csr_matrix) of test results + ctrl: numpy array (or scipy.sparse.csr_matrix) of ctrl results + stat_func: statistic to bootstrap. We provide several default functions: + * stat_functions.mean + * stat_functions.sum + * stat_functions.std + compare_func: Function to compare test and control against. + * compare_functions.difference + * compare_functions.percent_change + * compare_functions.ratio + * compare_functions.percent_difference + test_denominator: optional array that does division after the statistic + is aggregated. This lets you compute group level division + statistics. One corresponding entry per record in test. + Example: + SUM(value) / SUM(denom) instead of MEAN(value / denom) + + Ex. Cost Per Click + cost per click across a group (clicks is denominator) + SUM(revenue) / SUM(clicks) + mean cost per click for each record + MEAN(revenue / clicks) + ctrl_denominator: see test_denominator. + alpha: alpha value representing the confidence interval. + Defaults to 0.05, i.e., 95th-CI. + num_iterations: number of bootstrap iterations to run. The higher this + number the more sure you can be about the stability your bootstrap. + By this - we mean the returned interval should be consistent across + runs for the same input. This also consumes more memory and makes + analysis slower. + iteration_batch_size: The bootstrap sample can generate very large + arrays. This function iteration_batch_size limits the memory + footprint by batching bootstrap rounds. + scale_test_by: The ratio between test and control population + sizes. Use this if your test and control split is different from a + 50/50 split. Defaults to 1.0. + is_pivotal: if true, use the pivotal method for bootstrapping confidence + intervals. If false, use the percentile method. + num_threads: The number of therads to use. This speeds up calculation of + the bootstrap. Defaults to 1. If -1 is specified then + multiprocessing.cpu_count() is used instead. + Returns: + BootstrapResults representing CI and estimated value. + ''' + # both test_denominator and ctrl_denominator must be specified at the same + # time. + + results = _bootstrap_ab_distribution(test, ctrl, stat_func, compare_func, + test_denominator, ctrl_denominator, + num_iterations, iteration_batch_size, + scale_test_by, num_threads) + + t = _compute_stat( + test, + test_denominator, + stat_func, + )[0] + + c = _compute_stat( + ctrl, + ctrl_denominator, + stat_func, + )[0] + + value = compare_func(t * scale_test_by, c) + return _get_confidence_interval(results, value, alpha, is_pivotal) diff --git a/bootstrapped/compare_functions.py b/bootstrapped/compare_functions.py new file mode 100644 index 0000000..6593a12 --- /dev/null +++ b/bootstrapped/compare_functions.py @@ -0,0 +1,56 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. +'''Various comparison functions for use in bootstrap a/b tests''' +from __future__ import print_function +from __future__ import absolute_import +from __future__ import division +from __future__ import unicode_literals + + +def difference(test_stat, ctrl_stat): + """Calculates difference change. A good default. + Args: + test_stat: numpy array of test statistics + ctrl_stat: numpy array of control statistics + Returns: + test_stat - ctrl_stat + """ + return (test_stat - ctrl_stat) + + +def percent_change(test_stat, ctrl_stat): + """Calculates percent change. + Args: + test_stat: numpy array of test statistics + ctrl_stat: numpy array of control statistics + Returns: + (test_stat - ctrl_stat) / ctrl_stat * 100 + """ + return (test_stat - ctrl_stat) * 100.0 / ctrl_stat + + +def ratio(test_stat, ctrl_stat): + """Calculates ratio between test and control + Args: + test_stat: numpy array of test statistics + ctrl_stat: numpy array of control statistics + Returns: + test_stat / ctrl_stat + """ + return test_stat / ctrl_stat + + +def percent_difference(test_stat, ctrl_stat): + """Calculates ratio between test and control. Useful when your statistics + might be close to zero. Provides a symmetric result. + Args: + test_stat: numpy array of test statistics + ctrl_stat: numpy array of control statistics + Returns: + (test_stat - ctrl_stat) / ((test_stat + ctrl_stat) / 2.0) * 100.0 + """ + return (test_stat - ctrl_stat) / ((test_stat + ctrl_stat) / 2.0) * 100.0 diff --git a/bootstrapped/power.py b/bootstrapped/power.py new file mode 100644 index 0000000..6ce1e3e --- /dev/null +++ b/bootstrapped/power.py @@ -0,0 +1,143 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. +'Functions that allow one to perform power analysis' +from __future__ import print_function +from __future__ import absolute_import +from __future__ import division +from __future__ import unicode_literals +import pandas as _pd +import numpy as _np +import warnings as _warnings + + +def _get_power_df(bootstrap_result_list): + '''Returns a dataframe with importat statistics for power analysis + + Args: + bootstrap_result_list: list of BootstrapResults + + Example: + + results = [] + # should really be 600 -> 1k + for i in range(100): + test = numpy.random.normal(loc=100, scale=100, size=500) * 1.05 + ctrl = numpy.random.normal(loc=100, scale=10, size=500) + + results.append(bootstrap.percent_difference(test, ctrl)) + + + power_df = bootstrap.get_power_df(results) + ''' + if len(bootstrap_result_list) < 3000: + _warnings.warn(('bootstrap_result_list has very few examples. ' + 'A general heuristic is to have at least 3k values. ' + 'The more examples the more confident you can be in ' + 'the power')) + + df = _pd.DataFrame.from_dict([x.__dict__ for x in bootstrap_result_list]) + + df = df.sort('value').reset_index().dropna() + + is_sig = df['upper_bound'].apply(_np.sign) + is_sig = is_sig == df['lower_bound'].apply(_np.sign) + df['is_significant'] = is_sig + + df['test_result'] = df['upper_bound'].apply(_np.sign).astype(int) \ + * df['is_significant'].apply(lambda x: 1 if x else 0) + + result_cols = [ + 'negative_significant', + 'insignificant', + 'positive_significant', + ] + df['test_result'] = df['test_result'].apply(lambda x: result_cols[x + 1]) + + df['lower_bound_relative'] = df['value'] - df['lower_bound'] + df['upper_bound_relative'] = df['upper_bound'] - df['value'] + + df['x_val'] = _np.arange(len(df)) + + return df + + +def power_stats(bootstrap_result_list): + '''Returns summary statistics about a power_df + Args: + power_df: get_power_df([BootstrapResult, ...]) + Returns: + A dataframe with summary statistics about the power of the simulation. + ''' + power_df = _get_power_df(bootstrap_result_list) + pcnt_results = power_df.test_result.value_counts() * 100 / len(power_df) + + sd = { + 'Positive': [(power_df.value > 0).mean() * 100], + 'Negative': [(power_df.value < 0).mean() * 100], + 'Insignificant': [pcnt_results.get('insignificant', 0)], + 'Positive Significant': [pcnt_results.get('positive_significant', 0)], + 'Negative Significant': [pcnt_results.get('negative_significant', 0)], + } + stats = _pd.DataFrame(sd).transpose() + stats.columns = ['Percent'] + return stats + + +def plot_power(bootstrap_result_list, insignificant_color='blue', + significant_color='orange', trend_color='black', + zero_color='black'): + ''' + Args: + power_df: get_power_df([BootstrapResult, ...]) + + Example: + + results = [] + # should really be 600 -> 1k + for i in range(100): + test = numpy.random.normal(loc=100, scale=100, size=500) * 1.05 + ctrl = numpy.random.normal(loc=100, scale=10, size=500) + + results.append(bootstrap.percent_difference(test, ctrl)) + + power_df = bootstrap.get_power_df(results) + + bootstrap.power_stats(power_df) + bootstrap.plot_power(power_df) + ''' + import matplotlib.pyplot as plt + + power_df = _get_power_df(bootstrap_result_list) + sel = ~power_df['is_significant'] + + plt.axhline(0, c=zero_color) + + plt.plot(power_df.x_val, power_df.value, c=trend_color) + + plt.errorbar( + power_df[sel]['x_val'], + power_df[sel]['value'], + yerr=( + power_df[sel]['lower_bound_relative'], + power_df[sel]['upper_bound_relative'], + ), + c=insignificant_color, + linestyle=' ', + ) + + plt.errorbar( + power_df[~sel]['x_val'], + power_df[~sel]['value'], + yerr=( + power_df[~sel]['lower_bound_relative'], + power_df[~sel]['upper_bound_relative'], + ), + c=significant_color, + linestyle=' ', + ) + + plt.xlim(0, len(power_df)) diff --git a/bootstrapped/stats_functions.py b/bootstrapped/stats_functions.py new file mode 100644 index 0000000..c6c47a6 --- /dev/null +++ b/bootstrapped/stats_functions.py @@ -0,0 +1,38 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. +'''Various comparison statistics functions to run on bootstrap simulations''' +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals +import numpy as _np +import scipy.sparse as _sparse + + +def mean(values, axis=1): + '''Returns the mean of each row of a matrix''' + if isinstance(values, _sparse.csr_matrix): + ret = values.mean(axis=axis) + return ret.A1 + else: + return _np.mean(_np.asmatrix(values), axis=axis).A1 + +def sum(values, axis=1): + '''Returns the sum of each row of a matrix''' + if isinstance(values, _sparse.csr_matrix): + ret = values.sum(axis=axis) + return ret.A1 + else: + return _np.sum(_np.asmatrix(values), axis=axis).A1 + +def std(values, axis=1): + '''Returns the std of each row of a matrix''' + if isinstance(values, _sparse.csr_matrix): + ret = values.std(axis=axis) + return ret.A1 + else: + return _np.std(_np.asmatrix(values), axis=axis).A1 diff --git a/examples/advanced_bootstrap_features.ipynb b/examples/advanced_bootstrap_features.ipynb new file mode 100644 index 0000000..b3fe6b0 --- /dev/null +++ b/examples/advanced_bootstrap_features.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": { + "collapsed": true + }, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + " \n", + "All rights reserved.\n", + " \n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Advanced Bootstrap Features\n", + "In this example we will cover:\n", + "* Bootstrapping with custom aggregation functions\n", + "* Bootstrapping Ratios \n", + " * Bootstrap( SUM(numerator) / SUM(denominator) )\n", + " * Bootstrap( AVG(numerator / denominator) )\n", + "\n", + "**Note:** Here we will demonstrate bs.bootstrap of this same functionality is available with bootstrap_ab" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.compare_functions as bs_compare\n", + "import bootstrapped.stats_functions as bs_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame()\n", + "df['revenue'] = np.random.normal(loc=100, scale=90, size=1000000)\n", + "df['revenue'] = df['revenue'].apply(lambda x: x if x > 0 else 1)\n", + "\n", + "df['clicks'] = np.random.binomial(100, 0.15, 1000000) \n", + "\n", + "sample_df = df[:5000]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "106.213747717\n", + "104.728860445 (102.489200685, 106.965327721)\n" + ] + } + ], + "source": [ + "# Calculate the estimate of revenue per record \n", + "print(df.revenue.mean())\n", + "\n", + "print(bs.bootstrap(values=sample_df.revenue.values, stat_func=bs_stats.mean))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bootstraps with custom functions\n", + "Lets demonstrate a simple eample of how to calculate the bootstrapped mean in a custom function. Should give similar results to the above function calls." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "length of the array 5000\n", + "function input shape (12345, 5000)\n", + "function output shape (12345,) == num bootstrap iterations\n", + "\n", + "104.728860445 (102.493065757, 106.939565776)\n" + ] + } + ], + "source": [ + "def custom_mean(values, axis=1):\n", + " '''Calculate the mean of values for each bootstrap sample\n", + " Args:\n", + " values: a np.array of values we want to calculate the statistic on\n", + " This is actually a 2d array (matrix) of values. Each row represents \n", + " a bootstrap resample simulation that we wish to aggretage across.\n", + " '''\n", + " \n", + " \n", + " mean_values = values.mean(axis=axis)\n", + "\n", + " if values.shape[0] != 1:\n", + " # this function gets called 2x\n", + " # once for the bootstrap and once to calculate the bootstrap statistics\n", + " \n", + " # once to calculate the statistic on the whole population (non bootstrap)\n", + " # filter out this case\n", + " \n", + " # 12345 bootstrap resample simulations\n", + " print('function input shape {}'.format(values.shape))\n", + " print('function output shape {} == num bootstrap iterations'.format(mean_values.shape))\n", + "\n", + " \n", + " return mean_values\n", + "\n", + "print('length of the array %d' % len(sample_df.revenue.values))\n", + "\n", + "results = bs.bootstrap(sample_df.revenue.values, stat_func=custom_mean, num_iterations=12345)\n", + "print('')\n", + "print(results)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "104.728860445 (102.53926148, 106.946964017)\n" + ] + } + ], + "source": [ + "# alternatively we could write our function to aggregate across rows and ignore the axis\n", + "# this is much slower\n", + "\n", + "def alternate_mean(values):\n", + " # note this way of doing things is often slower, but not always\n", + " return np.array([np.mean(v) for v in values])\n", + " \n", + "print(bs.bootstrap(sample_df.revenue.values, alternate_mean))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bootstraps with 'advanced' functions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "244.503848258 (238.451110157, 248.242912801)\n" + ] + } + ], + "source": [ + "def percentile_range(values):\n", + " '''Calculate a percentile range of values\n", + " Args:\n", + " values: a np.array of values we want to calculate the statistic on\n", + " This is actually a 2d array (matrix) of values. Each row represents \n", + " a bootstrap resample simulation that we wish to aggretage across.\n", + " '''\n", + " p95 = np.percentile(values, 95, axis=1)\n", + " p5 = np.percentile(values, 5, axis=1) \n", + " return p95 - p5\n", + " \n", + "\n", + "print(bs.bootstrap(sample_df.revenue.values, percentile_range))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Denominator Values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you would like to bootstrap the global Clicks Per Dollar reduction you need a function that does:\n", + "\n", + "**Bootstrap(SUM(Clicks) / SUM(Revenue))**\n", + "\n", + "and not \n", + "\n", + "**Mean(Bootstrap(Clicks/Revenue))**\n", + "\n", + "The first gives you the global reduction. In this case you want to sample a whole record according to an event (revenue, click) and then calculate from that. In this case this is achievable by the following code (in addition to more complex functions). " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7671678731\n", + "2.53236955294 (2.3676668297, 2.69316687436)\n" + ] + } + ], + "source": [ + "print((df.clicks / df.revenue).mean())\n", + "\n", + "print(bs.bootstrap(\n", + " sample_df.clicks.values / sample_df.revenue.values,\n", + " bs_stats.mean\n", + "))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.141187909497\n", + "0.143295744231 (0.140071246128, 0.146471415045)\n" + ] + } + ], + "source": [ + "print(df.clicks.sum() / df.revenue.sum())\n", + "\n", + "print(bs.bootstrap(\n", + " sample_df.clicks.values,\n", + " bs_stats.mean,\n", + " denominator_values=sample_df.revenue.values\n", + "))" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/bootstrap_ab_testing.ipynb b/examples/bootstrap_ab_testing.ipynb new file mode 100644 index 0000000..67d9e39 --- /dev/null +++ b/examples/bootstrap_ab_testing.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bootstrap Intro" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.compare_functions as bs_compare\n", + "import bootstrapped.stats_functions as bs_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bootstrap Examples\n", + "Bootstrap at a high level:\n", + "The bootstrap lets you resample a numeric series to (typically) estimate confidence intervals.\n", + "\n", + "[More info on the bootstrap](https://ocw.mit.edu/courses/mathematics/18-05-introduction-to-probability-and-statistics-spring-2014/readings/MIT18_05S14_Reading24.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# little a/b test\n", + "# score in test are 10% greater than ctrl (per record)\n", + "# ctrl has 5x the number of records as test\n", + "\n", + "# 10% lift in test\n", + "lift = 1.1\n", + "test = np.random.binomial(100, p=0.2 * lift, size=10000) * 1.0\n", + "ctrl = np.random.binomial(100, p=0.2, size=50000) * 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGBCAYAAABvrRvrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n0BEREZHC+v+DqKFY80QTMAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.linspace(0, 40, 20)\n", + "\n", + "plt.hist(ctrl, bins=bins, label='Control')\n", + "plt.hist(test, bins=bins, label='Test', color='orange')\n", + "plt.title('Test/Ctrl Data')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.73534158795\n", + "9.73534158795 (9.28309336123, 10.1890345815)\n" + ] + } + ], + "source": [ + "# run an a/b test simulation ignoring the lengths of the series (average)\n", + "# just what is the 'typical' value\n", + "# use percent change to compare test and control\n", + "\n", + "print(bs_compare.percent_change(test.mean(), ctrl.mean()))\n", + "\n", + "print(bs.bootstrap_ab(test, ctrl, bs_stats.mean, bs_compare.percent_change))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10000\n", + "50000\n" + ] + } + ], + "source": [ + "print(len(test))\n", + "print(len(ctrl))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-78.0529316824\n", + "-78.0529316824 (-78.1433332594, -77.9641983621)\n" + ] + } + ], + "source": [ + "# run an a/b test simulation considering the lengths of the series (sum)\n", + "# consider the full 'volume' of values that are passed in\n", + "\n", + "print(bs_compare.percent_change(test.sum(), ctrl.sum()))\n", + "\n", + "print(bs.bootstrap_ab(\n", + " test, \n", + " ctrl, \n", + " stat_func=bs_stats.sum,\n", + " compare_func=bs_compare.percent_change\n", + "))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Advice:** For most situations we reccomend that we use 'sum' aggregate function as this will take the size of the population into account. This can be useful if you think your test will increase the total number of individuals in the population and not only the typical value per individual. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exception to the above advice**\n", + "\n", + "\n", + "There are situations where you might need to make some adjustments, for example if your holdouts are sized differently.\n", + "\n", + " * You give 100 dollars to **person_A** and you give 1000 dollars to **person_B** to bring people to your store\n", + " * Say you don't know how many people person_A or person_B went after but they did each get paying customers to attend\n", + " * However you do need to correct at the end for the fact that you gave person_B 10x more money than person_A" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Gave $100, got 1k events on the store, $20 per event \n", + "person_A_results = np.random.binomial(100, p=0.2, size=1000) * 1.0\n", + "\n", + "# Gave $1000, got 5k events on the store, $30 per event\n", + "person_B_results = np.random.binomial(100, p=0.3, size=5000) * 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-129893.0 (-130569.025, -129228.0)\n" + ] + } + ], + "source": [ + "# The test earned much less in terms of total dollars\n", + "print(bs.bootstrap_ab(\n", + " person_A_results, \n", + " person_B_results, \n", + " stat_func=bs_stats.sum,\n", + " compare_func=bs_compare.difference,\n", + "))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9.8474 (-10.1362, -9.56539)\n" + ] + } + ], + "source": [ + "# The test gives ~$10 less per event\n", + "print(bs.bootstrap_ab(\n", + " person_A_results, \n", + " person_B_results, \n", + " stat_func=bs_stats.mean,\n", + " compare_func=bs_compare.difference,\n", + "))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "51583.0 (48922.0, 54195.0)\n" + ] + } + ], + "source": [ + "# If we scale the text by $$ spent - person_A should be a better return on investment\n", + "# - assuming person_A can achieve similar results with 10x more money\n", + "print(bs.bootstrap_ab(\n", + " person_A_results, \n", + " person_B_results, \n", + " stat_func=bs_stats.sum,\n", + " compare_func=bs_compare.difference,\n", + " scale_test_by=10.,\n", + "))" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/bootstrap_failure.ipynb b/examples/bootstrap_failure.ipynb new file mode 100644 index 0000000..a62744e --- /dev/null +++ b/examples/bootstrap_failure.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example of when Bootstrapping can go wrong\n", + "\n", + "In this example we will create a a situation where the bootstrap is not going to work so well. \n", + "\n", + "For a more thurough explanation please see this external reference on [When the bootstrap dosen't work](http://notstatschat.tumblr.com/post/156650638586/when-the-bootstrap-doesnt-work)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import numpy.random as npr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.stats_functions as bs_stats\n", + "import bootstrapped.power as bs_power" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visual Intuition\n", + "The bootstrap is based on a sample of your larger population. A sample is only as good as how representitave it is. If you happen to be unlucky in your sample then you are going to make some very bad inferences. \n", + "\n", + "One way to improve the representitiveness of our sample is to boost the number of samples we take. Lets see this visually." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAloAAAGBCAYAAAC+Sh+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "population = np.random.exponential(scale=1000, size=500000)\n", + "\n", + "# Plot the population\n", + "count, bins, ignored = plt.hist(population, 30, normed=True)\n", + "\n", + "plt.title('Distribution of the population')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "population = pd.Series(population)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def plot_sample_means(population, num_samples):\n", + "\n", + " sample_means = []\n", + " for i in range(100):\n", + " sample = population.sample(num_samples, replace=True)\n", + " sample_means.append(sample.mean())\n", + "\n", + " pd.Series(sample_means).plot()\n", + " print('Standard Deviation %f' % pd.Series(sample_means).std())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation 108.035411\n" + ] + }, + { + "data": { + "text/plain": [ + "(700, 1300)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_sample_means(population, 100)\n", + "plt.ylim(700, 1300)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation 29.979785\n" + ] + }, + { + "data": { + "text/plain": [ + "(700, 1300)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiIiIln8fz0j+2TH9Lz1AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_sample_means(population, 1000)\n", + "plt.ylim(700, 1300)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation 9.383124\n" + ] + }, + { + "data": { + "text/plain": [ + "(700, 1300)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pretty representative\n", + "plot_sample_means(population, 10000)\n", + "plt.ylim(700, 1300)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Wow!** So we can visually see how our estimate of the mean gets more stable the more samples we take." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The worst.\n", + "\n", + "\n", + "Now that you have a sense for how sample size impacts error in estimating the mean - lets create a scenario that is even more extreme.\n", + "\n", + "Above we looked at an exponential distribution which can generate some rare extreme outliers (which hurt our estimation ability).\n", + "\n", + "Lets create a poulation where things are even more extreme." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "bad_population = pd.Series([1]*10000 + [100000])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAGBCAYAAADbp+3kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the population\n", + "count, bins, ignored = plt.hist(bad_population, 30, normed=True)\n", + "\n", + "plt.title('Distribution of the population')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation 35.618275\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAFxCAYAAAArqzGRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nERGRyhRQiIiISGUKKERERKSy/x++ZLOojiny2wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# uh oh... \n", + "plot_sample_means(bad_population, 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.99890011\n", + "1.0 (1.0, 1.0)\n" + ] + } + ], + "source": [ + "# Yikes! Our bootstrap interval is very tight but it is also completley off!\n", + "# This is a 'worst case' scenario for doing the bootstrap\n", + "# It looks like we happened to take a sample where there was no extreme value\n", + "samples = bad_population.sample(1000)\n", + "\n", + "print(bad_population.mean())\n", + "print(bs.bootstrap(samples.values, stat_func=bs_stats.mean, is_pivotal=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.99890011\n", + "10.9999 (1.0, 30.9997)\n" + ] + } + ], + "source": [ + "# Here we incresed the sample count and got lucky (sampled that single extreme value)\n", + "# Note that the error bars on the bootstrap are very wide\n", + "samples = bad_population.sample(10000)\n", + "\n", + "print(bad_population.mean())\n", + "print(bs.bootstrap(samples.values, stat_func=bs_stats.mean, is_pivotal=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Just how often can we expect our error bars to not reflect the true mean?\n", + "\n", + "See the [Power Calculation](https://github.com/facebookincubator/bootstrapped/blob/master/examples/power_calculation.ipynb) example for more information on power." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "num_samples = 1000\n", + "results = []\n", + "\n", + "bad_population_mean = bad_population.mean()\n", + "\n", + "for _ in range(1000):\n", + " samples = bad_population.sample(num_samples)\n", + " result = bs.bootstrap(samples.values, stat_func=bs_stats.mean)\n", + " \n", + " # we want to 0 center this for our power plotting below\n", + " result = result - bad_population_mean\n", + " \n", + " results.append(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Percent
Insignificant10.500
Negative89.500
Negative Significant89.500
Positive10.500
Positive Significant0.000
\n", + "
" + ], + "text/plain": [ + " Percent\n", + "Insignificant 10.500\n", + "Negative 89.500\n", + "Negative Significant 89.500\n", + "Positive 10.500\n", + "Positive Significant 0.000" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Ideally the sample should have no significant difference from the mean. \n", + "# This would mean that the bootstrap errorbars overlap the true mean.\n", + "\n", + "# We see here that only 10% of the time we should expect our error bars NOT contain the mean\n", + "# This is bad! 90% of the time our confidence interval wont cover the true mean!\n", + "bs_power.power_stats(results)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# lets try the above with 10k instead of 1k samples\n", + "num_samples = 10000\n", + "larger_results = []\n", + "\n", + "bad_population_mean = bad_population.mean()\n", + "\n", + "for _ in range(1000):\n", + " samples = bad_population.sample(num_samples)\n", + " result = bs.bootstrap(samples.values, stat_func=bs_stats.mean)\n", + " \n", + " # we want to 0 center this for our power plotting below\n", + " result = result - bad_population_mean\n", + " \n", + " larger_results.append(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Percent
Insignificant100.000
Negative0.000
Negative Significant0.000
Positive100.000
Positive Significant0.000
\n", + "
" + ], + "text/plain": [ + " Percent\n", + "Insignificant 100.000\n", + "Negative 0.000\n", + "Negative Significant 0.000\n", + "Positive 100.000\n", + "Positive Significant 0.000" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# With a larger sample we find the sample's error bars overlap the true mean, this is better\n", + "bs_power.power_stats(larger_results)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/bootstrap_intro.ipynb b/examples/bootstrap_intro.ipynb new file mode 100644 index 0000000..cdc1d1f --- /dev/null +++ b/examples/bootstrap_intro.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simple Bootstrap Example\n", + "\n", + "In this example we will create a normal distribution and take a smaller sample. From the sample, we show how to estimate the true mean and standard deviation of the larger population." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import numpy.random as npr\n", + "\n", + "import collections" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAGBCAYAAACq34F6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean = 100\n", + "stdev = 10\n", + "\n", + "population = np.random.normal(loc=mean, scale=stdev, size=50000)\n", + "\n", + "# Plot the population\n", + "count, bins, ignored = plt.hist(population, 30, normed=True)\n", + "\n", + "plt.title('Distribution of the population')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.compare_functions as bs_compare\n", + "import bootstrapped.stats_functions as bs_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# take 1k 'samples' from the larger population\n", + "samples = population[:1000]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 9.8886535])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std([samples], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# calculate bootstrap estimates for the mean and standard deviation\n", + "mean_results = bs.bootstrap(samples, stat_func=bs_stats.mean)\n", + "\n", + "# see advanced_bootstrap_features.ipynb for a discussion of how to use the stat_func arg\n", + "stdev_results = bs.bootstrap(samples, stat_func=lambda x: np.std(x, axis=1))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bootstrapped mean should be: 100\n", + "\t100.132773078 (99.5161227872, 100.750887763)\n", + "\n", + "Bootstrapped stdev should be: 10\n", + "\t9.88865349729 (9.47842431323, 10.31394789)\n" + ] + } + ], + "source": [ + "print('Bootstrapped mean should be: {}'.format(mean))\n", + "print('\\t' + str(mean_results))\n", + "print('')\n", + "print('Bootstrapped stdev should be: {}'.format(stdev))\n", + "print('\\t' + str(stdev_results))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis\n", + "We found the mean and standard deviation we estimated are close to the true values. The bootstrap function also gives us error bars associated with the estimate." + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/large_data.ipynb b/examples/large_data.ipynb new file mode 100644 index 0000000..b877ca8 --- /dev/null +++ b/examples/large_data.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": { + "collapsed": true + }, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Large Data\n", + "\n", + "The bootstrapped library also provides functionality to deal with large-ish datasets. There are two situations where large data may pose issues. By large, we mean that it still fits reasnably in memory but is large enough that the bootstrap methods take considerable time to execute.\n", + "1. Memory\n", + "2. Time\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.compare_functions as bs_compare\n", + "import bootstrapped.stats_functions as bs_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "test = np.random.normal(loc=100, scale=100, size=1000000) * 1.1\n", + "ctrl = np.random.normal(loc=100, scale=100, size=1000000) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Memory\n", + "Use 'iteration_batch_size' argument. This will help with the memory footprint at the cost of some speed." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There was a memory error - too much memory to be allocated\n" + ] + } + ], + "source": [ + "# this will probably fail unless you have a LOT of memory\n", + "try:\n", + " print(bs.bootstrap_ab(test, ctrl, bs_stats.sum, bs_compare.percent_change))\n", + "except MemoryError as e:\n", + " print('There was a memory error - too much memory to be allocated')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results 10.0181745751 (9.71428395746, 10.3221786039)\n", + "\n", + "Seconds Taken 464.418161154\n" + ] + } + ], + "source": [ + "t = time.time()\n", + "results = bs.bootstrap_ab(test, ctrl, bs_stats.sum, bs_compare.percent_change, \n", + " iteration_batch_size=1000)\n", + "\n", + "print('Results {}'.format(results))\n", + "print('')\n", + "print('Seconds Taken {}'.format(time.time() - t))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Time\n", + "Use the 'num_threads' argument. This will spawn @num_threads processes to divide an conquer. This will usually speed up execution at the cost of CPU utilizaiton." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results 10.0181745751 (9.7088207046, 10.3279251239)\n", + "\n", + "Seconds Taken 74.681885004\n" + ] + } + ], + "source": [ + "t = time.time()\n", + "results = bs.bootstrap_ab(test, ctrl, bs_stats.sum, bs_compare.percent_change, \n", + " iteration_batch_size=500, num_threads=20)\n", + "\n", + "print('Results {}'.format(results))\n", + "print('')\n", + "print('Seconds Taken {}'.format(time.time() - t))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# A tip on Power\n", + "Power calculation simulations can take a very long time. Fortunately this method is easily parallelizable. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def run_simulation(num_loops, lift, data):\n", + " results = []\n", + " for _ in range(num_loops):\n", + " \n", + " # in real life you would use real data and then apply some hypothetical lift to it\n", + " sel = np.random.random(len(data)) > 0.5\n", + " \n", + " test = data[sel] * lift\n", + " ctrl = data[~sel]\n", + " \n", + " r = bs.bootstrap_ab(test, ctrl, bs_stats.sum, bs_compare.percent_change, \n", + " iteration_batch_size=500)\n", + " results.append(r)\n", + " \n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data = np.random.normal(loc=100, scale=100, size=20000) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import multiprocessing\n", + "num_threads = 20\n", + "iterations_per_thread = int(np.ceil(3000/num_threads))\n", + "\n", + "pool = multiprocessing.Pool(num_threads)\n", + "\n", + "pow_results = []\n", + "for _ in range(num_threads):\n", + " r = pool.apply_async(run_simulation, (iterations_per_thread, 1.05, data))\n", + " pow_results.append(r)\n", + "\n", + "pow_results = np.hstack([r.get() for r in pow_results])\n", + "pool.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.power as bs_power" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# take every 10th sample to make plotting a bit cleaner\n", + "bs_power.plot_power(pow_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Percent
Insignificant16.667
Negative0.667
Negative Significant0.000
Positive99.333
Positive Significant83.333
\n", + "
" + ], + "text/plain": [ + " Percent\n", + "Insignificant 16.667\n", + "Negative 0.667\n", + "Negative Significant 0.000\n", + "Positive 99.333\n", + "Positive Significant 83.333" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This test was positive but we should only expect to see a significantly positive \n", + "# result ~15% of the time\n", + "bs_power.power_stats(pow_results)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/pivotal_vs_percentile.ipynb b/examples/pivotal_vs_percentile.ipynb new file mode 100644 index 0000000..c57693a --- /dev/null +++ b/examples/pivotal_vs_percentile.ipynb @@ -0,0 +1,594 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pivotal method vs Percentile Method\n", + "\n", + "In this notebook we will explore the difference between the **pivotal** and **percentile** bootstrapping methods. \n", + "\n", + "tldr -\n", + "* The **percentile method** generates a bunch of re-samples and esimates confidence intervals based on the percentile values of those re-samples. \n", + "* The **pivotal method** is similar to percentile but does a correction for the fact that your input sample may not be a good representation of your population. Bootstrapped uses this as the default.\n", + "\n", + "We will show that the pviotal method has generally better power. This does come at a cost - the pivotal method can warp the confidence interval to give non-sencical interval values.\n", + "\n", + "See [Link1](https://ocw.mit.edu/courses/mathematics/18-05-introduction-to-probability-and-statistics-spring-2014/readings/MIT18_05S14_Reading24.pdf), [Link2](http://www.stat.cmu.edu/~cshalizi/402/lectures/08-bootstrap/lecture-08.pdf) for explanations of both methods." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import numpy.random as npr" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.stats_functions as bs_stats\n", + "import bootstrapped.power as bs_power" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup\n", + "The bootstrap is based on a sample of your larger population. A sample is only as good as how representitave it is. If you happen to be unlucky in your sample then you are going to make some very bad inferences! \n", + "\n", + "We pick the exponential distribution because it should differentiate the difference between the two methods somewhat. We will also look at an extreme case." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAloAAAGBCAYAAAC+Sh+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3Xu81NV57/EPbLzgZSteuRhravTxUjEIGlQUb1GOlRAr\nXqtGbTAnXtpEUTGpqCdpbdQGNbamJ2kaNamg9JgipkhtvaFIqon3+Gi8EcUbAQOR+95z/njWT4Zh\nZu/5zezZ7D18368Xrx97Zq1Z65nZM/uZtdZv/foUCgVEREREpOv13dAdEBEREWlWSrREREREGkSJ\nloiIiEiDKNESERERaRAlWiIiIiINokRLREREpEGUaImIiIg0iBItERERkQZRoiUiIiLSIP02dAdk\nwzCzzwK/BNqBbdz94w3cpYbKE6+Z/RtwIvA9d/+rbupil9rYXt96mdl44KvA/sAAoE+6a7C7v7fB\nOpaY2TnAj4A33H33DdwdKcPMFgPblLlrD3d/rbv7Uwt9bjSGEq1exMx+CpxedNNqYDHwAjAT+Gd3\nX1rlww1Px1e6681kZpcD/YGp7u7d0WaRPPEOAwrEB84G0QXPVbe/vr2VmV0BXEe85muAD9L/P2xU\nklXD63tA6tPTjeiP1MfMBgPL0z+AzYFtgUXdmWTpc6NnUqLVu2Qfth8DfyDezDsCRwJHAV83s7Hu\n/lwVjzUQeBmY1aC+rsPMdgL+juj/Xd3RZomq4jWzbYHd2ICJVhc9V936+vZWZjYIuJZ4rv8auMHd\n1zS4zVpe3wPS8ZmGdErq4u4LgMHZz2Y2Cfhb4Knu6oM+N3ouJVq9hJltCeyRfrzM3f8p3b418EXg\nRuBTwAwzM3df2dHjufvfAH/TwC6X+lw6/t7dX+nGdoFc8WZ/0FYCLzauRx2q+7naAK9vb3UysCnw\nsrtf101t5np9zawPMaUJ8KuG9Uq60kFEwvM/3dimPjd6KC2G7z2Gsfb1+uTD1t2XuvudwKnppk8B\nZ3Zz36oxMh2784OnFlmi9YK7t2+gPvSW56oZjCb+ID7QjW3mfX33BLZM/1ei1TsclI6/6MY29bnR\nQ/UpFAobug9SBTP7S+AmYg3J1uVGrMzsDWBX4C53P7Pkvv8AjiupsgZodfcVVbT/WeAC4DAimesL\nvEsMM/878KPiKRcz+xLwLyUPU2DtIuNiP3b38yq0+xSR/FwOfBc4FzgH2JuYOn0buL10NKLWeM3s\nX4mk9QfAd4BrgGOJBdJvEAuSb3T39d44ZvYA8HngOnf/Zpn7/wa4EvhPdz+u6Pa6n6sueH33AS4G\njgGGECN6vwJudff/V6HOXxDP0+vu/hkzOwu4ENgX+D3wEHBFmlbpcjX2+dvAN0purvRcD3D333dB\nP+t6fc3sdOCnwPvuPqiW5zmtIboE+FPgj4jn6hngH939npoC64CZfY14v/4KOJR4/54GfJpYVzoD\n+Ia7L+rgMWp5fWtut9b3b5lyQ4DfEq/xkM7W+ZnZ5sAJqe1hKdYdgCXEmrxb3X1mmXr63OglNKLV\ne2SLFF/uYFrwdeJNNqTMfTsB76V/S4k3pFf5ZrqSWGvwF8S36wLxhtoNGAPcUqbarkXtFX/QLCq5\n/V3gyQrtthBvvgIwH/gv4g06Mt22CTGdemgXxpuNaG1G/CE6k1hcugkR+3eAf6xQ97N0vLYrW2Rf\nOipR93NFfa/vX6Y+nw/8MfHatgJHANPN7K87iedlM7sDuB3Yi3iuBgF/DtyfXscuVUefd2Ht8/Rh\n0e0fsO5z/UxXJFlJva/vsHR8rpbnOf0hewX4OvE7vBLYGjgcmGZmN9cTXAXZetIPgHnA1az9grYz\n8bo9aGabVOhzra9vPe3W+v4tlY1mLajyZIq/AO4Gvkx8zm9JLKrfjviSN8PMJpapp8+NXkKJVu+R\nfYB0tEA7W3O33uvq7sPdfbC7DyYWSvahimkIMzuamLPvQ5yZNcTdt3b3AURC97+Bn5UuIHb3bxW1\nt3/RXYdmt6d/Q9z9/1Zofm8i4QG4FNidSHxa3X1H4o/FqcB/dkW8JevgvgQ8DHzG3bclvmH+PN03\nwcz2KKk7mDgxATr+oIaSBc1d8VzV8fr+BTFSugkwBdg5vbYDiZFKgMlmtluFePoQH6wGjEjP1Ras\nXecxlLV/eLpEPX1293OKnqeT0s1rgF1KnusDSuvWqgte36wvh5LzeTazc4k/ZMuAvwK2S8/VlsRI\nRDtwUXqfd6UDiN+N44jPrYPdfevU7tWpzP7AWWX6XM/vZE3t1vP+LSPvtOGuwPeA/wVs7+7bptd3\nF+K1A/iWmbUWV9LnRu+hRKsXMLP+RMYPHSdaA4gPl486echqv5kBnJ3KTnf3vy7+hubu77n7D9z9\ntCraA1jmnuuU48+mYx9ge+IN+a/uvjy1v8rdp7t7Z9/Iq403+wAAmOXu49z9jdTWYiKpzPpzTJm6\nEAtR3yh94HR2287px476UetzVfoYncab+nRTKnu1u09094UA7v4hcB7xzbqFmNoortuH+DAsAL8D\njnb3X6a67cSUazbyumuNcXRpn8vIEpiXSr8oNFAtr2/2euZ6ntN0/z8SIxqj3P3WbJTO3Ve6+z8C\nP07FT6WLpKkwS31+Gxjt7r9I7a5x92+z9kSTo0vq1vM7WXO7dN37F2JRetUL4d39Cnf/K3ef7e4f\nFd3+LvAVYBVxwsa+HTyMPjd6MCVavcP+xC8tVEi00i9wtpHhm5UeKA3H7tfRY5XYIR3rmUbJPgSe\nrbFeO3Cau3+Qt+Gc8WbttRGbV67D3d8hPhxg7Yduad1K33azP+rLiWmczvqQ97kCcsd7JfFN/wXK\nnGmUkstsD6BPl9xdvEB7orv/oaRuOzFSBDGV0VXq6XOp7Lnuzm08cr2+ZvZHxBcoyP88f4f4A32F\nVz4LzYkvDp+qpj9VKv68utLLT8E+m9otfR/V8/rW026XvH/T53C2zKMrFqX3Ze2Xv46+DOhzowfT\n9g69Q/YmL1D5g2APYi1RR2UgRsY2r6Jc5iliSPvLZtYOfN/d8+7lU820ZznZmon/cPda96PJE2/2\nPP/c3d+qUCZbBL+s5PbOvg1+ss7GyyykL+lDPXt4VRWvmW1GTMMWiB3wK/Up+3ZZen8Wz3LgvjKP\nvyvxgVogTpioWxf0uVSekd2ukvf1Lf4DX/XzbGb7EourC8CNZnZDhcffKh1Lf5/rkfV5EZX3c2pL\nx2yDz654fWtqN+mq9+/exJKGdqpMtMxsO2IUaAwxajWASJCLFYg1uJXoc6MHU6LVO2TfkF4r/QZQ\n5Mii/z/awWNlv+hvVvjGV+p6YvH5McAE4HwzW0CcDv9Dd59bxWNkbeb9g5atO5ies165tquJN/uw\nWu8DAD6ZmshGF0rPiOlsdCR77M6SvVqfq9L6ncV7MLFzdQG4v4Ny2Yjm+xXaedzLL5zNfmcXu/tv\nO3j8POrt8yfMbFNgn/RjdyZaeV/fLHnI+zx/oej/O9KxAnFGbVfJYpzllbdIGZzafbfotq76nczb\nbnHdet+/2V5Wv3H3JZ2UxcxOJE7w2S49/mpiUfrqVGRLInH7nbv/ruyDBH1u9GBKtHqHar6t/Gk6\n/to7vuRD9sFd1RvS4zIMx5nZocB44lvy3qRtFszscnf/+0r1zWwr1k5pVv1ty8w+xdoPnznV1iuj\nqnjTN7W904+VvokOJ6Ym1ll/UeVu8p32o9bnKm87SfEHWukfnaw/W7N2nUTppV+y0cZKl4TJ9XtW\npXr7XGw/4vOvnW7abb3G1zcbacn7PGf1prh7uTPWGin7vOrotc/WXxaPVNf7+tbUble9f5NsAXen\no1lmdiRxtmFf4A7itXq2pMxtxDqtir8v+tzo+ZRo9XDpm3e2CLLS+qxBxPRegdjnqSM1XcfP3R8H\nHk/t7Qv8X+Lbzd+a2W3uXmnqIVtgvpKY069W9s1naSeJYzWPU028Q4n3QwF4p0KZbGHn/JIFp9nI\n2wrKDHeb2d7EB09nfwRqfa5KH6OaeHdKx46+JY9N/VkKlI5cdjYC0IjrRdbb52JZ/3/j3XdNt1pe\n3+wPT97neWA6duWUYKfMrB/wJ+nHslsbmNlI4uSWArFlS6bm17fOdrvq/QtrF8JXc8bh3xFJ1nR3\nP6dMuy3An9H5+0ifGz2cFsP3fFkCAJV/+W4kRlp+TwxDdyT7RlfzNwZ3f5E4NZzUt46mJrIPsRfd\nva2DcqWyftY72lBtvMWn86/3BSQlvOcQHwKlmwRmWz28UWHNQnYh8Dbg+Q76UOtzVazaeLMFtpt1\nUOZrRLxTszM94ZMNGbOpgc5Ohe/KD8ya+1xGvVMttcj1+prZQNYmTHmf52xB8R/n6mH99mXt+qKy\ne2Sx9uzdeSVfoup5fetpt0vevynZy74UV7OVzIHpx0pfjk+n8y0nQJ8bPZ4SrZ5veNH/1/vlM7ML\niTdkAZjk7ksrPZCZfRrYJv3Y2QdBZ5vFZYnJR8Sp1JXsmY5559s72zywU3niZd1E68Ay919FnKn0\nO6B0O4lsf5v+ZfqwFzCRtRsBdnQNylqfq6ytPPFmC2uHmFnpGViY2SXACOJbfumZRcWnwq+3QNfi\n4raD0o9d+YFZT59LVTPN1NXyvr71PM8vEX8Ujzezil+EzGxg2j6mqxS/jz5XeqeZHQScQTz33yq5\nu57Xt552u+r9O5i1SV6ltbSZrYv+X67d3YFbi27qaBpcnxs9XM1Th2leeBKxbmdX4g/uvXTyx76G\ndiYQi7D3ItZTPEKcFvpqhfI7E5fYGEu8aO8Tl6+4utJeOWZ2FHAZkdRsRXxrudrdy17B3Mz+hIj9\nCCJDfxt4EPhW2gKgK2UfIPPTabPZt6GDibn7k4gPgTu98safpY/1vne+Y/GRacfofwRmZmfhmdkO\nxE7Gk1O7N3byLSpb1DnczIbkeH66YsQhT7zZH16AG8zsdXd/Ka3fuCL9awfOL7NYdH467mZmXwf+\nIZX9U+LDchVrd5rvSK3PVXEMUF28M4kd/VuA283sPHdfkOK9jPj9LhDvtfkldas9Ff4Pld6nNaqn\nz58ws77ESDF07wd63tc3ex5reZ7vJC6ZtQ3wgJldBPzC3dekjS9HEV/QvkBMp3WV4oTnXDN7mLUn\ns5wE3Ea8fne5+3+U1K3n9a2n3a56/xYv7r7IzC7uYFT1feLKBDsC15jZc+7+ejrhZjwxS5Et6C+7\nt1cRfW70cDUlWukb0kPE4mEnnvxDiL2HdmPtwuy6mNlU4BTicgqziGRrLPELtU/pWR1mticx9z6Y\n+AP9SyIZupI4U+LCMm1cRGy+thqYTSRaRxKXPRhdeladxXXH/oV47p4gFmp/jrgMwRfNbFilRYI1\nyka0BpvZu6l/2T4kBWKK4AYvuTZX+mPyBuueJrxFOu6QHqvYYe7+m5J29yJ2LP6emS0jhs6zb2Lt\nxOLN6+jYLOLSH0OA+Wb2e9ae+ntuuWTWzLYhrsdW9YhWPfGWrO+4hdhB+wUzW0o8332ID9EL3f1n\nZZp/gEi2hwB/D2Sn0vchvj3/GTGl0FnSWPVzVe/r6+5vm9nVwLeJy3y8bWZLiNe3D/F++Gt3v61M\nP6tZNwRdvMi8zj4XM9ZuhdKdI1p53wvZez/38+zu88zs/xAjsfsTn1NrzOxj1o5eFICnKn0BrVG2\nxuYW4lIqU1kb42bpvpnEl7XSPtfz+tbcLl30/nX3D1KCN5rYruFLZva71PbL7n5kUdlCivUfiBMz\nfpN+H7YiZppmEGtFL+isXfS50ePVOnV4O5Fk3ezu+7j7KcQvy0JgjJkN7bB2FczsCiLJegzYI7Wx\nPzFyNIhYL1NcfhPiDI7BwKXuPsLdxxNJ0GpiH6jtSuocQlw+4H1gmMdO4EcTl2roR2ToxeX3IJKs\n1cQv4OEeu6LvQSz625G4XlWXKEoACqk/OxHfJN4G/pvYRXfP0iQr2ZO4hMNORf+2So/VUnL7Nqx/\nevdUYsh8FjFc3Df9+zWxEP5z1ZzN5O7/SVzO5ikg+5DfiXiuKm38l00brkjtVaOeePdh7YfxZGIE\n1YlpgLeIdW8HuHvp2qwsxqXETtMziffAEuL39Djigzq7PmSHHyA5n6t6X19Skpy9x5YSv2OvAd8n\nduGvtPfSZ4lEu7MFrR1Nd9Skjj6X69/bnZwy36VqeC/U9Ty7+zXE7+C/E9sZFIjf6VeI9/dZxBfR\nLmGxWWe2XmgmMWo2g9gzaQVxMs056XO27BRcLa9vve121fs3OZFI9l4jvgTvSLzG603rufv3iR35\nf8Hafb3mAGe6+4nE+rpO30f63Oj5+hQKne3pty4zO574hfwV8aQWiu77EfGCX+xxeYeamNn2xB84\niERiQdF9ZxOXjZiekq/s9guIYd4Z7v7Fksf7b+Jbxlh3/3nR7fOI+eSTikcqLDZNexNY6O47Fd1+\nHXE1+Ovd/cqSNr5JvClvcPcrao1dRKQ3SuuZXiL+WO7o7t2ys/eGalekWrWMaF3O2v1ZSrO0d4nh\nw8F19utiYjhzanGSVdQGZdrIFizeWObx1qtjZqOJRc+vl5kOyspvn0aVMrulY7n58v1T+4+XuU9E\npNllUz9vd3Oys6HaFalKrkQrLTQfRQzH3lOmSDb90tkZa505OT3OHRXaoLgNMzuQSILecvdym1uu\nV4cYsu2sjdI6vyESyRPTXHfW/hnEgsv/dPcZZR5PRKTZbajNJptyk0tpHnkXw59AJGePuftKM7uG\nuDTLVzz2VsrWQNX8rSKd1ro3cXrsE2Y2jjiL8LvuPq1CG9nlJmanx/g+8BngrLQwvVydsen4YFp7\n9UPgyTTtl5VfUTKnfytxivBxwMtm9ktiR94/Ieanv15r3CIivVy2eL+7E54N1a5IVfJOHY4kRoEe\nMbMtiIXDBxNnRkCcpQY17udR1AbA3HQ2zDeJKb7JHbSR9etRM9uHOAPwSOLil+vVsdg4bQhxZsY8\nYvHzYcDEdEZl2Tjc/X3i1Nu3iQTrZOLb1E+Bq9x9Vc1Ri4j0bvsTi527O+HZUO2KVCXviFY2F/6S\nuy8zs2nEiNY96cyPbFfces4a+KSNdLyDOB37x+nnoax/ZkJW50XgVeBhYkRrZtr3aSBxBsgzJeXd\n3dvN7F7gbCK5+7DorMlP2khnNf4DkVxdSJzJsyXwl8SI20gzO0DJlohsjNy9K/fj6vHtilQrb6K1\nSzq+AuDu2aUJMLPhxF4ai+rcbGwXIpHK2riVtENuWhd1aCo3L922OWsvPvyKu68Gjirq10npvy/4\n2quFl8Yxl7WXuoA4Q7GQtZH8hBjNKj5D8WPgr83sMGLt2impXFUKhUKhT58+nRcUERGRUr3iD2je\nRGtAOpZbg3VsOs6svTudtnEQsbfHfHd/rqT8qgq78B5LJE3Fi9QrtpFGrg5PP96XbtuPGMn6TYUN\nK+cRida+Ze6rqE+fPixZspy2tvbOC/dwLS19aW3tr3h6oGaKBRRPT9ZMsYDi6cmyWHqDvIlW9sqs\nKHPf2URCU+5sxK5q49x0vLua8mm06+T04/SiuzpqYzwxMvdU0WUPDknHFyv0ObtQZu5pw7a2dtas\n6d2/8MUUT8/VTLGA4unJmikWUDxSn7yL4bM9rYqn2bJNTA34tbvfX2efKrWxE3FtrlXEzruZhem2\n1pRYFTuPuPTOA+7+QmdtJNmVx4v348qep9bSwma2GWunKp8s83giIiKykcqbaM0h5kTPy26wuPL3\nbcQo0SWVKprZkWbWnv6Nq6KNM7PNQlMCdSex+PxGd387K+xxQeNsLVU24oWZHUBcj2kFsclqsWxT\n0TFmNrCozrXEGY5zWHdkLnv8w9JGp1n5zYhtHXYFniMuVyMiIiIC5J86nAKcBlyWrhO4EPg8cYHW\nSe4+u4O6I9KxQFzbqZJpxFYOhwDPm9nz6f+DiHVWk8vUuZ5YI/U9M/sicS3CY4nk79yS0SzSVdKn\nE5uMPmtmjxLXgNqPuMbdGcW73rv7L83sTmK7iAfThUM/JpKyQcS1AE8ss1O+iIiIbMRyjWi5+zPE\nZp1PEPtHHUaM/hxXxcVcRxBJ1oK0iWilNpYRFzq9F9gZGAO8B1zg7ie6+3oTy2m68lRiVOnw1NZ9\nwCh3v6tCU2cDNxNJ2QlEsngdMNLd3ylT/hzgr4Bnib3DPk8spv8/xAWH36wcuoiIiGyMcl9UWrpU\nYfHij5tiUWK/fn0ZMGBLFE/P00yxgOLpyZopFlA8PVmKpVds71DLRaVFREREpAp512hJF7rtB7fz\nkr9Je84vFgcdMJTjjzumMZ0SERGRLqNEawOa+6vfsLj/iNx727Y99UslWiIiIr2Apg5FREREGkSJ\nloiIiEiDKNESERERaRAlWiIiIiINokRLREREpEGUaImIiIg0iBItERERkQZRoiUiIiLSIEq0RERE\nRBpEiZaIiIhIgyjREhEREWkQJVoiIiIiDaJES0RERKRBlGiJiIiINIgSLREREZEGUaIlIiIi0iBK\ntEREREQaRImWiIiISIMo0RIRERFpkH61VjSzrYBJwHhgV+Aj4F5gkrsv7ZrugZlNACYAewHtwCPA\nRHd/tUL5nYFvAGOBQcD7wE+Bq919TYU6RwGXAcOBrYDnU/lZJeX2Bl6sotvnu/sPqygnIiIiTaym\nRMvMdgQeAvYGHJgJHAJ8FdgN+NOu6JyZTQVOAT4AZhHJ1lhguJnt4+5LSsrvCfwXMBj4FfBL4Ajg\nSmBb4MIybVwE3ASsBmYTidaRwAwzG+3uc4uKbwH8uEJ3BwPHAn8AZuSPVkRERJpNrSNatxNJ1s3u\nfgmAmQ0gkq4xZjbU3Z+rp2NmdgWRZD0GnODuS82sD/AAcDRwDnBLUflNgLuJhOdSd78p3b478BLw\nZTO7yt0XFdU5BJhCjHod7e4vp9uvAq4lRrn+LCvv7k8D51Xo778CBeB6d/+gnthFRESkOeReo2Vm\nxwNjgGeAS7Pb3X0xMbIFMKqeTpnZ9sBVwDLg9Gwq0t0LwE+APmXamAAMBe7LkqxU5zXgcSKpHFlS\nZwrxHFyYJVnJ7XniMLODgFOBd4G/r6aOiIiINL9aFsNfTozcTEmJT7F3iSRocJ39upiYppvq7gvK\ntEGZNiamft1Y5vHWq2Nmo4EDgdfd/WcVym9vZtWM+mVtXuPuy6soLyIiIhuBXIlWWmg+ClgB3FOm\nyGZEstNSZ79OTo9zR4U2KG7DzA4k1oa95e5zqqlDjEB11kZpnfWY2TjiOfk18M8dlRUREZGNS941\nWicQydlj7r7SzK4BjgG+4u4vAtulcosq1O9UWlO1N7Go/ImUyHwD+K67T6vQxhfScXZ6jO8DnwHO\ncvd3K9QZm44PmtkewA+BJ939iqLyK9x9ZQd9bQG+QyRsk8qM8ImIiMhGLO/U4UgiqXjEzLYAJgMH\nAxek+/dKx9/W0adsHdXctB3DN4kpvskdtJH161Ez2wc4nzhz8MxydcxsCDAEWAnMI9Z3HQZMTGdU\nVhvH+cCewKPuPrOTsiIiIrKRyTuiNSwdX3L3ZWY2jRjRuiedEbhvuv/pOvr0SRvpeAdgrN1WYSiR\nVD1dps6LwKvAw8SI1kwz2wEYCKwhFvAXl3d3bzeze4GzieTuQzMb2lkcaR+xa1JfLssVYZ369ulD\nv349a6/Zlpa+6xx7u2aKp5liAcXTkzVTLKB4erLeFEPeRGuXdHwFwN1Pz+4ws+HA1sCiSpuJ5mij\nUNTGrcCtqY2+wKGp3Lx02+bEVF8BeMXdVwNHFfXrpPTfF9x9RYU45hLJWGZ0erx5HfTzCmBHYJq7\nP5U7yjpsulk/BgzYsjubrFpra/8N3YUu1UzxNFMsoHh6smaKBRSP1CdvojUgHcutwTo2HeudQuuo\njYOAbYD5Rft0ZeVXVTjj71giaSreRLRiG2k/rsPTj/eV66CZDQK+Dqwi1o91q1Ur17B48cfd3WyH\nWlr60tranyVLltPW1r6hu1O3ZoqnmWIBxdOTNVMsoHh6siyW3iBvopW9MivK3Hc2kdCUOxuxq9o4\nNx3vrqZ8Gu06Of04vco2xhMjc0+5+xsV+vhtoD9wSwdlGqa9UGDNmp75Jmlra++xfatFM8XTTLGA\n4unJmikWUDxSn7yTnNmeVsXTbNkmpgb82t3vr7NPldrYCTidGEW6peiuhem21pRYFTuPuPTOA+7+\nQmdtJF+j8n5cmNl+wJeAJcC3OgtGRERENl55E605xIakn1yGxsw+DdxGjBJdUqmimR1pZu3p37gq\n2jgz2yw0JVB3AlsCN7r721lhd29j7VqqbMQLMzuAGHlaQWyyWuzxdBxjZgOL6lxLnOE4h8ojc9en\n/v1d8eV8RERERErlnTqcApwGXJauE7gQ+DwxjTbJ3Wd3UHdEOhaAX3RQbhqxlcMhwPNm9nz6/yBi\nndXkMnWuJzYN/Z6ZfZG4QPSxRPJ3bsloFu7+uplNB04CnjWzR4ltGvYjrtd4Rrk9sczsGOA4YtuH\nm0rvFxERESmWa0TL3Z8hEo0ngAOIvafmAMe5+w2dVB9BJFkL0iaildpYBhwB3AvsTFxX8T3gAnc/\n0d3Xm1hO05WnAs8RC9lHEAvZR7n7XRWaOhu4mUjKTiCSxeuAke7+TmnhtH3F9SmGyR1tZCoiIiIC\n+Ue0cPeHqeGi0e5+ao6ybxGL0vM8/nTWXfDeWfkVxFRnxenOkvIFIrkUERERqUrv2fFLREREpJdR\noiUiIiLSIEq0RERERBpEiZaIiIhIgyjREhEREWkQJVoiIiIiDaJES0RERKRBlGiJiIiINIgSLRER\nEZEGUaIlIiIi0iBKtEREREQaRImWiIiISIMo0RIRERFpECVaIiIiIg2iREtERESkQZRoiYiIiDSI\nEi0RERGRBlGiJSIiItIgSrREREREGkSJloiIiEiDKNESERERaZB+tVY0s62AScB4YFfgI+BeYJK7\nL+2a7oGZTQAmAHsB7cAjwER3f7VC+Z2BbwBjgUHA+8BPgavdfU2FOkcBlwHDga2A51P5WR30a09g\nInA0MARYArwEXO/uP88fqYiIiDSbmka0zGxH4EngSiL5mZmOXwWmdlXnzGwq8E9EIjcLmE8kUA+Z\nWWuZ8nvXNiRGAAAgAElEQVQCTwEXAYuA+4nE6Urg5gptXATMBo4A5qZ/BwIzzOzgCnXOBZ4DzgHe\nBv4N+DXwOWD3WmIVERGR5lPr1OHtwN7Aze6+j7ufAuwHLATGmNnQejtmZlcApwCPAXukNvYHHiRG\nqs4pKb8JcDcwGLjU3Ue4+3gi+VkNfNnMtiupcwgwhRj1Gubu49z9aOBqYrTvsjL9Ggv8gBi92sfd\nR7v7n7v7aOCPgHvqjV1ERESaQ+5Ey8yOB8YAzwCXZre7+2JiZAtgVD2dMrPtgauAZcDp2VSkuxeA\nnwB9yrQxARgK3OfuNxX16zXgcSJxGllSZwrxHFzo7i8X3X57uTjSdOkPiMTsGHf/TfH97v6Bu7+X\nL1oRERFpVrWMaF0OFIApKfEp9i6RBA2us18XA1sAU919QZk2KNPGxNSvG8s83np1zGw0MUX4urv/\nrEL57c2seB3bhcCOwDfdfVE1gYiIiMjGK9di+LTQfBSwgvJTZJsRyU5Lnf06OT3OHRXaoLgNMzsQ\n2A14093nVFMHOLWKNrI62SL6CcDvgZ+mRO14oJWYRrzD3X9fOSQRERHZ2OQ96/AEYhTsMXdfaWbX\nAMcAX3H3F4FsDVTNoz1mtjux/usPwBNmNo44i/C77j6tQhtfSMfZ6TG+D3wGOMvd361QZ2w6Pmhm\newA/BJ509yuKyq9w95XpMYcBf0wsfP8hcBaRqEGM4l1qZiPcfWGtsYuIiEhzyTt1OJJILh4xsy2A\nycDBwAXp/r3S8bd19ClbRzU3bcfwTWKKb3IHbWT9etTM9gHOB44EzixXx8yGEFsyrATmESNVhwET\n0xmV5do4Jh1HE9tAHE5Mbw4nRrQ+BVxbU8QiIiLSlPImWsPS8SV3XwZMI0aJ7jGzPsC+6f6n6+jT\nJ22k4x3AUuDH6eehRFL1dJk6LwKvAg8D7wAzzWwHYCDQRizgLy7v7t5O7P/1ATDD3T9MbZTGMTwd\nNwWOdPc57r7S3Z8hzk7sQyRhIiIiIkD+qcNd0vEVAHc/PbvDzIYDWwOLKm0mmqONQlEbtwK3pjb6\nAoemcvPSbZsTU30F4BV3Xw0cVdSvk9J/X3D3FRXimEskY5nR6fHmFd1m6bbvpWSsWBZvvScBVKVv\nnz7069ezNvVvaem7zrG3a6Z4mikWUDw9WTPFAoqnJ+tNMeRNtAakY7k1WMem48wy93VVGwcB2wDz\n3f25kvKr3H15hX4VgBnVtJH24zo8/Xhf0V07pON/l2ljUDp2y/qsTTfrx4ABW3ZHU7m1tvbf0F3o\nUs0UTzPFAoqnJ2umWEDxSH3yJlrt6biizH1nEwlNvRt2dtTGuel4dzXl02jXyenH6VW2MZ4YmXvK\n3d8ouj07E3F+mToHpOMTZe7rcqtWrmHx4o+7o6mqtbT0pbW1P0uWLKetrb3zCj1cM8XTTLGA4unJ\nmikWUDw9WRZLb5A30VpAbKMwkNjmAPhkE1Mj1m7dX2efsn2ziqfyMLOdgNOBVcAtRXctTLe1mtnm\nRdODAOcB2wKz3P2FztpIvkb5/bg+ALYHdgZeK+pXX2LfrwJwV2fBdYX2QoE1a3rmm6Strb3H9q0W\nzRRPM8UCiqcna6ZYQPFIffJOcs4hFn2fl91gZp8GbiNGiS6pVNHMjjSz9vRvXBVtnJltFppGpu4E\ntgRudPe3s8Lu3sbatVTZiBdmdgDwbWLU6vKSNh5PxzFmNrCozrXEGY5zWH9k7r9Svy5JyRXpBICb\niW0fHnX3BzqIS0RERDYyeUe0pgCnAZel6wQuBD4P9AcmufvsDuqOSMcC8IsOyk0jtnI4BHjezJ5P\n/x9ErLOaXKbO9cRGqt8zsy8S1zY8lkj+zi0ZzcLdXzez6cBJwLNm9iiwJ3G9RgfOKLPr/XdS7CcC\nL5rZs8TZi3ukOqd1EJOIiIhshHKNaKWtDI4j1iIdQOw9NQc4zt1v6KT6CCLJWpA2Ea3UxjLgCGLL\nhZ2J6yq+B1zg7iem7RhK69xP7PT+HLGQfQSxkH2Uu1eazjubGI1aTWzE2h+4Dhjp7u+UaWMBcYHq\nu4izHMcRI1x/C4xw9/c7iV9EREQ2MnlHtHD3h6nhotHufmqOsm8Ri9LzPP501l3w3ln5FcRUZ8Xp\nzjJ13mTtJqgiIiIiHeo9G1GIiIiI9DJKtEREREQaRImWiIiISIMo0RIRERFpECVaIiIiIg2iREtE\nRESkQZRoiYiIiDSIEi0RERGRBlGiJSIiItIgSrREREREGkSJloiIiEiDKNESERERaRAlWiIiIiIN\nokRLREREpEGUaImIiIg0iBItERERkQZRoiUiIiLSIEq0RERERBpEiZaIiIhIgyjREhEREWkQJVoi\nIiIiDaJES0RERKRB+tVa0cy2AiYB44FdgY+Ae4FJ7r60a7oHZjYBmADsBbQDjwAT3f3VCuV3Br4B\njAUGAe8DPwWudvc1FeocBVwGDAe2Ap5P5WeVKfsl4F866PIX3X1GddGJiIhIM6sp0TKzHYGHgL0B\nB2YChwBfBXYD/rQrOmdmU4FTgA+AWUSyNRYYbmb7uPuSkvJ7Av8FDAZ+BfwSOAK4EtgWuLBMGxcB\nNwGrgdlEonUkMMPMRrv73JIqw4AC8B+pX8UKwBM1hisiIiJNptYRrduJJOtmd78EwMwGEEnXGDMb\n6u7P1dMxM7uCSLIeA05w96Vm1gd4ADgaOAe4paj8JsDdRJJ1qbvflG7fHXgJ+LKZXeXui4rqHAJM\nIUa9jnb3l9PtVwHXEqNcf1bStc+m45fd/b16YhQREZHmlnuNlpkdD4wBngEuzW5398XEyBbAqHo6\nZWbbA1cBy4DTs6lIdy8APwH6lGljAjAUuC9LslKd14DHiaRyZEmdKcRzcGGWZCW3dxDH/sDvlGSJ\niIhIZ2pZDH85MUU2JSU+xd4lkqDBdfbrYmALYKq7LyjTBmXamJj6dWOZx1uvjpmNBg4EXnf3n1Uo\nv72Z9Suq82lgG6Cu0ToRERHZOOSaOkwLzUcBK4B7yhTZjEh2Wurs18npce6o0AbFbZjZgcTasDfd\nfU41dYBTq2gjq5Mtoh+Wjn3N7DpgADCfSAhfrxSMiIiIbJzyjmidkOo85u4rzewaM5tjZvum+7dL\nx0Xlq3curanaG/gYeMLMxpnZPDM7tYM2vpCOs9NjfN/MHjSzQR3UGZuOD5rZHmb2iJl9p6T8Cndf\nWVTns0RyNpoY2ZsAfBv4tZmdUUu8IiIi0rzyJlojiUTjETPbApgMHAxckO7fKx1/W0efsnVUc9N2\nDN8kpvgmd9BG1q9HzWwf4HzizMEzy9UxsyHAEGAlMI9ImA4DJqYzKivFsTQ95u7E1OafANOATYB/\nNrM/qi1kERERaUZ5E61s6uwld19GJBmLgHvSGYHZyNbTdfTpkzbS8Q4iwflx+nkokVQ9XabOi8Cr\nwMPAO8BMM9sBGAi0EQv4i8u7u7cT+399AMxw9w9TG+vF4e43uPtd7v6mu690918DZwD/A2wKnFZj\nzCIiItKE8m7vsEs6vgLg7qdnd5jZcGBrYFGlzURztFEoauNW4NbURl/g0FRuXrptc2KqrwC84u6r\ngaOK+nVS+u8L7r6iQhxziWQsMzo93rzOOuvuBTP7OTHqtluOOGvWt08f+vXrWZv6t7T0XefY2zVT\nPM0UCyienqyZYgHF05P1phjyJloD0rHcGqxj03Fmmfu6qo2DiLP+5hft05WVX+Xuyyv0qwAU79Ze\nsY20H9fh6cf7quxzlsB9VGX5umy6WT8GDNiyO5rKrbW1/4buQpdqpniaKRZQPD1ZM8UCikfqkzfR\nak/HFWXuO5tIaMqdjdhVbZybjndXUz6Ndp2cfpxeZRvjiZG5p9z9jWo6TOyKXwBKd5FviFUr17B4\n8cfd0VTVWlr60tranyVLltPW1t55hR6umeJpplhA8fRkzRQLKJ6eLIulN8ibaC0gpscGAr/Pbkyb\nmBqxduv+OvuU7ZtVPJWHme0EnA6somhHeGBhuq3VzDYvmh4EOI+49M4sd3+hszaSr1F5P671mNlB\nxCWH5hOX5Wm49kKBNWt65pukra29x/atFs0UTzPFAoqnJ2umWEDxSH3yTnLOITYkPS+7IW3ieRsx\nSnRJpYpmdqSZtad/46po48xss9A0MnUnsCVwo7u/nRV29zbWrqXKRrwwswOIrRdWEFsxFHs8HceY\n2cCiOtcSa63mUDQyZ2YnpMv1lMZ0NDG9WAAuSOvDRERERID8I1pTiDPrLkuJx0Lg80B/YJK7z+6g\n7oh0LAC/6KDcNGIrh0OA583s+fT/QcQ6q8ll6lxPbKT6PTP7InGB6GOJ5O/cktEs3P11M5sOnAQ8\na2aPAnsC+xHXazyjZNf7M4FTzOw14FliBG3fVH458CV375bRLBEREek9co1oufszwHHAE8ABxN5T\nc4Dj3P2GTqqPIJKsBe7+bqVCaduII4gtF3Ymrqv4HjFidGLajqG0zv3ETu/PEQvZRxAjTaPc/a4K\nTZ0N3EwkZScQyeJ1wEh3f6ek7Gzgv4HNgeOJzU5bUv193f1fO4ldRERENkJ5R7Rw94ep4aLR7n5q\n56U+KfsWsSg9z+NPZ90F752VX0FMdVac7iwq+yPgR3n6IyIiItJ7NqIQERER6WWUaImIiIg0iBIt\nERERkQZRoiUiIiLSIEq0RERERBpEiZaIiIhIgyjREhEREWkQJVoiIiIiDaJES0RERKRBlGiJiIiI\nNEjuS/DIhtXetpoP3nuHX/3q6dx19913PzbddNMG9EpERETKUaLVyyz58E2WfrQF37r9qVz1lv5u\nPtdfAsOGDW9Qz0RERKSUEq1eaOvtd2XbgXts6G6IiIhIJ7RGS0RERKRBlGiJiIiINIgSLREREZEG\nUaIlIiIi0iBKtEREREQaRImWiIiISIMo0RIRERFpECVaIiIiIg2iREtERESkQWreGd7MtgImAeOB\nXYGPgHuBSe6+tGu6B2Y2AZgA7AW0A48AE9391Qrldwa+AYwFBgHvAz8Frnb3NRXqHAVcBgwHtgKe\nT+VnVdnHfwVOA9qArd19RdUBioiISNOqaUTLzHYEngSuJJKfmen4VWBqV3XOzKYC/0QkcrOA+UQC\n9ZCZtZYpvyfwFHARsAi4n0icrgRurtDGRcBs4Ahgbvp3IDDDzA6uoo8TiSSrALyiJEtEREQytU4d\n3g7sDdzs7vu4+ynAfsBCYIyZDa23Y2Z2BXAK8BiwR2pjf+BBYqTqnJLymwB3A4OBS919hLuPBz4H\nrAa+bGbbldQ5BJhCjHoNc/dx7n40cDUx2ndZJ308BrgOyEbXnqk5YBEREWk6uRMtMzseGEMkFZdm\nt7v7YmJkC2BUPZ0ys+2Bq4BlwOnZVKS7F4CfAH3KtDEBGArc5+43FfXrNeBxInEaWVJnCvEcXOju\nLxfdfntncZjZp4nRu4eAf099UqIlIiIin6hlROtyYppsSkp8ir1LJByD6+zXxcAWwFR3X1CmDcq0\nMTH168Yyj7deHTMbTUwRvu7uP6tQfnszW28dm5n1J9aj/Z6YNtw/tf2rDmISERGRjUyuRCstNB8F\nrADuKVNkMyLhaKmzXyenx7mjQhsUt2FmBwK7AW+5+5xq6gCnVtFGaZ3Mj4DPACe6+yLgs+l2jWiJ\niIjIJ/KedXgCkZw95u4rzewa4BjgK+7+IpCtgVpUa4fMbHdi/dcfgCfMbBxxFuF33X1ahTa+kI6z\n02N8n0iEznL3dyvUGZuOD5rZHsAPgSfd/Yqi8ivcfWVJ/y4j1o6d6e7PmdkQYEdggbsvrDVuERER\naT55pw5HEqNAj5jZFsBk4GDggnT/Xun42zr6lK2jmpu2Y/gmMcU3uYM2sn49amb7AOcDRwJnlquT\nkqMhwEpgHrG+6zBgYjqjsmwcZvZ54G+Bm9z9rnTzAemo0SwRERFZR94RrWHp+JK7LzOzacSI1j1m\n1gfYN93/dB19+qSNdLwDMODH6eehRFL1dJk6LxJnAD5MjGjNNLMdgIHAGtYmQ1l5d/d2M7sXOJtI\n7j4sOmvykzbM7I+Bu4h9vIrPRswSrR6/PqulpS/9+jVmj9qWlr7rHHu7ZoqnmWIBxdOTNVMsoHh6\nst4UQ95Ea5d0fAXA3U/P7jCz4cDWwKJKm4nmaKNQ1MatwK2pjb7AoancvHTb5sRUX7aP1WrgqKJ+\nnZT++0LRHlelccwlkrHM6PR4WRtbEIvflwKnunt7UdkDUtkeP6LV2tqfAQO2bHgbzaSZ4mmmWEDx\n9GTNFAsoHqlP3kRrQDqWW4N1bDrOLHNfV7VxELANMN/dnyspv8rdl1foVwGYUU0baT+uw9OP96Xj\nOGKfsJeBn5hZcZVD0vFSM/sycI67v1+mHxvckiXLWbz444Y8dktLX1pb+7NkyXLa2to7r9DDNVM8\nzRQLKJ6erJliAcXTk2Wx9AZ5E63slSm3+/nZREJT7mzErmrj3HS8u5ryabTr5PTj9CrbGE+MzD3l\n7m+k27LpSkv/yvkcsebrwwr3b3Btbe2sWdPYN1d3tNGdmimeZooFFE9P1kyxgOKR+uRNtBYQ2ygM\nJPaQAj7ZxNSItVv319mnbN+s4qk8zGwn4HRgFXBL0V0L022tZrZ5ySVwzgO2BWa5+wudtZF8jZL9\nuNz9SuIyPusws8OINVvz3L3Ty/WIiIjIxiXvarI5xIak52U3pB3SbyNGiS6pVNHMjjSz9vRvXBVt\nnJltFppGpu4EtgRudPe3s8Lu3kZaS8XaES/M7ADg28So1eUlbTyejmPMbGBRnWuJMxznUN3I3H7p\n+FyHpURERGSjlHdEawqxE/pl6TqBC4HPA/2BSe4+u4O6I9KxAPyig3LTiK0cDgGeN7Pn0/8HEeus\nJpepcz2xker3zOyLxLUNjyWSv3NLRrNw99fNbDpwEvCsmT0K7EkkTg6cUWbX+3KysxOVaImIiMh6\nco1oufszwHHAE8TZdocRoz/HufsNnVQfQSRZC9ImopXaWAYcQZzltzNxXcX3gAvc/cSSM/6yOvcT\nO70/RyxkH0EsZB9VtN9VqbOBm4mk7AQiWbwOGOnu73QSS+ZPiGROiZaIiIisJ++IFu7+MDVcNNrd\nT81R9i1iUXqex5/OugveOyu/gpjqrDjdWcVj1HXxbBEREWluvWfHLxEREZFeRomWiIiISIMo0RIR\nERFpECVaIiIiIg2iREtERESkQZRoiYiIiDSIEi0RERGRBlGiJSIiItIgSrREREREGkSJloiIiEiD\nKNESERERaRAlWiIiIiINokRLREREpEGUaImIiIg0iBItERERkQZRoiUiIiLSIEq0RERERBpEiZaI\niIhIgyjREhEREWkQJVoiIiIiDaJES0RERKRBlGiJiIiINEi/Wiua2VbAJGA8sCvwEXAvMMndl3ZN\n98DMJgATgL2AduARYKK7v1qh/M7AN4CxwCDgfeCnwNXuvqZCnaOAy4DhwFbA86n8rDJlLwaOBPYG\ndgY2Bd4E7gKmuPuyWmMVERGR5lLTiJaZ7Qg8CVxJJD8z0/GrwNSu6pyZTQX+iUjkZgHziQTqITNr\nLVN+T+Ap4CJgEXA/kThdCdxcoY2LgNnAEcDc9O9AYIaZHVxStj/wXeBw4IPUp4dS/76V2hMREREB\nap86vJ0Y0bnZ3fdx91OA/YCFwBgzG1pvx8zsCuAU4DFgj9TG/sCDxEjVOSXlNwHuBgYDl7r7CHcf\nD3wOWA182cy2K6lzCDCFGPUa5u7j3P1o4GpitO+ykm5tRiRZO7r7aHc/w93HEqNtHwGHm9nIemMX\nERGR5pA70TKz44ExwDPApdnt7r6YGNkCGFVPp8xse+AqYBlwejYV6e4F4CdAnzJtTACGAve5+01F\n/XoNeJxInEqToCnEc3Chu79cdPvt5eJw94/cfW7qR/HtC4Cn048Dc4QqIiIiTayWEa3LgQKxHqlQ\nct+7RBI0uM5+XQxsAUxNSUxpG5RpY2Lq141lHm+9OmY2mpgifN3df1ah/PZm1uk6NjPrC+yZfnyl\ns/IiIiKycciVaKWF5qOAFcA9ZYpsRiQ7LXX26+T0OHdUaIPiNszsQGA34C13n1NNHeDUKtoorbMe\nM9scuBX4FPCQu7/UUXkRERHZeOQ96/AEIjl7zN1Xmtk1wDHAV9z9RSBbA7Wo1g6Z2e7E+q8/AE+Y\n2TjiLMLvuvu0Cm18IR1np8f4PvAZ4Cx3f7dCnbHp+KCZ7QH8EHjS3a8oKr/C3VeW6eO3gSHATsAI\nYAdgDvDnNQUtIiIiTSnv1OFIYhToETPbApgMHAxckO7fKx1/W0efsnVUc9N2DN8kpvgmd9BG1q9H\nzWwf4HxiC4Yzy9UxsyFEorQSmEes7zoMmJjOqKwYR5pKvBQ4m1irtj1xRuNod3+/tpBFRESkGeUd\n0RqWji+5+zIzm0aMaN1jZn2AfdP9T5etnbONdLwDMODH6eehRFL1dJk6LwKvAg8TI1ozzWwHYoH6\nGmIBf3F5d/d2M7uXSJzmuvuHRWdNrhdHSv76m1kLsDuxrcPXgAHAuTXE221aWvrSr19j9qhtaem7\nzrG3a6Z4mikWUDw9WTPFAoqnJ+tNMeRNtHZJx1cA3P307A4zGw5sDSyqtJlojjYKRW3cSqyByhad\nH5rKzUu3bU5M9RWAV9x9NXBUUb9OSv99wd1XVIhjLuueLTg6Pd68Sp109zbgFTM7CzgEONvM/s7d\nvYaYu0Vra38GDNiy4W00k2aKp5liAcXTkzVTLKB4pD55E60B6VhuDdax6TizzH1d1cZBwDbAfHd/\nrqT8KndfXqFfBWBGNW2k/bgOTz/e11ln3X2VmT1HnNG4N9BjE60lS5azePHHDXnslpa+tLb2Z8mS\n5bS1tTekje7UTPE0UyygeHqyZooFFE9PlsXSG+RNtLJXZkWZ+84mEppyZyN2VRvZ1Nzd1ZRPo10n\npx+nV9nGeGJk7il3f6OaDhPrtCAW8PdYbW3trFnT2DdXd7TRnZopnmaKBRRPT9ZMsYDikfrkneTM\n9rRaZ1POtImpAb9293ovQ1OpjZ2A04FVwC1Fdy1Mt7WmxKrYecC2wAPu/kJnbSRfo/J+XOsxs/2J\nMw9XEpclEhEREQHyJ1pziA1Jz8tuMLNPA7cRo0SXVKpoZkeaWXv6N66KNs7MNgtNCdSdwJbAje7+\ndlY4rZXK1lJ9shjdzA4Avk2MWl1e0sbj6TjGzAYW1bmWOMNxDkUjc2Y2KT1eaUwHAv+e+nuDu/fo\nES0RERHpXnmnDqcApwGXpesELgQ+D/QHJrn77A7qjkjHAvCLDspNI7ZyOAR43syeT/8fRKyzmlym\nzvXERqrfM7MvEtc2PJZI/s4tGc3C3V83s+nAScCzZvYosbP7fsQaqzNKdr3/OvC3ZvYa8CyRvBkw\nPMXzA3e/uoOYREREZCOUa0TL3Z8BjgOeAA4g9p6aAxzn7jd0Un0EkZQsSJuIVmpjGXAEcC+wM7FX\n1XvABe5+oruvN7GcpitPBZ4jFrKPIBayj3L3uyo0dTax/9VqYiPW/sB1wEh3fycrlLat+Dvg58Qu\n8ccSCdoOwF3AUe7+vzuJXURERDZCeUe0cPeHqeGi0e5+ao6ybxGL0vM8/nTWXfDeWfkVxFRnxenO\nVK5AjORNydMfERERkd6z45eIiIhIL6NES0RERKRBlGiJiIiINIgSLREREZEGUaIlIiIi0iBKtERE\nREQaJPf2DtI7tbetwf3lmuruu+9+bLrppl3cIxERkeanRGsj8fFH7/LP9y9g6yfzXSVo6e/mc/0l\nMGzY8Ab1TEREpHkp0dqIbL39rmw7cI8N3Q0REZGNhtZoiYiIiDSIEi0RERGRBlGiJSIiItIgSrRE\nREREGkSJloiIiEiDKNESERERaRAlWiIiIiINokRLREREpEGUaImIiIg0iBItERERkQZRoiUiIiLS\nIEq0RERERBqk5otKm9lWwCRgPLAr8BFwLzDJ3Zd2TffAzCYAE4C9gHbgEWCiu79aofzOwDeAscAg\n4H3gp8DV7r6mQp2jgMuA4cBWwPOp/KwyZXcHzgKOAfYBtgQWAP8GXNuVsYuIiEjvVtOIlpntCDwJ\nXEkkPzPT8avA1K7qnJlNBf6JSORmAfOJBOohM2stU35P4CngImARcD+ROF0J3FyhjYuA2cARwNz0\n70BghpkdXFK2D/AMcBWwC/AQcB/QH7gEeNjMNq0nZhEREWketU4d3g7sDdzs7vu4+ynAfsBCYIyZ\nDa23Y2Z2BXAK8BiwR2pjf+BBYqTqnJLymwB3A4OBS919hLuPBz4HrAa+bGbbldQ5BJhCjHoNc/dx\n7n40cDUx2ndZSbf2BB4ADnX33dz9pNTGZ4CXgM8CZ9cbu4iIiDSH3ImWmR0PjCFGdi7Nbnf3xcTI\nFsCoejplZtsTo0bLgNOz6Th3LwA/AfqUaWMCMBS4z91vKurXa8DjROI0sqTOFOI5uNDdXy66/fZy\ncXgY7+5Pltz+B2Ba6lfdSaaIiIg0h1pGtC4HCsCUlPgUe5dINgbX2a+LgS2Aqe6+oEwblGljYurX\njWUeb706ZjaamCJ83d1/VqH89mZW7Tq2T6X2l1RZXkRERJpcrkQrLTQfBawA7ilTZDMi2Wips18n\np8e5o0IbFLdhZgcCuwFvufucauoAp1bRRmmdssxsCHBG+vG/OysvIiIiG4e8Zx2eQCRnj7n7SjO7\nhjj77ivu/iKQrYFaVGuH0ll9ewN/AJ4ws3HEWYTfdfdpFdr4QjrOTo/xfWLd1Fnu/m6FOmPT8UEz\n2wP4IfCku19RVH6Fu6/spL99gB8TI3D/4+5KtERERATIP3U4khgFesTMtgAmAwcDF6T790rH39bR\np2wd1dy0HcM3iSm+yR20kfXrUTPbBzgfOBI4s1ydNAI1BFgJzCPWdx0GTExnVOaJ43rgaGA58BfV\nhSgiIiIbg7yJ1rB0fMndlxELwBcB96SRnX3T/U/X0adP2kjHO4ClxKgRxGLzQkkbWZ0XgVeBh4F3\ngIabHxYAACAASURBVJlmtgMwEGgjFvAXl3d3byf2//oAmOHuH7J2QXuHcZjZpcQJAauAU939hWqD\nFBERkeaXd+pwl3R8BcDdT8/uMLPhwNbAokqbieZoo1DUxq3AramNvsChqdy8dNvmxFRfAXjF3VcD\nRxX166T03xfcfUWFOOYSyVhmdHq8eZU6aWZ/CdxAjGSNd/f/qCHWXqGlpS/9+nWck7e09F3n2Ns1\nUzzNFAsonp6smWIBxdOT9aYY8iZaA9Kx3BqsY9NxZpn7uqqNg4BtgPnu/lxJ+VXuvrxCvwrAjGra\nSPtxHZ5+vK9cB83sSuBvgMXAF9z98fKhNIfW1v4MGLBl1WWbSTPF00yxgOLpyZopFlA8Up+8iVZ7\nOq4oc9/ZREJT7mzErmrj3HS8u5ryabTr5PTj9CrbGE+MzD3l7m+UecwbiOnCd4D/tTFMFy5ZspzF\niz/usExLS19aW/uzZMly2traOyzbGzRTPM0UCyienqyZYgHF05NlsfQGeROtBcQ2CgOB32c3pk1M\njVi7dX+dfcr2zSqeysPMdgJOJ9ZD3VJ018J0W6uZbV40PQhwHrAtMKskISrbRvI1yuzHlaYt/xn4\nErF+bIy7v50jrl6rra2dNWuqe1PmKdsbNFM8zRQLKJ6erJliAcUj9ck7yTmH2JD0vOwGM/s0cBsx\nSnRJpYpmdqSZtad/46po48xss9A0MnUncQHnG4sTHHdvY+1aqmzECzM7APg2MWp1eUkb2VTfGDMb\nWFTnWuIMxzkUjcyZ2WbA/yOSrDnAqI0lyRIREZHa5R3RmgKc9v/bO/cwq6ojb79cRFTAC0ZQ8zkx\nBkslQEBUokTQKJKIMUbUz0R9IiNxorkNXkATNRcnTtSEmDi5TZyJmERRM2YU5lOHqCiKTDTeiaWj\nJqigBm+ACgr090etbW9O73O6Tzenezf+3ufpZ/XZe62zqs6+1a5VqxZwVloncDlwKLGo8gx3v7VG\n29GpbAL+p0a92UQqh/2BR8zskfT/jkSc1fkFbS4mEqn+2Mw+TaxtOIEw/k6uHN5z96fN7HrgaOAh\nM7uTWMdwGODAZyuy3n+DyNW1jhgynGlmlTI84e4X1dBLCCGEEO8x6vJoufuDwGHAPcAoIvfUAuAw\nd7+kleajCSNraUoiWq2PN4HxRMqFQcS6ii8Ap7n7USkdQ2WbuUSm94eJQPbRRCD7WHe/ukpXJwGX\nEUbZJMJYvAgY4+7PV5G9J7HQ9UkFf7vUVl8IIYQQ7zXq9Wjh7nfQjkWj3f24Our+lQhKr+f7r2fD\ngPfW6q8mhjqrDnfm6n6iHlmEEEIIIaB9i0oLIYQQQog2IENLCCGEEKJByNASQgghhGgQMrSEEEII\nIRqEDC0hhBBCiAYhQ0sIIYQQokHI0BJCCCGEaBAytIQQQgghGoQMLSGEEEKIBlF3Znjx3mL9urW4\nP95qvV69ejJgwBasWPEW69bFKklDhw6jT58+jRZRCCGEKC0ytERN3nhtGVfMXUr/e1fV1W7ly0u4\neBqMHLl3gyQTQgghyo8MLdEq/QfuwjaDh3S1GEIIIUS3QzFaQgghhBANQoaWEEIIIUSDkKElhBBC\nCNEgZGgJIYQQQjQIGVpCCCGEEA1ChpYQQgghRIOQoSWEEEII0SBkaAkhhBBCNAgZWkIIIYQQDUKG\nlhBCCCFEg2j3Ejxm1g+YAUwGdgFeA24AZrj7yo0jHpjZVGAqsAewHpgPnOnuT1apPwg4FzgC2BF4\nEfgNcIG7r63S5mDgLGBvoB/wSKp/c0Hd3sDRwH7AGGAksDnwDXf/bvs1FUIIIcSmRrs8Wmb2PuBe\n4BzC+JmTyi8C12ws4czsGuDnhCF3M7CEMKBuN7MBBfV3B+4DvgS8AswlDKdzgMuq9PEl4FZgPLAw\n/e0D3GhmHy1oMgK4GvgqYWxtBjQBD7ZTTSGEEEJsorR36PBKYE/gMnffy92PBYYBy4GJZja8o4KZ\n2XTgWOAuYEjqYwQwj/BUfb6i/mbAtcBOwBnuPtrdJxPG0DvAKWa2XUWb/YGZhNdrpLsf6e4fBy4g\nvH1nFYjWL7U5Bng/sCptf6ijOgshhBBi06JuQ8vMPglMJDw4Z2Tb3f1VwrMFMLYjQpnZQOA84E3g\n+Gwo0t2bgF8DPQr6mAoMB25y9x/m5HoKuJswnMZUtJlJ/Aanu/vjue1XVtPD3ee7+xnu/h/EkOEA\n4BV3f749ugohhBBi06U9Hq2ziaGymcnwybOMMIJ26qBcXwa2BK5x96UFfVDQx5lJrksLvq9FGzMb\nRwwRPu3uv69Sf2CKyarGiFTKmyWEEEKIFtRlaKVA87HAauC6giqbE8ZOrw7KdUz6nllV+iDfh5nt\nA3wA+Ku7L2hLG+C4NvRR2aYSGVpCCCGEqEq9sw4nEcbZXe6+xsy+CRwCnOrujwFZDNQr7RXIzHYj\n4r9WAfeY2ZHELMIfuPvsKn18KpW3pu/4GfAh4ER3X1alzRGpnGdmQ4BfAve6+/Rc/dXuvqaGuCMI\nY02GlhBCCCFaUO/Q4RjCsJhvZlsC5wMfBU5L+/dI5bMdkCmLo1qY0jF8nRjiO79GH5lcd5rZXsAX\ngIOAE4ramNnOwM7AGmAREd/1MeDMNKOyrXrIoyWEEEKIqtRraI1M5WJ3fxOYTXiJrjOzHsDQtP/+\nDsj0bh+pnAWsBH6VPg8njKr7C9o8BjwJ3AE8D8wxs+2BwcA6mlMwZPXd3dcT+b9eAm5097+lPmrq\nYWZbAbsSMxofq0dBIYQQQrw3qHfo8P2pfALA3Y/PdpjZ3kB/YgZeYTLROvpoyvVxOXB56qMncECq\ntyht60sM9TUBT7j7O8DBObmOTv8+6u6rq+ixkDDGMsal71tUQ87hROD/49USob7X6dWrJ717d8/F\nB3r16rlB2Z3ZlHQB6VNmNiVdQPqUme6kQ72G1rapLIrBmpDKOQX7NlYf+wJbA0vc/eGK+m+7+1tV\n5GoCbmxLHykf14Hp40015NSwYSsMGLAF2267VVeL0SEGDNiiq0XYaGxKuoD0KTObki4gfUTHqNfQ\nWp/K1QX7TiIMmqLZiBurj5NTeW1b6idv1zHp4/Vt7GMy4Zm7z92fqSGnAuFbYcWKt3j11Te6Wox2\n0atXTwYM2IIVK95i3br1rTcoMZuSLiB9ysympAtInzKT6dIdqNfQWkqkURgMvJ5tTElMjYjdmttB\nmbK8WfmhPMxsB+B44G3gR7ldy9O2AWbWNzc8CDAF2Aa42d0fba2PxNeono8rT+bR0tI7Baxft5bF\nixe362IeOnQYffr0aYBU9bNu3XrWru3eN6SMTUkXkD5lZlPSBaSP6Bj1GloLiADwKcB0ADPbFfgp\n4SWaVq2hmR0E/CF9PMrd/7NGHycDJ5jZFe6+NnmmrgK2Ai5y9+eyyu6+zswWEfm9Tk6yYGajgAsJ\nr9XZFX3cncqJZjbY3V9Ibb5FzHC8ixqeuRQrNix9lEergDdeW8YVc5fS/95VrVfOsfLlJVw8DUaO\n3LtBkgkhhBCdR72G1kzg/wJnpXUClwOHAlsAM9z91hptR6eyCfifGvVmE6kc9gceMbNH0v87EnFW\n5xe0uZgwtH5sZp8mZgJOIIy/kyu8Wbj702Z2PXA08JCZ3QnsThhPDny2Muu9mU0Avp3k700YfU3E\nzEZSX+NTML4A+g/chW0GD+lqMYQQQoguo66wfXd/EDgMuAcYReSeWgAc5u6XtNJ8NGGYLE1JRKv1\n8SYwnki5MIhYV/EF4DR3PyqlY6hsM5fI9P4wEcg+mghkH+vuV1fp6iTgMsIom0QYixcBY6qsWzie\n8HbtS+ieGWL7pr/tZWQJIYQQIk+9Hi3c/Q7asWi0ux9XR92/EkHp9Xz/9WwY8N5a/dXEUGfV4c6K\n+ucSGeqFEEIIIdpE90lEIYQQQgjRzZChJYQQQgjRIGRoCSGEEEI0CBlaQgghhBANQoaWEEIIIUSD\nkKElhBBCCNEgZGgJIYQQQjQIGVpCCCGEEA1ChpYQQgghRIOQoSWEEEII0SDqXoJHiEayft1a3B9v\nV9uhQ4fRp0+fjSyREEII0X5kaIlS8cZry7hi7lL637uqrnYrX17CxdNg5Mi9GySZEEIIUT8ytETp\n6D9wF7YZPKSrxRBCCCE6jGK0hBBCCCEahAwtIYQQQogGIUNLCCGEEKJByNASQgghhGgQMrSEEEII\nIRqEZh2KTQLl3xJCCFFGZGiJTQLl3xJCCFFGZGiJTQbl3xJCCFE2FKMlhBBCCNEg2u3RMrN+wAxg\nMrAL8BpwAzDD3VduHPHAzKYCU4E9gPXAfOBMd3+ySv1BwLnAEcCOwIvAb4AL3H1tlTYHA2cBewP9\ngEdS/Zur1O8N/CNwIrAb8CZwS5LrhfZpKoQQQohNjXYZWmb2PuB2YE/AgTnA/sAXgQ8Ah28M4czs\nGuBY4CXgZsLYOgLY28z2cvcVFfV3B/4A7AQ8APwJGA+cA2wDnF7Qx5eAHwLvALcShtZBwI1mNs7d\nF1bU75tkORBYAswFRgKfBT5sZqPcff3G0F80nmpB9L169WTAgC1YseIt1q1reTgVQC+EEKIttNej\ndSVhZF3m7tMAzGxbwuiaaGbD3f3hjghmZtMJI+suYJK7rzSzHoTn6OPA54Ef5epvBlxLGFlnuPsP\n0/bdgMXAKWZ2nru/kmuzPzCT8Hp93NMT18zOA75FeLk+UyHaTMLIug44wd3fMbPNgfuAYcAk4MaO\n6C46j/YE0SuAXgghRFupO0bLzD4JTAQeBM7Itrv7q4RnC2BsR4Qys4HAecSQ3PHZUKS7NwG/BnoU\n9DEVGA7clBlZqc1TwN2EUTmmos1M4jc43Td0a1xZpIeZ7QV8AVgKTHH3d1IfawjDq0guUXKyIPq2\n/vUfuEtXiyyEEKKb0B6P1tlAEzAzGT55lhHGxk4dlOvLwJbAv7n70oI+KOjjzCTXpQXf16KNmY0D\n9gGecvffV6k/0Mx652K7zk7lz9z9jTbKJTYxlLNLCCFEW6nL0EqB5mOB1YQHp5LNCWOnVwflOiZ9\nz6wqfZDvw8z2IWLD/uLuC9rSBjiuDX1kbdamAPgj07Y2ySU2TZSzSwghRFup16M1iRhqu8vd15jZ\nN4FDgFPd/TFgu1TvlSrtWyXFVO0JrALuMbMjiVmEP3D32VX6+FQqb03f8TPgQ8CJ7r6sSpsjUjnP\nzIYAvwTudffpufqr07AgwDhga+AJd19iZqcCU4Cz3X3+xtBddB/ak7NLnjAhhHjvUa+hNYbwAs03\nsy2B89Pn04gZfXukes92QKYsjmqhu681s68Do1Nfs6v0kcl1Zy6Oqgk4Abikso2Z7QzsTHjmFgH/\nDHwMGGtml9boAyK9BMB3gO2J4cT5qU0THdNdbMK01xP2+t+eYeoRj2O2R+uVKxg6dBi9e/etu50Q\nQoiNQ72G1shULnb3N81sNuHRui7NCBya9t/fAZne7SOVswADfpU+DycMmvsL2jwGPAncQXi05pjZ\n9sBgYC0RwJ+v7+6+3sxuAE4ijLu/mdnwAj1Gpn4zuf4dOJUIzs/kqmzTEFa+vKTuNm++/gIhvtp1\ntF1H+tpy60F1t1u9cjk/nHULWw54oL7+VrzEtM9PZK+99qJfv76sWrWa9evrl7ts9OzZQ/qUlE1J\nF9j09Rk1qvuGMfTq1X3yrddraL0/lU8AuPvx2Q4z2xvoD7xSLZloHX005fq4HLg89dETOCDVW5S2\n9SWG7ZqIYb13gINzch2d/n3U3VdX0WMhYYxljEvft6hCrnyb6cD01Mf2xHDneuCPbVV01k++06Ot\ndYUQQgjR/ajXJNw2lUVxSBNSOadg38bqY18iTurZXJ6urP7b7v5WFbma2DC3VdU+Uj6uA9PHm9oo\n1yHEbMu73f21gv1CCCGEeA9Sr6GVpcheXbDvJMKgKZqNuLH6ODmV17alfvJ2HZM+Xt/GPiYTnrn7\n3f2ZOuRqqpBLCCGEEO9x6jW0spxW+WG2LImpAX9297kdlKlaHzsAxwNvk8sIDyxP2wYkwyrPFGLp\nnVvc/dHW+kh8jeJ8XNXk+jCRqf5lmuPIhBBCCCHqNrQWEENkU7INZrYr8FPC4zOtWkMzO8jM1qe/\nI6vVy/VxQspdlXmmrgK2Ai519+eyyu6+juZYqszjhZmNAi4kPFBZotGMu1M50cwG59p8i0hiuoCW\nnrlMrs/n6g9McvUAznX3N2voJYQQQoj3GD2amto+k8LMPkIYNZsRxspy4FBgC2CGu19So+1ZwPcI\nb9H7U36ronpbErMHdyECzx8hFqzekYizOrpy0WYzOzztayIWlX6HiM1aD5zs7lcX9HMtcHTS4U5g\nd2KtQgcOcffnK+rvSMw4HEDMXnyaCLrfBviJu3+5mu5CCCGEeG9Sl0fL3R8EDgPuAUYRuacWAIfV\nMrISowlDaGk1Iyv18SYwHrgBGESsq/gCcJq7H1VpZKU2c4lM7w8TgeyjiUD2sUVGVuIk4DLCKJtE\nGIsXAWMqjazUxzJiNuI8YAgRAP8YsRajjCwhhBBCtKAuj5YQQgghhGg73SfjlxBCCCFEN0OGlhBC\nCCFEg5ChJYQQQgjRIOpdgkdsBMysHzCDSI66C/AaEfw/w91XdkL/I4DPEZMODOgL/IVIVfG9tIxR\nZZuRwLnEEkjbEmtKXuLuV9XoZyowlVhwez2x+PaZ1ZZoMrNBqY8jiFmmLwK/AS5w97V16NebmH36\nMWCZu+/cHfUxs32IvG4HAjsQqxI8CHzT3RdV1C2tPmY2FjiDmD3cH1gC/J44114tqN+luhDXw1HE\nQvJjiNnIvYET3P23Vb6vlL+/mR1M3Gv2A7Ykcg72AXoV6ZNWxjgy6b8fsfTY28B9wHfdfV530qfK\nd3yEmNDVF7jI3b/ehfp8kpiENSTJk1HrXOtJpFg6ERhB6P88cBvwFXdf00W61H1s0r36NOAEYhm7\nt4HHgR+5++yifjpZn7OAvYF+RAaEC9z95mpyVUMerU7GzN4H3AucQ5wgc1L5ReCaTur/AeLBNwC4\nOf0NAr5NGHyVbY4ibkyfJmZ23kZa6NvMjqmsn9pcA/ycMCRvJh6uRwC3m9mAgvq7EzfzLxEGxVzi\n5D6HmB1aDz8kjKwmmhcS71b6mNk3iPPkKODPwO+AZ4jZrjt0F31SWpf5wCeSbHOIlChnA/ekdC5l\n0+Uw4ErgH4CPEEZW4blUIpmL+vgScCsxW3pA0mPLVvT5R2KFi88QD+/fJZ3GAbeY2bHdTJ/K7xhI\nGPmb12rTifrcBAwnZr33yP0VzlJL8i8AfgHsBvw3cAvxLD+6ipFVymOTHA7zifv1Tqn9/cRSe1eb\n2Xeq9NWZ+owHFqa/fYAbzeyjRW1qIUOr87mSsNwvc/e93P1Y4o15OZFAdXiD+x8B/Bsw3N33cPfj\n3P3IJNOLwCfM7JCsspntlmR+BzjI3Se6++HAKcQN4ZzKDsxsOnAscBcwJOk4gkiNsSO5pK+p/mbE\nzX0n4Ax3H+3uk4k3o3eAU8xsu7YoZ2YnE29I2ZvNgxX7S6+PmZ1OGL23Abu6+wR3/6y770+8+c7v\nDvqY2Xgid94LxPl2aOprCJGHbncil12pdCEeFP9M3LwtNV1DvGlX9l8KmSt/fzPbH5hJXNNnE16T\nw4mHGsTDr4U+xMoXXwUGu/s4d/+cu4/N6VO5YkbZ9cl/R8/U75bEKAIUGwCdqc9rhNF0OHFdZAZW\nCwPdzHoRhtm+6Tf4P+5+TEp7tBvxEtaVutR7bC4HPgpcDezm7ke7+wTihQVgWpKnK/UZ6e5HuvvH\nCW93b8LLVRcytDqR5CaeSFzcZ2Tb0/BJthj32EbK4O7z3P0Ud3+sYvsy4L/Sx7yxdxGRkf98d1+Q\n2/5b4kQdYWZbZRvTG9d5wJtEjrGV6fubgF8TN+tKHaemPm9y9+zixN2fIhLj9iaGcGpiZvsCPwH+\nnXgzgpY30lLrY2a7ABcTXoRJ7v5ifr+7/8XdV3QTff6BuMl+292fyLVbCdyePvYroS4vuvu57v5f\nxNAZwGIvyOFXIpkrf/+ZxP39dHe/LKfPwrS/qUgfd5/m7j9299crds1K+uycfzCVXZ8KLiU83VOA\nrYE3KoeaukCfv3f3UyvONQr6gHhmjAHOc/dLk0zv4pHnsit1afOxMbP+xJJ6a4FTPeeJ88iL+Q7h\ndezTxfrkDcQrU1n3M1qGVudyNvHgmVl5kQDLiBNlp06XqpnsQl8BYLG80meAlcRb17t4LH20PH3c\nMbfry8Qb4zXuvpQNyRLVVup4JsXrS9ZqswEWa2FmwxxfJMbVIYZJszrdQZ9ziFiNr3nBMECebqDP\n36XymYJ9mTG/EEqty4hUFnk+SimzmY0jhjmedvffV9TP4hV7pfiYtjKIWBFkPbAqt71b6GNmnyPi\nHacTx6Unca+opCv1GZH7f2BeH4tl6M4GniK8xG2hzMdmJ+J8Wu7u+fMJM9sr7XvY3d8okT5Z/YF1\nXjsKhu8sLILxxhJrL1auowjNMQO9OlOuDDMbTbPrOfM2HEPckH7nxes4bp7KvMzHEHrMakt9i4Dv\nDwB/qfAI1OqjUvbewPXExXlUKj8ErHL3/62QrbT6pHilzxKLs99hZpOAgwjD637gt+6+urvoA/wv\n4aKfTMQ7ZN85g7iZ/SL3Fl5WXUakPh4qqF9WmY+r0cfI3P+9CI9CW5iRynvc/e3c9tLrYzFR4RfE\n9TPTzE5Lu4ris7pSn+xcK9LnGGA7wsja2sxOJALBVwJz3P2ukukCtY/Nc8Rw/CAzO8Dd704ybA/8\nK+HR+mrJ9Nk89389144MrU5kEnFTvsvd15jZNwnD5lSPYbzMHf9KZwtmZlsQw20QD42n0v9HECfd\nPIsg+qsIq34K4X3bOtV7JX3PbkSs1yoi0PlIYqbHDzxmkBTp+KlU3pq+42eEkXSix3BmW36Xy4gH\n+iHuvtTMDkjyPVJRr+z6TCRm5d1uZrcQ64hmN94ewJfNbL/cg67s+lyUdDrFzPYj4jQ+THhOv+3u\n38zVLasumZehyNAqq8xHpHKemQ0Bfgnc6+7TieB+gDWteUwzUqzdaUnX7+W2l16fNNx0A7GG7Slp\n80gKArS7Wh829GitrtAnMzJeJa6j7dP2HsBZZnaOu3ebY+Pub5jZBcQ94jYzy9YoHgu8RNzL3zUe\nS6JPVr/y2LSKhg47jzHEhTI/eS7OJwIBs7erPVL5bBfIdiUwlHCpfwXeDbzMht/mExf6BGKNyNHE\nCdsLeIvmIZJsrHuhx5TZrxOei/PT9iIds9/lzuQy/gLhxTmhRpt3MbMpxFDhmbkLc1QqH8zV6w76\nfDyVxxEu8pGpHA8sJYbbvtpd9HH3xYSH7lXCwJpMBJf/hAg2p8y6JLn2Sts2MLRKLPPOxJDNGmAR\nEaPyMeDM5FW3fP3WSMOj1xIP9N+m2Ju8bKXVJx2j64g4wKNy3uAW94cy6EPzubZBH0mPccSw7UXA\nz4jh6O1onmxxgZnlY7xKfWwSM4mX5N7ETN9JxPVyRoGHrqv1eV+VPtqEDK3OI3OjLk7DDLMJS/o6\nM+tBGDrQHMTdKZjZj4kH4OtE8PULadeexJDV62k8/Fbgr8QJ+AjNMTYP5eLN3tUxlbMI1/av0ufh\nxImf1zFr8xgxU/AOYlr5nORGHgysozhGZj/gX4BZ7v7j3K5RqZ8HcttKrw/ND+5VwAR3f8jd16Sb\nzj8RD7tx3UEfM+tvZv8JXEEYH1sRMVtXEnEyc3LVy6qLEcMFS7xlcHhZZc7qewpAvoHwENwIDCSG\n1QH+SCuY2eCk18DU79SKKmXX5/vEg/I4d/9r0mkz4l67jpYe767U53biXMtmQ+b7GEJ4unsCV7j7\nBe7+kru/nrxYf0xt80HdpT42FjP7niGG9vYkXigPJALd56Sh0Txdqo+7/43ma7ruZ7SGDjuP7G3j\nCQB3Pz7bYWZ7ExfSK14l4VojMLPvA6eTUku4+59yuzN5nwRIsU675tpmD/xFFW2aaNbxcmIKbza1\n+oB8mxTguV3WxiNR6sG5PrKp/49WxCZlMW/XExfRqRWqFb2xllqfrEpq+0/u/lbFvuy8yAI3S6tP\nenG4lXjj3Dd3Xj1nZl8gjMWDzGxsip0oqy61hg3LKnPlfWYh8UDBzI4njPVKuVpgMbnkNuCDRK6i\nowvO2dLqkx7UXwGmu/sfcruGETPZHisY/ukyfZIuBxMJO5sq9Mk8Q6vIeYJzPEl4UfOB4GU+Nh8h\nEkovdvfP5HbdbWanpn0XEEPxpdAnMY6Wx6ZNyNDqPLZNZVEsy4RUzinYt9FJD8KfEAbKs8BhvuE0\nVqgtLzTHD93Uxjb7EjErS9z94Yr6bxcYFhC/SxPxhlTJFMLN+zfg92aW37dnKi82s9XEuHup9UnD\nA1un/bcVtM1mrmXDUGXW53AiZu6/K4x33H2dmf2JMEqGEskXy6pLrUD4sspcq4/sjb1Srg2wSDEy\nj0iIORs4yYuzZ5dZn28QwcoHW2T4zsiS/Q4ys/8HzHP375dAn+xcy/bn9cnisR5099doSeW9oVY/\n0PXH5jzC2C2aCZgZMbua2eY5Y7hL9Ume0APTx6rXTjVkaHUeWR6RIk/GScRBL5qNuFGxmKF3FREH\ntJgwsp4vqFpVXjMbQySbfJFc8sxabYCTU3ltG/voS3PSvusLvi9zFY8o2Jcxnpimu97Myq5PfkbL\nkoL9mZfunjb01dX6ZG+Xiykme3BkQf1l1aWWR6usMtfqI3uhe8rdi1JuYGZ7Et7InYDL3b1y5lee\nUupjMbnng8RQ24SCdk3E0NYEIpdSW/pqtD4jCA9QH+C+iuOT3Rta3BfS/TwLO1mY21XKY5PYP5VF\n94fs3tBEBMe3pa/O0GcyMepUeWzahGK0Oo8s70feFYlFElMjpvTPbaQA6QZ0E2Fk3QUcUMXIgiry\nJqbRnA8sn4iumo47EMnp3gZ+lNu1PG0bkE7+PFOIpVpucfdHKwVw9+PdvVflH5EZuAcwO20bdRlr\nLQAABEpJREFU0k30eRPIcsYMquivP3EzaSKyKJddn+y+UrQcxg7EMAfETKsy61I1h1aJZa4lVxZs\nXW3ZkX2J+8KOxLqrtYysqn11tT7u/pa7b1bl/nBHqvaJtO3CkuiTGVpFOZ9eSuUgWnIC4aVbVGEA\nlPLYJKreH4iAeAiDpkzXzteono+rVWRodR4LiAtpSrbBYkbPTwlLelojOzezbYix7wnAfwCHessA\n3zz3E5b9aDPL3pgws78nrPsnSWPkOTIdT0hvWtnbw1VEMPSl7v5cVtkjqWPmKs7eSjCzUcCFqf+z\n61R1GHFBVAa6dgd9bkv9vVvHzDYnAj77A1e5u3cDfbI2k81sj1y7bYhg+H7AXHf/c1l1STfwwUQu\ntqcLdCydzInMQzPRIpg9a3MJEZy8jphAsgEWy27NI47NSe5+SYHOlZRWnxoMS2Xl/aHL9EnnWjb8\nt4CWIxt3Et6d8Ra5obJ+hhKrSDQRs/C6XJfUprVjsyjJdraZ5TO/H0AsPdaU9CqLPt8i4k2Ljk2b\n6NHU1NR6LdFhUgDgIuIEvJuwuA8lFhOd0cYbW0f6vwr4HDF99nqa3aR57nb3X+baXEws+7CSMAIG\nEzNblhGz4jZYxscibcVjxGKfTxA3s/2Jm8iNREBt5VIMh6d9TYQh+A5hDK4HTnb3q6kDM7uZ+F0/\nVekhLLs+Futc3kOcEw8SD+v9iVi0hcQw7xu5+qXUJwWnziOCR9fQbEDuR8RBPEAY+q+WSRdiiCab\nWLEVkZJiNc1Dhy+7+6Tc93W5zFV+/2uJNSRXEXFKfYlZXSR9Mg/dy+4+KXm6XyXuTX+m+ozE7+Vj\nOcuqTxXZsZhAs4zIRr5Dwf7O1Gdy0mVl0qUvzTOl367UxcwuJFI5vE1cWz2IPIybEaltZnahLnUd\nm3Sfu4sw6pcQ59v7CWOmJ/Ad3zDHXlfos5wwcHcnjHMncntVGwGqiQytTsQi8d+FRKDgW8SK4pe6\n+7xO6PvPxElTi3N9w6R3PYig0pOJE/oFImD/Im+5BELW5u+IadUHEzGATwD/6u4/ryHbZCL53J5E\nmom7Ux/3tU27Db7rOeKBt6u7P1uxr/T6pJvQt4lp6VsQS27MIoah1lbULa0+6U11OjFM/UHi7fZx\nYg3Af/ENs4uXQhcz+22Stxrz3P2wMslcpX5f4LvEWpNbpM1NbJh1/F19LNKk3ENtmoCdvWLtzTLq\nU6PfQ4BbgNvdvcUCzJ2szwM052Uq0qeFLmY2lci7aIQRcy9wsbvf0cW61H1szMyIHFgHEfFyrxHn\n4GUl0efYJNezhBfr4lZGgGoiQ0sIIYQQokEoRksIIYQQokHI0BJCCCGEaBAytIQQQgghGoQMLSGE\nEEKIBiFDSwghhBCiQcjQEkIIIYRoEDK0hBBCCCEahAwtIYQQQogGIUNLCCGEEKJByNASQgghhGgQ\nMrSEEEIIIRqEDC0hhBBCiAbx/wGUrf4eGjfikwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "population = np.random.exponential(scale=1000, size=500000)\n", + "\n", + "# Plot the population\n", + "count, bins, ignored = plt.hist(population, 30, normed=True)\n", + "\n", + "plt.title('Distribution of the population')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "population = pd.Series(population)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Do a bunch of simpulations and track the percent of the time the error bars overlap the true mean\n", + "def bootstrap_vs_pop_mean(population, num_samples, is_pivotal, num_loops=3000):\n", + " population_mean = population.mean()\n", + " pop_results = []\n", + "\n", + " for _ in range(num_loops):\n", + " samples = population.sample(num_samples)\n", + " result = bs.bootstrap(samples.values, stat_func=bs_stats.mean, is_pivotal=is_pivotal)\n", + "\n", + " # we want to 0 center this for our power plotting below\n", + " # we want our error bars to overlap zero\n", + " result = result - population_mean\n", + "\n", + " pop_results.append(result)\n", + " return pop_results" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def bounds_squared_distance(results):\n", + " '''The squared distance from zero for both the lower and the upper bound\n", + " This is a rough measure of how 'good' the confidence intervals are in terms of near misses vs extreme misses.\n", + " \n", + " It is minimized when (1) the confidence interval is symmetric over zero and (2) when it is narrow.\n", + " '''\n", + " return np.sum([r.upper_bound**2 for r in results]) + np.sum([r.lower_bound**2 for r in results])\n", + "\n", + "def squared_dist_ratio(x, y):\n", + " 'Compare bounds_squared_distance for two sets of bootstrap results'\n", + " return bounds_squared_distance(x) / bounds_squared_distance(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pivotal vs Percentile for very small input sample size - 10 elements" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pivotal_tiny_sample_count = bootstrap_vs_pop_mean(population, num_samples=10, is_pivotal=True)\n", + "percentile_tiny_sample_count = bootstrap_vs_pop_mean(population, num_samples=10, is_pivotal=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.98990672011763114" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "squared_dist_ratio(pivotal_tiny_sample_count, percentile_tiny_sample_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 84.933\n", + "Negative 52.533\n", + "Negative Significant 13.400\n", + "Positive 47.467\n", + "Positive Significant 1.667\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAFxCAYAAAC/TZhjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# more insignificant results is better\n", + "print(bs_power.power_stats(pivotal_tiny_sample_count))\n", + "bs_power.plot_power(pivotal_tiny_sample_count[::20])" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 84.833\n", + "Negative 54.800\n", + "Negative Significant 13.100\n", + "Positive 45.200\n", + "Positive Significant 2.067\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAFxCAYAAAC/TZhjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# more insignificant results is better\n", + "print(bs_power.power_stats(percentile_tiny_sample_count))\n", + "bs_power.plot_power(percentile_tiny_sample_count[::20])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pivotal vs Percentile for small input sample size - 100 elements" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pivotal_small_sample_count = bootstrap_vs_pop_mean(population, num_samples=100, is_pivotal=True)\n", + "percentile_small_sample_count = bootstrap_vs_pop_mean(population, num_samples=100, is_pivotal=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.98164440864935931" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "squared_dist_ratio(pivotal_small_sample_count, percentile_small_sample_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 94.067\n", + "Negative 50.600\n", + "Negative Significant 5.133\n", + "Positive 49.400\n", + "Positive Significant 0.800\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIrn4/7RrnbGZDRh8AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(bs_power.power_stats(pivotal_small_sample_count))\n", + "bs_power.plot_power(pivotal_small_sample_count[::20])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 93.033\n", + "Negative 51.667\n", + "Negative Significant 5.067\n", + "Positive 48.333\n", + "Positive Significant 1.900\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAcX7SQf8Xqq8AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(bs_power.power_stats(percentile_small_sample_count))\n", + "bs_power.plot_power(percentile_small_sample_count[::20])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pivotal vs Percentile for medium input sample size - 1000 elements" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pivotal_med_sample_count = bootstrap_vs_pop_mean(population, num_samples=1000, is_pivotal=True)\n", + "percentile_med_sample_count = bootstrap_vs_pop_mean(population, num_samples=1000, is_pivotal=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0030288836327641" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "squared_dist_ratio(pivotal_med_sample_count, percentile_med_sample_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 95.133\n", + "Negative 48.267\n", + "Negative Significant 2.933\n", + "Positive 51.733\n", + "Positive Significant 1.933\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkVwoCBEREZFc/H8tVPc1jlGerAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(bs_power.power_stats(pivotal_med_sample_count))\n", + "bs_power.plot_power(pivotal_med_sample_count[::20])" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Percent\n", + "Insignificant 94.900\n", + "Negative 51.167\n", + "Negative Significant 3.200\n", + "Positive 48.833\n", + "Positive Significant 1.900\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nREREJBMKQkRERCQTCkJEREQkE/8fi6peUa6ExYUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(bs_power.power_stats(percentile_med_sample_count))\n", + "bs_power.plot_power(percentile_med_sample_count[::20])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pivotal vs Percentile for somewhat large input sample size - 10k elements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bad Populaiton" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "bad_population = pd.Series([1]*10000 + [100000])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAGBCAYAAADbp+3kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the population\n", + "count, bins, ignored = plt.hist(bad_population, 30, normed=True)\n", + "\n", + "plt.title('Distribution of the population')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean:\t\t10.99890011\n", + "Pivotal CI:\t10.9999 (-8.9999, 20.9998)\n", + "Percentile CI:\t10.9999 (1.0, 30.9997)\n" + ] + } + ], + "source": [ + "samples = bad_population.sample(10000)\n", + "print('Mean:\\t\\t{}'.format(bad_population.mean()))\n", + "print('Pivotal CI:\\t{}'.format(bs.bootstrap(samples.values, stat_func=bs_stats.mean, is_pivotal=True)))\n", + "print('Percentile CI:\\t{}'.format(bs.bootstrap(samples.values, stat_func=bs_stats.mean, is_pivotal=False)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Analysis:** The correction from the pivotal method causes a negative lower bound for the estimate in this instance. Generalization: the pivotal correction may not always produce realisitc intervals. In this situation we know that the mean cant be less than one. Still, we have seen from above that the piovtal method seems to be more reliable - this is why it is the default." + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/power_calculation.ipynb b/examples/power_calculation.ipynb new file mode 100644 index 0000000..c303b34 --- /dev/null +++ b/examples/power_calculation.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": { + "collapsed": true + }, + "source": [ + "Copyright 2016-present, Facebook, Inc.\n", + "\n", + "All rights reserved.\n", + "\n", + "This source code is licensed under the license found in the LICENSE-examples file in the root directory of this source tree." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Power Calculation\n", + "\n", + "In this secion we take a look at experimental power of a planned experiment. Say we want to run an a/b test and we want to know if we improve things by 5% - will we be able to get a statistically significant result? We may waste a lot of energy and time in running a test that is unmeasureable!\n", + "\n", + "Power calculations let us run some simulations (simulated a/b tests) to see the fraction of times we should expect to see a significantly significant result. \n", + "\n", + "For this example, we keep things simple and apply a 5% lift uniformly. It is important that you do a good job at thinking about the lift your experiment will have. Is your estimated lift realistic? Are all members of your population impacted in the same way?\n", + "\n", + "See [this tutorial](https://signalvnoise.com/posts/3004-ab-testing-tech-note-determining-sample-size) for more information on why power analysis is important." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import bootstrapped.bootstrap as bs\n", + "import bootstrapped.compare_functions as bs_compare\n", + "import bootstrapped.stats_functions as bs_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def run_simulation(lift, data_size):\n", + " results = []\n", + " \n", + " # in real life you would use real data and then apply some hypothetical lift to it\n", + " data = np.random.normal(loc=100, scale=100, size=data_size) * lift\n", + " \n", + " # the more simulations you do the more confident you can be in \n", + " # the power calculation. 3k is a good heuristic.\n", + " for i in range(3000):\n", + "\n", + " # in real life you would use real data and then apply some hypothetical lift to it\n", + " \n", + " sel = np.random.random(len(data)) > 0.5\n", + " \n", + " test = data[sel] * lift\n", + " ctrl = data[~sel]\n", + "\n", + " results.append(bs.bootstrap_ab(test, ctrl, bs_stats.sum, bs_compare.percent_change)) \n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# If you arent suppressing warnings this will warn you about the size of your control and test population sizes\n", + "# These methods work when the sampled population is a good representation of the larger population. \n", + "\n", + "# We reccomend at least 3k samples in test and in control. This is a completely arbitrary number \n", + "# but it should be good enough for many situaitons. \n", + "\n", + "test_results = run_simulation(lift=1.1, data_size=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import bootstrapped.power as bs_power" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAFxCAYAAAC/TZhjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiKSCwotIiIikgv/H7AiyTO2DpOoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bs_power.plot_power(test_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAFxCAYAAAClcXjtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# take every 10th sample to make plotting a bit cleaner\n", + "bs_power.plot_power(test_results[::50])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Percent
Insignificant69.633
Negative14.033
Negative Significant1.167
Positive85.967
Positive Significant29.200
\n", + "
" + ], + "text/plain": [ + " Percent\n", + "Insignificant 69.633\n", + "Negative 14.033\n", + "Negative Significant 1.167\n", + "Positive 85.967\n", + "Positive Significant 29.200" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This test was positive but we should only expect to see a significantly positive \n", + "# result ~15% of the time\n", + "bs_power.power_stats(test_results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Can we do something to improve our chances of measuring a good result?\n", + "Yes! Lets try again with larger proposed test and control groups." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "larger_test_results = run_simulation(lift=1.1, data_size=10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAFxCAYAAAArqzGRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nERER8e3/ARJJdZL0+9OnAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# take every 10th sample to make plotting a bit cleaner\n", + "bs_power.plot_power(larger_test_results[::50])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Percent
Insignificant2.300
Negative0.100
Negative Significant0.000
Positive99.900
Positive Significant97.700
\n", + "
" + ], + "text/plain": [ + " Percent\n", + "Insignificant 2.300\n", + "Negative 0.100\n", + "Negative Significant 0.000\n", + "Positive 99.900\n", + "Positive Significant 97.700" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bs_power.power_stats(larger_test_results)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3719931 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +matplotlib==1.5.3 +numpy==1.11.1 +pandas==0.18.1 diff --git a/run_tests.sh b/run_tests.sh new file mode 100644 index 0000000..45a03e8 --- /dev/null +++ b/run_tests.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python -m unittest discover tests diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..b4efc0a --- /dev/null +++ b/setup.py @@ -0,0 +1,12 @@ +from distutils.core import setup + +files = [] + +setup(name = "bootstrapped", + version = "0.21", + description = "", + author = "Spencer Beecher", + author_email = "spencebeecher@gmail.com", + packages = ['bootstrapped'], + long_description = """Implementations of the percentile based bootstrap""" +) diff --git a/tests/test_bootstrap.py b/tests/test_bootstrap.py new file mode 100644 index 0000000..7adc566 --- /dev/null +++ b/tests/test_bootstrap.py @@ -0,0 +1,383 @@ +# Copyright (c) 2016-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. +'''Tests for bootstrapped''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals +import unittest +import numpy as np +import bootstrapped.bootstrap as bs +import bootstrapped.compare_functions as bs_compare +import bootstrapped.stats_functions as bs_stats +import scipy.sparse as sparse + + +def to_sparse(data): + mat = sparse.csr_matrix((1, len(data))) + mat[0, :len(data)] = data + return mat + +class BootstrappedTest(unittest.TestCase): + + def setUp(self): + np.random.seed(1) + import warnings + warnings.filterwarnings('ignore') + + def test_result_math(self): + mean = 100 + stdev = 10 + + samples = np.random.normal(loc=mean, scale=stdev, size=5000) + + bsr = bs.bootstrap(samples, bs_stats.mean) + + self.assertEqual(bsr.value + 1, (bsr + 1).value) + self.assertEqual(bsr.value + 1, (1 + bsr).value) + + self.assertEqual(bsr.value - 1, (bsr - 1).value) + self.assertEqual(1 - bsr.value, (1 - bsr).value) + + self.assertEqual(bsr.value * 2, (bsr * 2).value) + self.assertEqual(2 * bsr.value, (2 * bsr).value) + + def test_bootstrap(self): + mean = 100 + stdev = 10 + + samples = np.random.normal(loc=mean, scale=stdev, size=5000) + + bsr = bs.bootstrap(samples, bs_stats.mean) + + self.assertAlmostEqual(bsr.value, 100, delta=2) + self.assertAlmostEqual(bsr.upper_bound, 102, delta=2) + self.assertAlmostEqual(bsr.lower_bound, 98, delta=2) + + bsr2 = bs.bootstrap(samples, bs_stats.mean, alpha=0.1) + + self.assertAlmostEqual(bsr.value, bsr2.value, delta=2) + self.assertTrue(bsr.upper_bound > bsr2.upper_bound) + self.assertTrue(bsr.lower_bound < bsr2.lower_bound) + + def test_bootstrap_ab(self): + mean = 100 + stdev = 10 + + test = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl = np.random.normal(loc=mean, scale=stdev, size=5000) + test = test * 1.1 + + bsr = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change) + self.assertAlmostEqual( + bsr.value, + 10, + delta=.5 + ) + + bsr2 = bs.bootstrap_ab(test, ctrl, bs_stats.sum, + bs_compare.percent_change) + self.assertAlmostEqual( + bsr2.value, + -88, + delta=2 + ) + + bsr3 = bs.bootstrap_ab(test, ctrl, bs_stats.sum, + bs_compare.percent_change, scale_test_by=10.) + self.assertAlmostEqual( + bsr3.value, + 10, + delta=.5 + ) + + test_denom = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl_denom = np.random.normal(loc=mean, scale=stdev, size=5000) + test_denom = test_denom * 1.1 + + bsr4 = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change, + test_denominator=test_denom, + ctrl_denominator=ctrl_denom) + self.assertAlmostEqual( + bsr4.value, + 0, + delta=.5 + ) + + def test_compare_functions(self): + self.assertAlmostEqual( + bs_compare.percent_change(1.1, 1.), + 10, + delta=.01 + ) + self.assertAlmostEqual( + bs_compare.ratio(1.1, 1.), + 1.1, + delta=0.1 + ) + self.assertAlmostEqual( + bs_compare.percent_difference(1.1, 1.), + 9.5, + delta=0.1 + ) + + self.assertAlmostEqual( + bs_compare.difference(1.1, 1.), + .1, + delta=0.01 + ) + + self.assertAlmostEqual( + bs_compare.ratio( + 1, + 1., + ), + 1., + delta=0.1 + ) + + def test_bootstrap_ratio(self): + denom = np.array(([10] * 100) + ([1 / 10.] * 100)) + samples = np.array((([1 / 10.] * 100) + [10] * 100)) + + bsr = bs.bootstrap(samples, bs_stats.mean, denominator_values=denom) + + self.assertAlmostEqual(bsr.value, 1, delta=.1) + + bsr = bs.bootstrap(samples / denom, bs_stats.mean) + self.assertAlmostEqual(bsr.value, 50, delta=5) + + def test_batch_size(self): + mean = 100 + stdev = 10 + + test = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl = np.random.normal(loc=mean, scale=stdev, size=5000) + test = test * 1.1 + + bsr = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change) + + bsr_batch = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change, + iteration_batch_size=10) + self.assertAlmostEqual( + bsr.value, + bsr_batch.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_batch.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_batch.upper_bound, + delta=.1 + ) + + bsr = bs.bootstrap(test, bs_stats.mean) + + bsr_batch = bs.bootstrap(test, bs_stats.mean, + iteration_batch_size=10) + self.assertAlmostEqual( + bsr.value, + bsr_batch.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_batch.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_batch.upper_bound, + delta=.1 + ) + + def test_threads(self): + mean = 100 + stdev = 10 + + test = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl = np.random.normal(loc=mean, scale=stdev, size=5000) + test = test * 1.1 + + bsr = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change) + + bsr_thread = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change, + num_threads=10) + self.assertAlmostEqual( + bsr.value, + bsr_thread.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_thread.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_thread.upper_bound, + delta=.1 + ) + + bsr = bs.bootstrap(test, bs_stats.mean) + + bsr_thread = bs.bootstrap(test, bs_stats.mean, + num_threads=10) + self.assertAlmostEqual( + bsr.value, + bsr_thread.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_thread.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_thread.upper_bound, + delta=.1 + ) + + def test_pivotal(self): + mean = 100 + stdev = 10 + + test = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl = np.random.normal(loc=mean, scale=stdev, size=5000) + test = test * 1.1 + + bsr = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change) + + bsr_percent = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change, + is_pivotal=False) + self.assertAlmostEqual( + bsr.value, + bsr_percent.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_percent.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_percent.upper_bound, + delta=.1 + ) + + bsr = bs.bootstrap(test, bs_stats.mean) + + bsr_percent = bs.bootstrap(test, bs_stats.mean, + num_threads=10) + self.assertAlmostEqual( + bsr.value, + bsr_percent.value, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_percent.lower_bound, + delta=.1 + ) + + self.assertAlmostEqual( + bsr.upper_bound, + bsr_percent.upper_bound, + delta=.1 + ) + + def test_bootstrap_sparse(self): + mean = 100 + stdev = 10 + + samples = np.random.normal(loc=mean, scale=stdev, size=5000) + samples_sp = sparse.csr_matrix(samples) + + bsr = bs.bootstrap(samples, bs_stats.mean) + bsr_sp = bs.bootstrap(samples_sp, bs_stats.mean) + + self.assertAlmostEqual(bsr.value, 100, delta=2) + self.assertAlmostEqual(bsr.upper_bound, 102, delta=2) + self.assertAlmostEqual(bsr.lower_bound, 98, delta=2) + + self.assertAlmostEqual(bsr.value, bsr_sp.value, delta=.2) + self.assertAlmostEqual(bsr.upper_bound, bsr_sp.upper_bound, delta=.2) + self.assertAlmostEqual(bsr.lower_bound, bsr_sp.lower_bound, delta=.2) + + bsr = bs.bootstrap(samples, bs_stats.sum) + bsr_sp = bs.bootstrap(samples, bs_stats.sum) + + self.assertAlmostEqual(bsr.value, bsr_sp.value, delta=bsr.value / 100.) + self.assertAlmostEqual(bsr.upper_bound, bsr_sp.upper_bound, + delta=bsr.upper_bound / 100.) + self.assertAlmostEqual(bsr.lower_bound, bsr_sp.lower_bound, + delta=bsr.lower_bound / 100.) + + bsr = bs.bootstrap(samples, bs_stats.std) + bsr_sp = bs.bootstrap(samples, bs_stats.std) + + self.assertAlmostEqual(bsr.value, bsr_sp.value, delta=.2) + self.assertAlmostEqual(bsr.upper_bound, bsr_sp.upper_bound, delta=.2) + self.assertAlmostEqual(bsr.lower_bound, bsr_sp.lower_bound, delta=.2) + + def test_bootstrap_ab_sparse(self): + mean = 100 + stdev = 10 + + test = np.random.normal(loc=mean, scale=stdev, size=500) + ctrl = np.random.normal(loc=mean, scale=stdev, size=5000) + test = test * 1.1 + test_sp = sparse.csr_matrix(test) + ctrl_sp = sparse.csr_matrix(ctrl) + + bsr = bs.bootstrap_ab(test, ctrl, bs_stats.mean, + bs_compare.percent_change) + bsr_sp = bs.bootstrap_ab(test_sp, ctrl_sp, bs_stats.mean, + bs_compare.percent_change) + + self.assertAlmostEqual( + bsr.value, + bsr_sp.value, + delta=.1, + ) + self.assertAlmostEqual( + bsr.upper_bound, + bsr_sp.upper_bound, + delta=.1, + ) + + self.assertAlmostEqual( + bsr.lower_bound, + bsr_sp.lower_bound, + delta=.1, + )