{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this example, we will use a simple Dual Moving Average Crossover (DMAC, not to be confused with MACD) indicator as our entry and exit strategy. We will start with analyzing a single fast and slow window combination, and then move on to some advanced analysis such as building 2D heatmaps to compare multiple combinations and 3D cubes to see how they perform against time. Finally, we will explore how our DMAC strategy compares to holding Bitcoin and trading randomly."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import vectorbt as vbt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"Collapsed": "false"
},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"from datetime import datetime, timedelta\n",
"import pytz\n",
"from dateutil.parser import parse\n",
"import ipywidgets as widgets\n",
"from copy import deepcopy\n",
"from tqdm import tqdm\n",
"import imageio\n",
"from IPython import display\n",
"import plotly.graph_objects as go\n",
"import itertools\n",
"import dateparser\n",
"import gc"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"Collapsed": "false"
},
"outputs": [],
"source": [
"# Enter your parameters here\n",
"seed = 42\n",
"symbol = 'BTC-USD'\n",
"metric = 'total_return'\n",
"\n",
"start_date = datetime(2018, 1, 1, tzinfo=pytz.utc) # time period for analysis, must be timezone-aware\n",
"end_date = datetime(2020, 1, 1, tzinfo=pytz.utc)\n",
"time_buffer = timedelta(days=100) # buffer before to pre-calculate SMA/EMA, best to set to max window\n",
"freq = '1D'\n",
"\n",
"vbt.settings.portfolio['init_cash'] = 100. # 100$\n",
"vbt.settings.portfolio['fees'] = 0.0025 # 0.25%\n",
"vbt.settings.portfolio['slippage'] = 0.0025 # 0.25%"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(831, 5)\n",
"Index(['Open', 'High', 'Low', 'Close', 'Volume'], dtype='object')\n"
]
}
],
"source": [
"# Download data with time buffer\n",
"cols = ['Open', 'High', 'Low', 'Close', 'Volume']\n",
"ohlcv_wbuf = vbt.YFData.download(symbol, start=start_date-time_buffer, end=end_date).get(cols)\n",
"\n",
"ohlcv_wbuf = ohlcv_wbuf.astype(np.float64)\n",
" \n",
"print(ohlcv_wbuf.shape)\n",
"print(ohlcv_wbuf.columns)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(731, 5)\n"
]
}
],
"source": [
"# Create a copy of data without time buffer\n",
"wobuf_mask = (ohlcv_wbuf.index >= start_date) & (ohlcv_wbuf.index <= end_date) # mask without buffer\n",
"\n",
"ohlcv = ohlcv_wbuf.loc[wobuf_mask, :]\n",
"\n",
"print(ohlcv.shape)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot the OHLC data\n",
"ohlcv_wbuf.vbt.ohlcv.plot().show_svg() \n",
"# remove show_svg() to display interactive chart!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Single window combination\n",
"\n",
"Perform a single test to see how our DMAC strategy compares to the hold strategy."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"fast_window = 30\n",
"slow_window = 80"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(831,)\n",
"(831,)\n"
]
}
],
"source": [
"# Pre-calculate running windows on data with time buffer\n",
"fast_ma = vbt.MA.run(ohlcv_wbuf['Open'], fast_window)\n",
"slow_ma = vbt.MA.run(ohlcv_wbuf['Open'], slow_window)\n",
"\n",
"print(fast_ma.ma.shape)\n",
"print(slow_ma.ma.shape)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(731,)\n",
"(731,)\n"
]
}
],
"source": [
"# Remove time buffer\n",
"fast_ma = fast_ma[wobuf_mask]\n",
"slow_ma = slow_ma[wobuf_mask]\n",
"\n",
"# there should be no nans after removing time buffer\n",
"assert(~fast_ma.ma.isnull().any()) \n",
"assert(~slow_ma.ma.isnull().any())\n",
"\n",
"print(fast_ma.ma.shape)\n",
"print(slow_ma.ma.shape)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# Generate crossover signals\n",
"dmac_entries = fast_ma.ma_crossed_above(slow_ma)\n",
"dmac_exits = fast_ma.ma_crossed_below(slow_ma)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = ohlcv['Open'].vbt.plot(trace_kwargs=dict(name='Price'))\n",
"fig = fast_ma.ma.vbt.plot(trace_kwargs=dict(name='Fast MA'), fig=fig)\n",
"fig = slow_ma.ma.vbt.plot(trace_kwargs=dict(name='Slow MA'), fig=fig)\n",
"fig = dmac_entries.vbt.signals.plot_as_entry_markers(ohlcv['Open'], fig=fig)\n",
"fig = dmac_exits.vbt.signals.plot_as_exit_markers(ohlcv['Open'], fig=fig)\n",
"\n",
"fig.show_svg()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Start 2018-01-01 00:00:00+00:00\n",
"End 2020-01-01 00:00:00+00:00\n",
"Period 731 days 00:00:00\n",
"Total 3\n",
"Rate [%] 0.410397\n",
"Total Overlapping 0\n",
"Overlapping Rate [%] 0.0\n",
"First Index 2018-05-11 00:00:00+00:00\n",
"Last Index 2019-03-03 00:00:00+00:00\n",
"Norm Avg Index [-1, 1] -0.297717\n",
"Distance -> Other: Min 25 days 00:00:00\n",
"Distance -> Other: Max 184 days 00:00:00\n",
"Distance -> Other: Mean 78 days 08:00:00\n",
"Distance -> Other: Std 91 days 12:16:23.545375334\n",
"Total Partitions 3\n",
"Partition Rate [%] 100.0\n",
"Partition Length: Min 1 days 00:00:00\n",
"Partition Length: Max 1 days 00:00:00\n",
"Partition Length: Mean 1 days 00:00:00\n",
"Partition Length: Std 0 days 00:00:00\n",
"Partition Distance: Min 83 days 00:00:00\n",
"Partition Distance: Max 213 days 00:00:00\n",
"Partition Distance: Mean 148 days 00:00:00\n",
"Partition Distance: Std 91 days 22:10:23.366287302\n",
"dtype: object\n"
]
}
],
"source": [
"# Signal stats\n",
"print(dmac_entries.vbt.signals.stats(settings=dict(other=dmac_exits)))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot signals\n",
"fig = dmac_entries.vbt.signals.plot(trace_kwargs=dict(name='Entries'))\n",
"dmac_exits.vbt.signals.plot(trace_kwargs=dict(name='Exits'), fig=fig).show_svg()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Start 2018-01-01 00:00:00+00:00\n",
"End 2020-01-01 00:00:00+00:00\n",
"Period 731 days 00:00:00\n",
"Start Value 100.0\n",
"End Value 227.256402\n",
"Total Return [%] 127.256402\n",
"Benchmark Return [%] -47.27928\n",
"Max Gross Exposure [%] 100.0\n",
"Total Fees Paid 1.68223\n",
"Max Drawdown [%] 29.194035\n",
"Max Drawdown Duration 323 days 00:00:00\n",
"Total Trades 3\n",
"Total Closed Trades 3\n",
"Total Open Trades 0\n",
"Open Trade PnL 0.0\n",
"Win Rate [%] 33.333333\n",
"Best Trade [%] 173.824516\n",
"Worst Trade [%] -10.494557\n",
"Avg Winning Trade [%] 173.824516\n",
"Avg Losing Trade [%] -8.834053\n",
"Avg Winning Trade Duration 184 days 00:00:00\n",
"Avg Losing Trade Duration 25 days 12:00:00\n",
"Profit Factor 8.541137\n",
"Expectancy 42.418801\n",
"Sharpe Ratio 1.177409\n",
"Calmar Ratio 1.735479\n",
"Omega Ratio 1.37092\n",
"Sortino Ratio 1.869101\n",
"dtype: object\n"
]
}
],
"source": [
"# Build partfolio, which internally calculates the equity curve\n",
"\n",
"# Volume is set to np.inf by default to buy/sell everything\n",
"# You don't have to pass freq here because our data is already perfectly time-indexed\n",
"dmac_pf = vbt.Portfolio.from_signals(ohlcv['Close'], dmac_entries, dmac_exits)\n",
"\n",
"# Print stats\n",
"print(dmac_pf.stats())"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" id col size entry_idx entry_price entry_fees exit_idx \\\n",
"0 0 0 0.011787 130 8462.593960 0.249377 155 \n",
"1 1 0 0.011773 213 7586.067777 0.223271 239 \n",
"2 2 0 0.021499 426 3856.793721 0.207294 610 \n",
"\n",
" exit_price exit_fees pnl return direction status parent_id \n",
"0 7614.675366 0.224390 -10.468386 -0.104946 0 1 0 \n",
"1 7078.539086 0.208333 -6.406577 -0.071735 0 1 1 \n",
"2 10596.981189 0.569565 144.131365 1.738245 0 1 2 \n"
]
},
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot trades\n",
"print(dmac_pf.trades.records)\n",
"dmac_pf.trades.plot().show_svg()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"Collapsed": "false"
},
"outputs": [],
"source": [
"# Now build portfolio for a \"Hold\" strategy\n",
"# Here we buy once at the beginning and sell at the end\n",
"hold_entries = pd.Series.vbt.signals.empty_like(dmac_entries)\n",
"hold_entries.iloc[0] = True\n",
"hold_exits = pd.Series.vbt.signals.empty_like(hold_entries)\n",
"hold_exits.iloc[-1] = True\n",
"hold_pf = vbt.Portfolio.from_signals(ohlcv['Close'], hold_entries, hold_exits)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Equity\n",
"fig = dmac_pf.value().vbt.plot(trace_kwargs=dict(name='Value (DMAC)'))\n",
"hold_pf.value().vbt.plot(trace_kwargs=dict(name='Value (Hold)'), fig=fig).show_svg()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we will implement an interactive window slider to easily compare windows by their performance."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"min_window = 2\n",
"max_window = 100"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(HBox(children=(Label(value='Fast and slow window:'), IntRangeSlider(value=(30, 80), layout=Layo…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"perf_metrics = ['total_return', 'positions.win_rate', 'positions.expectancy', 'max_drawdown']\n",
"perf_metric_names = ['Total return', 'Win rate', 'Expectancy', 'Max drawdown']\n",
"\n",
"windows_slider = widgets.IntRangeSlider(\n",
" value=[fast_window, slow_window],\n",
" min=min_window,\n",
" max=max_window,\n",
" step=1,\n",
" layout=dict(width='500px'),\n",
" continuous_update=True\n",
")\n",
"dmac_fig = None\n",
"dmac_img = widgets.Image(\n",
" format='png',\n",
" width=vbt.settings['plotting']['layout']['width'],\n",
" height=vbt.settings['plotting']['layout']['height']\n",
")\n",
"metrics_html = widgets.HTML()\n",
"\n",
"def on_value_change(value):\n",
" global dmac_fig\n",
" \n",
" # Calculate portfolio\n",
" fast_window, slow_window = value['new']\n",
" fast_ma = vbt.MA.run(ohlcv_wbuf['Open'], fast_window)\n",
" slow_ma = vbt.MA.run(ohlcv_wbuf['Open'], slow_window)\n",
" fast_ma = fast_ma[wobuf_mask]\n",
" slow_ma = slow_ma[wobuf_mask]\n",
" dmac_entries = fast_ma.ma_crossed_above(slow_ma)\n",
" dmac_exits = fast_ma.ma_crossed_below(slow_ma)\n",
" dmac_pf = vbt.Portfolio.from_signals(ohlcv['Close'], dmac_entries, dmac_exits)\n",
"\n",
" # Update figure\n",
" if dmac_fig is None:\n",
" dmac_fig = ohlcv['Open'].vbt.plot(trace_kwargs=dict(name='Price'))\n",
" fast_ma.ma.vbt.plot(trace_kwargs=dict(name='Fast MA'), fig=dmac_fig)\n",
" slow_ma.ma.vbt.plot(trace_kwargs=dict(name='Slow MA'), fig=dmac_fig)\n",
" dmac_entries.vbt.signals.plot_as_entry_markers(ohlcv['Open'], fig=dmac_fig)\n",
" dmac_exits.vbt.signals.plot_as_exit_markers(ohlcv['Open'], fig=dmac_fig)\n",
" else:\n",
" with dmac_fig.batch_update():\n",
" dmac_fig.data[1].y = fast_ma.ma\n",
" dmac_fig.data[2].y = slow_ma.ma\n",
" dmac_fig.data[3].x = ohlcv['Open'].index[dmac_entries]\n",
" dmac_fig.data[3].y = ohlcv['Open'][dmac_entries]\n",
" dmac_fig.data[4].x = ohlcv['Open'].index[dmac_exits]\n",
" dmac_fig.data[4].y = ohlcv['Open'][dmac_exits]\n",
" dmac_img.value = dmac_fig.to_image(format=\"png\")\n",
" \n",
" # Update metrics table\n",
" sr = pd.Series([dmac_pf.deep_getattr(m) for m in perf_metrics], \n",
" index=perf_metric_names, name='Performance')\n",
" metrics_html.value = sr.to_frame().style.set_properties(**{'text-align': 'right'}).render()\n",
" \n",
"windows_slider.observe(on_value_change, names='value')\n",
"on_value_change({'new': windows_slider.value})\n",
"\n",
"dashboard = widgets.VBox([\n",
" widgets.HBox([widgets.Label('Fast and slow window:'), windows_slider]),\n",
" dmac_img,\n",
" metrics_html\n",
"])\n",
"dashboard"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"dashboard.close() # after using, release memory and notebook metadata"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1660"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"gc.collect()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Multiple window combinations\n",
"\n",
"Calculate the performance of each window combination in a vectorized way and display the results as a heatmap."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(831, 4851)\n",
"(831, 4851)\n",
"Int64Index([ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
" ...\n",
" 96, 96, 96, 96, 97, 97, 97, 98, 98, 99],\n",
" dtype='int64', name='fast_ma_window', length=4851)\n",
"Int64Index([ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n",
" ...\n",
" 97, 98, 99, 100, 98, 99, 100, 99, 100, 100],\n",
" dtype='int64', name='slow_ma_window', length=4851)\n"
]
}
],
"source": [
"# Pre-calculate running windows on data with time buffer\n",
"fast_ma, slow_ma = vbt.MA.run_combs(\n",
" ohlcv_wbuf['Open'], np.arange(min_window, max_window+1), \n",
" r=2, short_names=['fast_ma', 'slow_ma'])\n",
"\n",
"print(fast_ma.ma.shape)\n",
"print(slow_ma.ma.shape)\n",
"print(fast_ma.ma.columns)\n",
"print(slow_ma.ma.columns)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(731, 4851)\n",
"(731, 4851)\n"
]
}
],
"source": [
"# Remove time buffer\n",
"fast_ma = fast_ma[wobuf_mask]\n",
"slow_ma = slow_ma[wobuf_mask]\n",
"\n",
"print(fast_ma.ma.shape)\n",
"print(slow_ma.ma.shape)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"MultiIndex([( 2, 3),\n",
" ( 2, 4),\n",
" ( 2, 5),\n",
" ( 2, 6),\n",
" ( 2, 7),\n",
" ( 2, 8),\n",
" ( 2, 9),\n",
" ( 2, 10),\n",
" ( 2, 11),\n",
" ( 2, 12),\n",
" ...\n",
" (96, 97),\n",
" (96, 98),\n",
" (96, 99),\n",
" (96, 100),\n",
" (97, 98),\n",
" (97, 99),\n",
" (97, 100),\n",
" (98, 99),\n",
" (98, 100),\n",
" (99, 100)],\n",
" names=['fast_ma_window', 'slow_ma_window'], length=4851)\n"
]
}
],
"source": [
"# We perform the same steps, but now we have 4851 columns instead of 1\n",
"# Each column corresponds to a pair of fast and slow windows\n",
"# Generate crossover signals\n",
"dmac_entries = fast_ma.ma_crossed_above(slow_ma)\n",
"dmac_exits = fast_ma.ma_crossed_below(slow_ma)\n",
"\n",
"print(dmac_entries.columns) # the same for dmac_exits"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"# Build portfolio\n",
"dmac_pf = vbt.Portfolio.from_signals(ohlcv['Close'], dmac_entries, dmac_exits)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(4851,)\n",
"MultiIndex([( 2, 3),\n",
" ( 2, 4),\n",
" ( 2, 5),\n",
" ( 2, 6),\n",
" ( 2, 7),\n",
" ( 2, 8),\n",
" ( 2, 9),\n",
" ( 2, 10),\n",
" ( 2, 11),\n",
" ( 2, 12),\n",
" ...\n",
" (96, 97),\n",
" (96, 98),\n",
" (96, 99),\n",
" (96, 100),\n",
" (97, 98),\n",
" (97, 99),\n",
" (97, 100),\n",
" (98, 99),\n",
" (98, 100),\n",
" (99, 100)],\n",
" names=['fast_ma_window', 'slow_ma_window'], length=4851)\n"
]
}
],
"source": [
"# Calculate performance of each window combination\n",
"dmac_perf = dmac_pf.deep_getattr(metric)\n",
"\n",
"print(dmac_perf.shape)\n",
"print(dmac_perf.index)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(38, 96)"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dmac_perf.idxmax() # your optimal window combination"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(99, 99)\n"
]
}
],
"source": [
"# Convert this array into a matrix of shape (99, 99): 99 fast windows x 99 slow windows\n",
"dmac_perf_matrix = dmac_perf.vbt.unstack_to_df(symmetric=True, \n",
" index_levels='fast_ma_window', column_levels='slow_ma_window')\n",
"\n",
"print(dmac_perf_matrix.shape)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"dmac_perf_matrix.vbt.heatmap(\n",
" xaxis_title='Slow window', \n",
" yaxis_title='Fast window').show_svg()\n",
"# remove show_svg() for interactivity"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we will implement an interactive date range slider to easily compare heatmaps over time."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"def dmac_pf_from_date_range(from_date, to_date):\n",
" # Portfolio from MA crossover, filtered by time range\n",
" range_mask = (ohlcv.index >= from_date) & (ohlcv.index <= to_date)\n",
" range_fast_ma = fast_ma[range_mask] # use our variables defined above\n",
" range_slow_ma = slow_ma[range_mask]\n",
" dmac_entries = range_fast_ma.ma_crossed_above(range_slow_ma)\n",
" dmac_exits = range_fast_ma.ma_crossed_below(range_slow_ma)\n",
" dmac_pf = vbt.Portfolio.from_signals(ohlcv.loc[range_mask, 'Close'], dmac_entries, dmac_exits)\n",
" return dmac_pf"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"def rand_pf_from_date_range(from_date, to_date):\n",
" # Portfolio from random strategy, filtered by time range\n",
" range_mask = (ohlcv.index >= from_date) & (ohlcv.index <= to_date)\n",
" range_fast_ma = fast_ma[range_mask] # use our variables defined above\n",
" range_slow_ma = slow_ma[range_mask]\n",
" dmac_entries = range_fast_ma.ma_crossed_above(range_slow_ma)\n",
" dmac_exits = range_fast_ma.ma_crossed_below(range_slow_ma)\n",
" rand_entries = dmac_entries.vbt.signals.shuffle(seed=seed) # same number of signals as in dmac\n",
" rand_exits = rand_entries.vbt.signals.generate_random_exits(seed=seed)\n",
" rand_pf = vbt.Portfolio.from_signals(ohlcv.loc[range_mask, 'Close'], rand_entries, rand_exits)\n",
" return rand_pf"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [],
"source": [
"def hold_pf_from_date_range(from_date, to_date):\n",
" # Portfolio from holding strategy, filtered by time range\n",
" range_mask = (ohlcv.index >= from_date) & (ohlcv.index <= to_date)\n",
" hold_entries = pd.Series.vbt.signals.empty(range_mask.sum(), index=ohlcv[range_mask].index)\n",
" hold_entries.iloc[0] = True\n",
" hold_exits = pd.Series.vbt.signals.empty_like(hold_entries)\n",
" hold_exits.iloc[-1] = True\n",
" hold_pf = vbt.Portfolio.from_signals(ohlcv.loc[range_mask, 'Close'], hold_entries, hold_exits)\n",
" return hold_pf"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(FigureWidget({\n",
" 'data': [{'close': array([13657.20019531, 14982.09960938, 15201. , ..…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# TimeSeries (OHLC)\n",
"ts_fig = ohlcv.vbt.ohlcv.plot(\n",
" title=symbol, \n",
" show_volume=False,\n",
" annotations=[dict(\n",
" align='left',\n",
" showarrow=False,\n",
" xref='paper',\n",
" yref='paper',\n",
" x=0.5,\n",
" y=0.9,\n",
" font=dict(size=14),\n",
" bordercolor='black',\n",
" borderwidth=1,\n",
" bgcolor='white'\n",
" )],\n",
" width=700, \n",
" height=250)\n",
"\n",
"# Histogram (DMAC vs Random)\n",
"histogram = vbt.plotting.Histogram(\n",
" trace_names=['Random strategy', 'DMAC strategy'],\n",
" title='%s distribution' % metric,\n",
" xaxis_tickformat='%',\n",
" annotations=[dict(\n",
" y=0, \n",
" xref='x', \n",
" yref='paper', \n",
" showarrow=True, \n",
" arrowcolor=\"black\",\n",
" arrowsize=1,\n",
" arrowwidth=1,\n",
" arrowhead=1,\n",
" xanchor='left', \n",
" text='Hold', \n",
" textangle=0,\n",
" font=dict(size=14),\n",
" bordercolor='black',\n",
" borderwidth=1,\n",
" bgcolor='white',\n",
" ax=0,\n",
" ay=-50,\n",
" )],\n",
" width=700,\n",
" height=250\n",
")\n",
"\n",
"# Heatmap (DMAC vs Holding)\n",
"heatmap = vbt.plotting.Heatmap(\n",
" x_labels=np.arange(min_window, max_window+1),\n",
" y_labels=np.arange(min_window, max_window+1),\n",
" trace_kwargs=dict(\n",
" colorbar=dict(\n",
" tickformat='%', \n",
" ticks=\"outside\"\n",
" ), \n",
" colorscale='RdBu'),\n",
" title='%s by window' % metric,\n",
" width=650,\n",
" height=420\n",
")\n",
"\n",
"dmac_perf_matrix = None\n",
"rand_perf_matrix = None\n",
"hold_value = None\n",
"\n",
"def update_heatmap_colorscale(perf_matrix):\n",
" # Update heatmap colorscale based on performance matrix\n",
" with heatmap.fig.batch_update():\n",
" heatmap.fig.data[0].zmid = hold_value\n",
" heatmap.fig.data[0].colorbar.tickvals = [\n",
" np.nanmin(perf_matrix), \n",
" hold_value, \n",
" np.nanmax(perf_matrix)\n",
" ]\n",
" heatmap.fig.data[0].colorbar.ticktext = [\n",
" 'Min: {:.0%}'.format(np.nanmin(perf_matrix)).ljust(12), \n",
" 'Hold: {:.0%}'.format(hold_value).ljust(12), \n",
" 'Max: {:.0%}'.format(np.nanmax(perf_matrix)).ljust(12)\n",
" ]\n",
" \n",
"def update_histogram(dmac_perf_matrix, rand_perf_matrix, hold_value):\n",
" # Update histogram figure\n",
" with histogram.fig.batch_update():\n",
" histogram.update(\n",
" np.asarray([\n",
" rand_perf_matrix.values.flatten(),\n",
" dmac_perf_matrix.values.flatten()\n",
" ]).transpose()\n",
" )\n",
" histogram.fig.layout.annotations[0].x = hold_value\n",
"\n",
"def update_figs(from_date, to_date):\n",
" global dmac_perf_matrix, rand_perf_matrix, hold_value # needed for on_heatmap_change\n",
" \n",
" # Build portfolios\n",
" dmac_pf = dmac_pf_from_date_range(from_date, to_date)\n",
" rand_pf = rand_pf_from_date_range(from_date, to_date)\n",
" hold_pf = hold_pf_from_date_range(from_date, to_date)\n",
"\n",
" # Calculate performance\n",
" dmac_perf_matrix = dmac_pf.deep_getattr(metric)\n",
" dmac_perf_matrix = dmac_perf_matrix.vbt.unstack_to_df(\n",
" symmetric=True, index_levels='fast_ma_window', column_levels='slow_ma_window')\n",
" rand_perf_matrix = rand_pf.deep_getattr(metric)\n",
" rand_perf_matrix = rand_perf_matrix.vbt.unstack_to_df(\n",
" symmetric=True, index_levels='fast_ma_window', column_levels='slow_ma_window')\n",
" hold_value = hold_pf.deep_getattr(metric)\n",
"\n",
" # Update figures\n",
" update_histogram(dmac_perf_matrix, rand_perf_matrix, hold_value)\n",
" with ts_fig.batch_update():\n",
" ts_fig.update_xaxes(range=(from_date, to_date))\n",
" ts_fig.layout.annotations[0].text = 'Hold: %.f%%' % (hold_value * 100)\n",
" with heatmap.fig.batch_update():\n",
" heatmap.update(dmac_perf_matrix)\n",
" update_heatmap_colorscale(dmac_perf_matrix.values)\n",
"\n",
"def on_ts_change(layout, x_range):\n",
" global dmac_perf_matrix, rand_perf_matrix, hold_value # needed for on_heatmap_change\n",
" \n",
" if isinstance(x_range[0], str) and isinstance(x_range[1], str):\n",
" update_figs(x_range[0], x_range[1])\n",
"\n",
"ts_fig.layout.on_change(on_ts_change, 'xaxis.range')\n",
"\n",
"def on_heatmap_change(layout, x_range, y_range):\n",
" if dmac_perf_matrix is not None:\n",
" x_mask = (dmac_perf_matrix.columns >= x_range[0]) & (dmac_perf_matrix.columns <= x_range[1])\n",
" y_mask = (dmac_perf_matrix.index >= y_range[0]) & (dmac_perf_matrix.index <= y_range[1])\n",
" if x_mask.any() and y_mask.any():\n",
" # Update widgets\n",
" sub_dmac_perf_matrix = dmac_perf_matrix.loc[y_mask, x_mask] # y_mask is index, x_mask is columns\n",
" sub_rand_perf_matrix = rand_perf_matrix.loc[y_mask, x_mask]\n",
" update_histogram(sub_dmac_perf_matrix, sub_rand_perf_matrix, hold_value)\n",
" update_heatmap_colorscale(sub_dmac_perf_matrix.values)\n",
" \n",
"heatmap.fig.layout.on_change(on_heatmap_change, 'xaxis.range', 'yaxis.range')\n",
"\n",
"dashboard = widgets.VBox([\n",
" ts_fig,\n",
" histogram.fig,\n",
" heatmap.fig\n",
"])\n",
"dashboard"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
"dashboard.close() # after using, release memory and notebook metadata"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Animate the whole thing as a GIF."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "6477421947b84b1f9c0fb5210e48fef2",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/92 [00:00