MNT: Rerender doc/examples with updated jupytext

Author: kernc

doc/examples/Multiple Time Frames.py

@@ -3,15 +3,16 @@
 #   jupytext:
 #     text_representation:
 #       extension: .py
-#       format_name: light
-#       format_version: '1.5'
-#       jupytext_version: 1.5.1
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.1
 #   kernelspec:
 #     display_name: Python 3
 #     language: python
 #     name: python3
 # ---
 
+# %% [markdown]
 # Multiple Time Frames
 # ============
 #
@@ -32,7 +33,7 @@
 # [Tulipy](https://tulipindicators.org),
 # but among us, let's introduce the two indicators we'll be using.
 
-# +
+# %%
 import pandas as pd
 
 
@@ -52,8 +53,7 @@ def RSI(array, n):
     return 100 - 100 / (1 + rs)
 
 
-# -
-
+# %% [markdown]
 # The strategy roughly goes like this:
 #
 # Buy a position when:
@@ -66,7 +66,7 @@ def RSI(array, n):
 #
 # We need to provide bars data in the _lowest time frame_ (i.e. daily) and resample it to any higher time frame (i.e. weekly) that our strategy requires.
 
-# +
+# %%
 from backtesting import Strategy, Backtest
 from backtesting.lib import resample_apply
 
@@ -112,34 +112,36 @@ def next(self):
         # close the position, if any.
         elif price < .98 * self.ma10[-1]:
             self.position.close()
-# -
 
+# %% [markdown]
 # Let's see how our strategy fares replayed on nine years of Google stock data.
 
-# +
+# %%
 from backtesting.test import GOOG
 
 backtest = Backtest(GOOG, System, commission=.002)
 backtest.run()
-# -
 
+# %% [markdown]
 # Meager four trades in the span of nine years and with zero return? How about if we optimize the parameters a bit?
 
-# +
+# %%
 # %%time
 
 backtest.optimize(d_rsi=range(10, 35, 5),
                   w_rsi=range(10, 35, 5),
                   level=range(30, 80, 10))
-# -
 
+# %%
 backtest.plot()
 
+# %% [markdown]
 # Better. While the strategy doesn't perform as well as simple buy & hold, it does so with significantly lower exposure (time in market).
 #
 # In conclusion, to test strategies on multiple time frames, you need to pass in OHLC data in the lowest time frame, then resample it to higher time frames, apply the indicators, then resample back to the lower time frame, filling in the in-betweens.
 # Which is what the function [`backtesting.lib.resample_apply()`](https://kernc.github.io/backtesting.py/doc/backtesting/lib.html#backtesting.lib.resample_apply) does for you.
 
+# %% [markdown]
 # Learn more by exploring further
 # [examples](https://kernc.github.io/backtesting.py/doc/backtesting/index.html#tutorials)
 # or find more framework options in the

doc/examples/Parameter Heatmap & Optimization.py

@@ -4,15 +4,16 @@
 #   jupytext:
 #     text_representation:
 #       extension: .py
-#       format_name: light
-#       format_version: '1.5'
-#       jupytext_version: 1.16.6
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.1
 #   kernelspec:
 #     display_name: Python 3 (ipykernel)
 #     language: python
 #     name: python3
 # ---
 
+# %% [markdown]
 # Parameter Heatmap
 # ==========
 #
@@ -25,16 +26,18 @@
 # [TA-Lib](https://github.com/mrjbq7/ta-lib) or
 # [Tulipy](https://tulipindicators.org).
 
+# %%
 from backtesting.test import SMA
 
+# %% [markdown]
 # Our strategy will be a similar moving average cross-over strategy to the one in
 # [Quick Start User Guide](https://kernc.github.io/backtesting.py/doc/examples/Quick%20Start%20User%20Guide.html),
 # but we will use four moving averages in total:
 # two moving averages whose relationship determines a general trend
 # (we only trade long when the shorter MA is above the longer one, and vice versa),
 # and two moving averages whose cross-over with daily _close_ prices determine the signal to enter or exit the position.
 
-# +
+# %%
 from backtesting import Strategy
 from backtesting.lib import crossover
 
@@ -84,16 +87,15 @@ def next(self):
                 self.position.close()
 
 
-# -
-
+# %% [markdown]
 # It's not a robust strategy, but we can optimize it.
 #
 # [Grid search](https://en.wikipedia.org/wiki/Hyperparameter_optimization#Grid_search)
 # is an exhaustive search through a set of specified sets of values of hyperparameters. One evaluates the performance for each set of parameters and finally selects the combination that performs best.
 #
 # Let's optimize our strategy on Google stock data using _randomized_ grid search over the parameter space, evaluating at most (approximately) 200 randomly chosen combinations:
 
-# +
+# %%
 # %%time 
 
 from backtesting import Backtest
@@ -112,32 +114,38 @@ def next(self):
     max_tries=200,
     random_state=0,
     return_heatmap=True)
-# -
 
+# %% [markdown]
 # Notice `return_heatmap=True` parameter passed to
 # [`Backtest.optimize()`](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Backtest.optimize).
 # It makes the function return a heatmap series along with the usual stats of the best run.
 # `heatmap` is a pandas Series indexed with a MultiIndex, a cartesian product of all permissible (tried) parameter values.
 # The series values are from the `maximize=` argument we provided.
 
+# %%
 heatmap
 
+# %% [markdown]
 # This heatmap contains the results of all the runs,
 # making it very easy to obtain parameter combinations for e.g. three best runs:
 
+# %%
 heatmap.sort_values().iloc[-3:]
 
+# %% [markdown]
 # But we use vision to make judgements on larger data sets much faster.
 # Let's plot the whole heatmap by projecting it on two chosen dimensions.
 # Say we're mostly interested in how parameters `n1` and `n2`, on average, affect the outcome.
 
+# %%
 hm = heatmap.groupby(['n1', 'n2']).mean().unstack()
 hm = hm[::-1]
 hm
 
+# %% [markdown]
 # Let's plot this table as a heatmap:
 
-# +
+# %%
 # %matplotlib inline
 
 import matplotlib.pyplot as plt
@@ -151,8 +159,8 @@ def next(self):
     ax.set_ylabel('n1'),
     ax.figure.colorbar(im, ax=ax),
 )
-# -
 
+# %% [markdown]
 # We see that, on average, we obtain the highest result using trend-determining parameters `n1=30` and `n2=100` or `n1=70` and `n2=80`,
 # and it's not like other nearby combinations work similarly well — for our particular strategy, these combinations really stand out.
 #
@@ -163,13 +171,13 @@ def next(self):
 #
 # <a id=plot-heatmaps></a>
 
-# +
+# %%
 from backtesting.lib import plot_heatmaps
 
 
 plot_heatmaps(heatmap, agg='mean')
-# -
 
+# %% [markdown]
 # ## Model-based optimization
 #
 # Above, we used _randomized grid search_ optimization method. Any kind of grid search, however, might be computationally expensive for large data sets. In the follwing example, we will use
@@ -179,12 +187,12 @@ def next(self):
 #
 # So, with `method="sambo"`:
 
-# +
+# %%
 # %%capture
 
 # ! pip install sambo  # This is a run-time dependency
 
-# +
+# %%
 # #%%time
 
 stats, heatmap, optimize_result = backtest.optimize(
@@ -199,10 +207,11 @@ def next(self):
     random_state=0,
     return_heatmap=True,
     return_optimization=True)
-# -
 
+# %%
 heatmap.sort_values().iloc[-3:]
 
+# %% [markdown]
 # Notice how the optimization runs somewhat slower even though `max_tries=` is lower. This is due to the sequential nature of the algorithm and should actually perform quite comparably even in cases of _much larger parameter spaces_ where grid search would effectively blow up, likely reaching a better optimum than a simple randomized search would.
 # A note of warning, again, to take steps to avoid
 # [overfitting](https://en.wikipedia.org/wiki/Overfitting)
@@ -214,18 +223,18 @@ def next(self):
 #
 # Note, because SAMBO internally only does _minimization_, the values in `optimize_result` are negated (less is better).
 
-# +
+# %%
 from sambo.plot import plot_objective
 
 names = ['n1', 'n2', 'n_enter', 'n_exit']
 _ = plot_objective(optimize_result, names=names, estimator='et')
 
-# +
+# %%
 from sambo.plot import plot_evaluations
 
 _ = plot_evaluations(optimize_result, names=names)
-# -
 
+# %% [markdown]
 # Learn more by exploring further
 # [examples](https://kernc.github.io/backtesting.py/doc/backtesting/index.html#tutorials)
 # or find more framework options in the