ENH Bootstrap analysis

pyfolio/plotting.py

@@ -462,7 +462,42 @@ def plot_drawdown_underwater(returns, ax=None, **kwargs):
     return ax
 
 
-def show_perf_stats(returns, factor_returns, live_start_date=None):
+def plot_perf_stats(returns, factor_returns, ax=None):
+    """Create box plot of some performance metrics of the strategy.
+    The width of the box whiskers is determined by a bootstrap.
+
+    Parameters
+    ----------
+    returns : pd.Series
+        Daily returns of the strategy, noncumulative.
+         - See full explanation in tears.create_full_tear_sheet.
+    factor_returns : pd.DataFrame, optional
+        data set containing the Fama-French risk factors. See
+        utils.load_portfolio_risk_factors.
+    ax : matplotlib.Axes, optional
+        Axes upon which to plot.
+
+    Returns
+    -------
+    ax : matplotlib.Axes
+        The axes that were plotted on.
+
+    """
+    if ax is None:
+        ax = plt.gca()
+
+    bootstrap_values = timeseries.perf_stats_bootstrap(returns,
+                                                       factor_returns,
+                                                       return_stats=False)
+    bootstrap_values = bootstrap_values.drop('kurtosis', axis='columns')
+
+    sns.boxplot(bootstrap_values, orient='h', ax=ax)
+
+    return ax
+
+
+def show_perf_stats(returns, factor_returns, live_start_date=None,
+                    bootstrap=False):
     """Prints some performance metrics of the strategy.
 
     - Shows amount of time the strategy has been run in backtest and
@@ -482,23 +517,30 @@ def show_perf_stats(returns, factor_returns, live_start_date=None):
     factor_returns : pd.Series
         Daily noncumulative returns of the benchmark.
          - This is in the same style as returns.
+    bootstrap : boolean (optional)
+        Whether to perform bootstrap analysis for the performance
+        metrics.
+         - For more information, see timeseries.perf_stats_bootstrap
 
     """
 
+    if bootstrap:
+        perf_func = timeseries.perf_stats_bootstrap
+    else:
+        perf_func = timeseries.perf_stats
+
     if live_start_date is not None:
         live_start_date = utils.get_utc_timestamp(live_start_date)
         returns_backtest = returns[returns.index < live_start_date]
         returns_live = returns[returns.index > live_start_date]
 
-        perf_stats_live = np.round(timeseries.perf_stats(
+        perf_stats_live = np.round(perf_func(
             returns_live,
             factor_returns=factor_returns), 2)
-        perf_stats_live.columns = ['Out_of_Sample']
 
-        perf_stats_all = np.round(timeseries.perf_stats(
+        perf_stats_all = np.round(perf_func(
             returns,
             factor_returns=factor_returns), 2)
-        perf_stats_all.columns = ['All_History']
 
         print('Out-of-Sample Months: ' +
               str(int(len(returns_live) / APPROX_BDAYS_PER_MONTH)))
@@ -508,16 +550,16 @@ def show_perf_stats(returns, factor_returns, live_start_date=None):
     print('Backtest Months: ' +
           str(int(len(returns_backtest) / APPROX_BDAYS_PER_MONTH)))
 
-    perf_stats = np.round(timeseries.perf_stats(
+    perf_stats = np.round(perf_func(
         returns_backtest,
         factor_returns=factor_returns), 2)
 
     if live_start_date is not None:
-        perf_stats = pd.DataFrame(OrderedDict([
+        perf_stats = pd.concat(OrderedDict([
             ('Backtest', perf_stats),
             ('Out of sample', perf_stats_live),
             ('All history', perf_stats_all),
-        ]))
+        ]), axis=1)
 
     print(perf_stats)
 

pyfolio/tears.py

@@ -61,6 +61,7 @@ def create_full_tear_sheet(returns,
                            round_trips=False,
                            hide_positions=False,
                            cone_std=(1.0, 1.5, 2.0),
+                           bootstrap=False,
                            set_context=True):
     """
     Generate a number of tear sheets that are useful
@@ -131,6 +132,9 @@ def create_full_tear_sheet(returns,
         If tuple, Tuple of standard deviation values to use for the cone plots
          - The cone is a normal distribution with this standard deviation
              centered around a linear regression.
+    bootstrap : boolean (optional)
+        Whether to perform bootstrap analysis for the performance
+        metrics. Takes a few minutes longer.
     set_context : boolean, optional
         If True, set default plotting style context.
          - See plotting.context().
@@ -156,6 +160,7 @@ def create_full_tear_sheet(returns,
         live_start_date=live_start_date,
         cone_std=cone_std,
         benchmark_rets=benchmark_rets,
+        bootstrap=bootstrap,
         set_context=set_context)
 
     create_interesting_times_tear_sheet(returns,
@@ -190,6 +195,7 @@ def create_full_tear_sheet(returns,
 def create_returns_tear_sheet(returns, live_start_date=None,
                               cone_std=(1.0, 1.5, 2.0),
                               benchmark_rets=None,
+                              bootstrap=False,
                               return_fig=False):
     """
     Generate a number of plots for analyzing a strategy's returns.
@@ -218,6 +224,9 @@ def create_returns_tear_sheet(returns, live_start_date=None,
     benchmark_rets : pd.Series, optional
         Daily noncumulative returns of the benchmark.
          - This is in the same style as returns.
+    bootstrap : boolean (optional)
+        Whether to perform bootstrap analysis for the performance
+        metrics. Takes a few minutes longer.
     return_fig : boolean, optional
         If True, returns the figure that was plotted on.
     set_context : boolean, optional
@@ -240,6 +249,7 @@ def create_returns_tear_sheet(returns, live_start_date=None,
     print('\n')
 
     plotting.show_perf_stats(returns, benchmark_rets,
+                             bootstrap=bootstrap,
                              live_start_date=live_start_date)
 
     if live_start_date is not None:
@@ -248,6 +258,9 @@ def create_returns_tear_sheet(returns, live_start_date=None,
     else:
         vertical_sections = 10
 
+    if bootstrap:
+        vertical_sections += 1
+
     fig = plt.figure(figsize=(14, vertical_sections * 6))
     gs = gridspec.GridSpec(vertical_sections, 3, wspace=0.5, hspace=0.5)
     ax_rolling_returns = plt.subplot(gs[:2, :])
@@ -317,6 +330,11 @@ def create_returns_tear_sheet(returns, live_start_date=None,
         df_monthly,
         ax=ax_return_quantiles)
 
+    if bootstrap:
+        ax_bootstrap = plt.subplot(gs[10, :])
+        plotting.plot_perf_stats(returns, benchmark_rets,
+                                 ax=ax_bootstrap)
+
     for ax in fig.axes:
         plt.setp(ax.get_xticklabels(), visible=True)
 

pyfolio/tests/test_tears.py

@@ -59,6 +59,7 @@ class PositionsTestCase(TestCase):
                            ({'round_trips': True},),
                            ({'hide_positions': True},),
                            ({'cone_std': 1},),
+                           ({'bootstrap': True},),
                            ])
     @cleanup
     def test_create_full_tear_sheet_breakdown(self, kwargs):
@@ -73,6 +74,7 @@ def test_create_full_tear_sheet_breakdown(self, kwargs):
                            ({'live_start_date':
                              test_returns.index[-20]},),
                            ({'cone_std': 1},),
+                           ({'bootstrap': True},),
                            ])
     @cleanup
     def test_create_returns_tear_sheet_breakdown(self, kwargs):

pyfolio/tests/test_timeseries.py

@@ -391,3 +391,41 @@ def test_bootstrap_cone_against_linear_cone_normal_returns(self):
         for col, vals in bootstrap_cone.iteritems():
             expected = normal_cone[col].values
             assert_allclose(vals.values, expected, rtol=.005)
+
+
+class TestBootstrap(TestCase):
+    @parameterized.expand([
+        (0., 1., 1000),
+        (1., 2., 500),
+        (-1., 0.1, 10),
+    ])
+    def test_calc_bootstrap(self, true_mean, true_sd, n):
+        """Compare bootstrap distribution of the mean to sampling distribution
+        of the mean.
+
+        """
+        np.random.seed(123)
+        func = np.mean
+        returns = pd.Series((np.random.randn(n) * true_sd) +
+                            true_mean)
+
+        samples = timeseries.calc_bootstrap(func, returns,
+                                            n_samples=10000)
+
+        # Calculate statistics of sampling distribution of the mean
+        mean_of_mean = np.mean(returns)
+        sd_of_mean = np.std(returns) / np.sqrt(n)
+
+        assert_almost_equal(
+            np.mean(samples),
+            mean_of_mean,
+            3,
+            'Mean of bootstrap does not match theoretical mean of'
+            'sampling distribution')
+
+        assert_almost_equal(
+            np.std(samples),
+            sd_of_mean,
+            3,
+            'SD of bootstrap does not match theoretical SD of'
+            'sampling distribution')

pyfolio/timeseries.py

@@ -126,7 +126,7 @@ def annual_return(returns, period=DAILY):
     num_years = float(len(returns)) / ann_factor
     df_cum_rets = cum_returns(returns, starting_value=100)
     start_value = 100
-    end_value = df_cum_rets[-1]
+    end_value = df_cum_rets.iloc[-1]
 
     total_return = (end_value - start_value) / start_value
     annual_return = (1. + total_return) ** (1 / num_years) - 1
@@ -752,6 +752,130 @@ def perf_stats(returns, factor_returns=None):
     return stats
 
 
+def perf_stats_bootstrap(returns, factor_returns=None, return_stats=True):
+    """Calculates various bootstrapped performance metrics of a strategy.
+
+    Parameters
+    ----------
+    returns : pd.Series
+        Daily returns of the strategy, noncumulative.
+         - See full explanation in tears.create_full_tear_sheet.
+    factor_returns : pd.Series (optional)
+        Daily noncumulative returns of the benchmark.
+         - This is in the same style as returns.
+        If None, do not compute alpha, beta, and information ratio.
+    return_stats : boolean (optional)
+        If True, returns a DataFrame of mean, median, 5 and 95 percentiles
+        for each perf metric.
+        If False, returns a DataFrame with the bootstrap samples for
+        each perf metric.
+
+    Returns
+    -------
+    pd.DataFrame
+        if return_stats is True:
+        - Distributional statistics of bootstrapped sampling
+        distribution of performance metrics.
+        if return_stats is False:
+        - Bootstrap samples for each performance metric.
+    """
+    bootstrap_values = OrderedDict()
+
+    for stat_func in SIMPLE_STAT_FUNCS:
+        stat_name = stat_func.__name__
+        bootstrap_values[stat_name] = calc_bootstrap(stat_func,
+                                                     returns)
+
+    if factor_returns is not None:
+        for stat_func in FACTOR_STAT_FUNCS:
+            stat_name = stat_func.__name__
+            bootstrap_values[stat_name] = calc_bootstrap(
+                stat_func,
+                returns,
+                factor_returns=factor_returns)
+
+    bootstrap_values = pd.DataFrame(bootstrap_values)
+
+    if return_stats:
+        stats = bootstrap_values.apply(calc_distribution_stats)
+        return stats.T[['mean', 'median', '5%', '95%']]
+    else:
+        return bootstrap_values
+
+
+def calc_bootstrap(func, returns, *args, **kwargs):
+    """Performs a bootstrap analysis on a user-defined function returning
+    a summary statistic.
+
+    Parameters
+    ----------
+    func : function
+        Function that either takes a single array (commonly returns)
+        or two arrays (commonly returns and factor returns) and
+        returns a single value (commonly a summary
+        statistic). Additional args and kwargs are passed as well.
+    returns : pd.Series
+        Daily returns of the strategy, noncumulative.
+         - See full explanation in tears.create_full_tear_sheet.
+    factor_returns : pd.Series (optional)
+        Daily noncumulative returns of the benchmark.
+         - This is in the same style as returns.
+    n_samples : int (optional)
+        Number of bootstrap samples to draw. Default is 1000.
+        Increasing this will lead to more stable / accurate estimates.
+
+    Returns
+    -------
+    numpy.ndarray
+        Bootstrapped sampling distribution of passed in func.
+    """
+
+    n_samples = kwargs.pop('n_samples', 1000)
+    out = np.empty(n_samples)
+
+    factor_returns = kwargs.pop('factor_returns', None)
+
+    for i in range(n_samples):
+        idx = np.random.randint(len(returns), size=len(returns))
+        returns_i = returns.iloc[idx].reset_index(drop=True)
+        if factor_returns is not None:
+            factor_returns_i = factor_returns.iloc[idx].reset_index(drop=True)
+            out[i] = func(returns_i, factor_returns_i,
+                          *args, **kwargs)
+        else:
+            out[i] = func(returns_i,
+                          *args, **kwargs)
+
+    return out
+
+
+def calc_distribution_stats(x):
+    """Calculate various summary statistics of data.
+
+    Parameters
+    ----------
+    x : numpy.ndarray or pandas.Series
+        Array to compute summary statistics for.
+
+    Returns
+    -------
+    pandas.Series
+        Series containing mean, median, std, as well as 5, 25, 75 and
+        95 percentiles of passed in values.
+
+    """
+    return pd.Series({'mean': np.mean(x),
+                      'median': np.median(x),
+                      'std': np.std(x),
+                      '5%': np.percentile(x, 5),
+                      '25%': np.percentile(x, 25),
+                      '75%': np.percentile(x, 75),
+                      '95%': np.percentile(x, 95),
+                      'IQR': np.subtract.reduce(
+                          np.percentile(x, [75, 25])),
+                      })
+
+
 def get_max_drawdown_underwater(underwater):
     """Determines peak, valley, and recovery dates given and 'underwater'
     DataFrame.