diff --git a/dependencies/fastquant/docs/assets/bbands.png b/dependencies/fastquant/docs/assets/bbands.png new file mode 100644 index 0000000..e9abaca Binary files /dev/null and b/dependencies/fastquant/docs/assets/bbands.png differ diff --git a/dependencies/fastquant/docs/assets/bitcoin_forecasts.png b/dependencies/fastquant/docs/assets/bitcoin_forecasts.png new file mode 100644 index 0000000..c460bdf Binary files /dev/null and b/dependencies/fastquant/docs/assets/bitcoin_forecasts.png differ diff --git a/dependencies/fastquant/docs/assets/bitcoin_prophet_backtest.png b/dependencies/fastquant/docs/assets/bitcoin_prophet_backtest.png new file mode 100644 index 0000000..1083a9d Binary files /dev/null and b/dependencies/fastquant/docs/assets/bitcoin_prophet_backtest.png differ diff --git a/dependencies/fastquant/docs/assets/daily_closing.png b/dependencies/fastquant/docs/assets/daily_closing.png new file mode 100644 index 0000000..f83f3ad Binary files /dev/null and b/dependencies/fastquant/docs/assets/daily_closing.png differ diff --git a/dependencies/fastquant/docs/assets/daily_closing_sma30.png b/dependencies/fastquant/docs/assets/daily_closing_sma30.png new file mode 100644 index 0000000..0a57b8f Binary files /dev/null and b/dependencies/fastquant/docs/assets/daily_closing_sma30.png differ diff --git a/dependencies/fastquant/docs/assets/emac.png b/dependencies/fastquant/docs/assets/emac.png new file mode 100644 index 0000000..cb7ee5a Binary files /dev/null and b/dependencies/fastquant/docs/assets/emac.png differ diff --git a/dependencies/fastquant/docs/assets/macd.png b/dependencies/fastquant/docs/assets/macd.png new file mode 100644 index 0000000..87147e9 Binary files /dev/null and b/dependencies/fastquant/docs/assets/macd.png differ diff --git a/dependencies/fastquant/docs/assets/rsi.png b/dependencies/fastquant/docs/assets/rsi.png new file mode 100644 index 0000000..c787784 Binary files /dev/null and b/dependencies/fastquant/docs/assets/rsi.png differ diff --git a/dependencies/fastquant/docs/assets/sentiment.png b/dependencies/fastquant/docs/assets/sentiment.png new file mode 100644 index 0000000..ccc495e Binary files /dev/null and b/dependencies/fastquant/docs/assets/sentiment.png differ diff --git a/dependencies/fastquant/docs/assets/smac.png b/dependencies/fastquant/docs/assets/smac.png new file mode 100644 index 0000000..c2f42cd Binary files /dev/null and b/dependencies/fastquant/docs/assets/smac.png differ diff --git a/dependencies/fastquant/docs/assets/smac_sample.png b/dependencies/fastquant/docs/assets/smac_sample.png new file mode 100644 index 0000000..1739fdb Binary files /dev/null and b/dependencies/fastquant/docs/assets/smac_sample.png differ diff --git a/dependencies/fastquant/docs/docusaurus/docs/backtest.md b/dependencies/fastquant/docs/docusaurus/docs/backtest.md new file mode 100644 index 0000000..258c7b3 --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/docs/backtest.md @@ -0,0 +1,65 @@ +--- +id: backtest +title: backtest +--- + +## Description + +Backtest financial data with a specified trading strategy + +## Parameters + +**strategy** : str or an instance of `fastquant.strategies.base.BaseStrategy` + see list of accepted strategy keys below + +**data** : pandas.DataFrame + dataframe with at least close price indexed with time + +**commission** : float + commission per transaction [0, 1] + +**init_cash** : float + initial cash (currency implied from `data`) + +**plot** : bool + show plot backtrader (disabled if `strategy`=="multi") + +**verbose** : int + Verbose can take values: [0, 1, 2, 3], with increasing levels of verbosity (default=1). + +**sort_by** : str + sort result by given metric (default='rnorm') + +**sentiments** : pandas.DataFrame + df of sentiment [0, 1] indexed by time (applicable if `strategy`=='senti') + +**strats** : dict + dictionary of strategy parameters (applicable if `strategy`=='multi') + +**return_history** : bool + return history of transactions (i.e. buy and sell timestamps) (default=False) + +**channel** : str + Channel to be used for notifications - e.g. "slack" (default=None) + +**symbol** : str + Symbol to be referenced in the channel notification if not None (default=None) + +**allow_short** : bool + Whether to allow short selling, with max set as `short_max` times the portfolio value (default=False) + +**short_max** : float + The maximum short position allowable as a ratio relative to the portfolio value at that timepoint(default=1.5) + +**figsize** : tuple + The size of the figure to be displayed at the end of the backtest (default=(30, 15)) + +**data_class** : bt.feed.DataBase + Custom backtrader database to be used as a parent class instead bt.feed. (default=None) + +**data_kwargs** : dict + Datafeed keyword arguments (empty dict by default) + +## Returns + +A plot containing the backtest results and a dictionary of the history and results of the backtest run. \ No newline at end of file diff --git a/dependencies/fastquant/docs/docusaurus/docs/get_crypto_data.md b/dependencies/fastquant/docs/docusaurus/docs/get_crypto_data.md new file mode 100644 index 0000000..4a44db8 --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/docs/get_crypto_data.md @@ -0,0 +1,25 @@ +--- +id: get_crypto_data +title: get_crypto_data +--- + +Get crypto data in OHLCV format + +## Parameters + +**ticker** : str + List of ticker symbols here: https://coinmarketcap.com/exchanges/binance/ + +**start_date**, **end_date** : str + date in YYYY-MM-DD format + +**time_resolution** : str + resolutions: '1w', '1d' (default), '1h', '1m' + +**exchange** : str + market exchanges: 'binance' (default), 'coinbasepro', 'bithumb', 'kraken', 'kucoin', 'bitstamp' + +## Returns + +**pandas.DataFrame** + Stock data (in the specified `format`) for the specified company and date range \ No newline at end of file diff --git a/dependencies/fastquant/docs/docusaurus/docs/get_stock_data.md b/dependencies/fastquant/docs/docusaurus/docs/get_stock_data.md new file mode 100644 index 0000000..ea9a501 --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/docs/get_stock_data.md @@ -0,0 +1,29 @@ +--- +id: get_stock_data +title: get_stock_data +--- + +## Parameters + +**symbol** : str + Symbol of the stock in the PSE or Yahoo. + You can refer to these links: + PHISIX: https://www.pesobility.com/stock + YAHOO: https://www.nasdaq.com/market-activity/stocks/screener?exchange=nasdaq + +**start_date** : str + Starting date (YYYY-MM-DD) of the period that you want to get data on + +**end_date** : str + Ending date (YYYY-MM-DD) of the period you want to get data on + +**source** : str + First source to query from ("pse", "yahoo"). If the stock is not found in the first source, the query is run on the other source. + +**format** : str + Format of the output data + +## Returns + +**pandas.DataFrame** + Stock data (in the specified `format`) for the specified company and date range \ No newline at end of file diff --git a/dependencies/fastquant/docs/docusaurus/docs/getting_started.md b/dependencies/fastquant/docs/docusaurus/docs/getting_started.md new file mode 100644 index 0000000..280fbf4 --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/docs/getting_started.md @@ -0,0 +1,277 @@ +--- +id: getting_started +title: Getting Started with fastquant +--- + +## Installation + +### Python + +``` +pip install fastquant +or +python -m pip install fastquant +``` + +## Get stock data +All symbols from [Yahoo Finance](https://finance.yahoo.com/) and Philippine Stock Exchange ([PSE](https://www.pesobility.com/stock)) are accessible via `get_stock_data`. + +### Python + +``` +from fastquant import get_stock_data +df = get_stock_data("JFC", "2018-01-01", "2019-01-01") +print(df.head()) + +# dt close +# 2019-01-01 293.0 +# 2019-01-02 292.0 +# 2019-01-03 309.0 +# 2019-01-06 323.0 +# 2019-01-07 321.0 +``` + +## Get crypto data +The data is pulled from Binance, and all the available tickers are found [here](https://coinmarketcap.com/exchanges/binance/). + +### Python + +``` +from fastquant import get_crypto_data +crypto = get_crypto_data("BTC/USDT", "2018-12-01", "2019-12-31") +crypto.head() + +# open high low close volume +# dt +# 2018-12-01 4041.27 4299.99 3963.01 4190.02 44840.073481 +# 2018-12-02 4190.98 4312.99 4103.04 4161.01 38912.154790 +# 2018-12-03 4160.55 4179.00 3827.00 3884.01 49094.369163 +# 2018-12-04 3884.76 4085.00 3781.00 3951.64 48489.551613 +# 2018-12-05 3950.98 3970.00 3745.00 3769.84 44004.799448 +``` + +## Backtest trading strategies + +### Simple Moving Average Crossover (15 day MA vs 40 day MA) +Daily Jollibee prices from 2018-01-01 to 2019-01-01 +``` +from fastquant import backtest +backtest('smac', df, fast_period=15, slow_period=40) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 102272.90 +``` +![](./docs/assets/smac_sample.png) + +## Optimize trading strategies with automated grid search + +fastquant allows you to automatically measure the performance of your trading strategy on multiple combinations of parameters. All you need to do is to input the values as iterators (like as a `list` or `range`). + +### Simple Moving Average Crossover (15 to 30 day MA vs 40 to 55 day MA) +Daily Jollibee prices from 2018-01-01 to 2019-01-01 + +``` +from fastquant import backtest +res = backtest("smac", df, fast_period=range(15, 30, 3), slow_period=range(40, 55, 3), verbose=False) + +# Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'fast_period': 15, 'slow_period': 40} +# Optimal metrics: {'rtot': 0.022, 'ravg': 9.25e-05, 'rnorm': 0.024, 'rnorm100': 2.36, 'sharperatio': None, 'pnl': 2272.9, 'final_value': 102272.90} + +print(res[['fast_period', 'slow_period', 'final_value']].head()) + +# fast_period slow_period final_value +#0 15 40 102272.90 +#1 21 40 98847.00 +#2 21 52 98796.09 +#3 24 46 98008.79 +#4 15 46 97452.92 + +``` + + +## Library of trading strategies + +| Strategy | Alias | Parameters | +| --- | --- | --- | +| Relative Strength Index (RSI) | rsi | `rsi_period`, `rsi_upper`, `rsi_lower` | +| Simple moving average crossover (SMAC) | smac | `fast_period`, `slow_period` | +| Exponential moving average crossover (EMAC) | emac | `fast_period`, `slow_period` | +| Moving Average Convergence Divergence (MACD) | macd | `fast_perod`, `slow_upper`, `signal_period`, `sma_period`, `sma_dir_period` | +| Bollinger Bands | bbands | `period`, `devfactor` | +| Buy and Hold | buynhold | `N/A` | +| Sentiment Strategy | sentiment | `keyword` , `page_nums`, `senti` | +| Custom Prediction Strategy | custom | `upper_limit`, `lower_limit`, `custom_column` | +| Custom Ternary Strategy | ternary | `buy_int`, `sell_int`, `custom_column` | + +### Relative Strength Index (RSI) Strategy +``` +backtest('rsi', df, rsi_period=14, rsi_upper=70, rsi_lower=30) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 132967.87 +``` +![](./docs/assets/rsi.png) + +### Simple moving average crossover (SMAC) Strategy +``` +backtest('smac', df, fast_period=10, slow_period=30) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 95902.74 +``` +![](./docs/assets/smac.png) + +### Exponential moving average crossover (EMAC) Strategy +``` +backtest('emac', df, fast_period=10, slow_period=30) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 90976.00 +``` +![](./docs/assets/emac.png) + +### Moving Average Convergence Divergence (MACD) Strategy +``` +backtest('macd', df, fast_period=12, slow_period=26, signal_period=9, sma_period=30, dir_period=10) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 96229.58 +``` +![](./docs/assets/macd.png) + +### Bollinger Bands Strategy +``` +backtest('bbands', df, period=20, devfactor=2.0) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 97060.30 +``` +![](./docs/assets/bbands.png) + +### News Sentiment Strategy +Use Tesla (TSLA) stock from yahoo finance and news articles from [Business Times](https://www.businesstimes.com.sg/) +``` +from fastquant import get_yahoo_data, get_bt_news_sentiment +data = get_yahoo_data("TSLA", "2020-01-01", "2020-07-04") +sentiments = get_bt_news_sentiment(keyword="tesla", page_nums=3) +backtest("sentiment", data, sentiments=sentiments, senti=0.2) + +# Starting Portfolio Value: 100000.00 +# Final Portfolio Value: 313198.37 +# Note: Unfortunately, you can't recreate this scenario due to inconsistencies in the dates and sentiments that is scraped by get_bt_news_sentiment. In order to have a quickstart with News Sentiment Strategy you need to make the dates consistent with the sentiments that you are scraping. + +from fastquant import get_yahoo_data, get_bt_news_sentiment +from datetime import datetime, timedelta + +# we get the current date and delta time of 30 days +current_date = datetime.now().strftime("%Y-%m-%d") +delta_date = (datetime.now() - timedelta(30)).strftime("%Y-%m-%d") +data = get_yahoo_data("TSLA", delta_date, current_date) +sentiments = get_bt_news_sentiment(keyword="tesla", page_nums=3) +backtest("sentiment", data, sentiments=sentiments, senti=0.2) +``` +![](./docs/assets/sentiment.png) + +### Multi Strategy + +Multiple registered strategies can be utilized together in an OR fashion, where buy or sell signals are applied when at least one of the strategies trigger them. + +``` +df = get_stock_data("JFC", "2018-01-01", "2019-01-01") + +# Utilize single set of parameters +strats = { + "smac": {"fast_period": 35, "slow_period": 50}, + "rsi": {"rsi_lower": 30, "rsi_upper": 70} +} +res = backtest("multi", df, strats=strats) +res.shape +# (1, 16) + + +# Utilize auto grid search +strats_opt = { + "smac": {"fast_period": 35, "slow_period": [40, 50]}, + "rsi": {"rsi_lower": [15, 30], "rsi_upper": 70} +} + +res_opt = backtest("multi", df, strats=strats_opt) +res_opt.shape +# (4, 16) +``` + +### Custom Strategy for Backtesting Machine Learning & Statistics Based Predictions + +This powerful strategy allows you to backtest your own trading strategies using any type of model w/ as few as 3 lines of code after the forecast! + + Predictions based on any model can be used as a custom indicator to be backtested using fastquant. You just need to add a `custom` column in the input dataframe, and set values for `upper_limit` and `lower_limit`. + +The strategy is structured similar to `RSIStrategy` where you can set an `upper_limit`, above which the asset is sold (considered "overbought"), and a `lower_limit`, below which the asset is bought (considered "underbought). `upper_limit` is set to 95 by default, while `lower_limit` is set to 5 by default. + +In the example below, we show how to use the custom strategy to backtest a custom indicator based on in-sample time series forecasts. The forecasts were generated using Facebook's [Prophet](https://github.com/facebook/prophet) package on Bitcoin prices. + +``` +from fastquant import get_crypto_data, backtest +from fbprophet import Prophet +from matplotlib import pyplot as plt + +# Pull crypto data +df = get_crypto_data("BTC/USDT", "2019-01-01", "2020-05-31") + +# Fit model on closing prices +ts = df.reset_index()[["dt", "close"]] +ts.columns = ['ds', 'y'] +m = Prophet(daily_seasonality=True, yearly_seasonality=True).fit(ts) +forecast = m.make_future_dataframe(periods=0, freq='D') + +# Predict and plot +pred = m.predict(forecast) +fig1 = m.plot(pred) +plt.title('BTC/USDT: Forecasted Daily Closing Price', fontsize=25) +``` + +![](./docs/assets/bitcoin_forecasts.png) + +``` +# Convert predictions to expected 1 day returns +expected_1day_return = pred.set_index("ds").yhat.pct_change().shift(-1).multiply(100) + +# Backtest the predictions, given that we buy bitcoin when the predicted next day return is > +1.5%, and sell when it's < -1.5%. +df["custom"] = expected_1day_return.multiply(-1) +backtest("custom", df.dropna(),upper_limit=1.5, lower_limit=-1.5) +``` + +![](./docs/assets/bitcoin_prophet_backtest.png) + +See more examples [here](https://nbviewer.jupyter.org/github/enzoampil/fastquant/tree/master/examples/). + +## Be part of the growing fastquant community + +Want to discuss more about fastquant with other users, and our team of developers? + +Join the fastquant Slack community, and our bi-weekly remote meetups through this [link](https://join.slack.com/t/fastquant/shared_invite/zt-gaaoahkz-X~5qw0psNOLg1iFYKcpRlQ)! + +You can also [subscribe](https://forms.gle/HAPYdMp2YMu4qXPd7) to our monthly newsletter to receive updates on our latest tutorials, blog posts, and product features! + +## Run fastquant in a Docker Container + +``` +# Build the image +docker build -t myimage . + +# Run the container +docker run -t -d -p 5000:5000 myimage + +# Get the container id +docker ps + +# SSH into the fastquant container +docker exec -it /bin/bash + +# Run python and use fastquant +python + +>>> from fastquant import get_stock_data +>>> df = get_stock_data("TSLA", "2019-01-01", "2020-01-01") +>>> df.head() +``` diff --git a/dependencies/fastquant/docs/docusaurus/docs/walk_forward_data_split.md b/dependencies/fastquant/docs/docusaurus/docs/walk_forward_data_split.md new file mode 100644 index 0000000..5377689 --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/docs/walk_forward_data_split.md @@ -0,0 +1,161 @@ +--- +id: walk_forward_data_split +title: walk_forward_data_split +--- + +# Example + +To import: `from fastquant.utils.data_split import walk_forward_split` + +Example: +Initialize time series with size of 100 + +## Default Parameters +``` +>>> X = np.random.random(100) +>>> for train_indices, test_indices in walk_forward_split(X): + print("TRAIN:",len(train_indices), train_indices) + print("TEST: ", len(test_indices) ,test_indices) + print() +``` + +``` +TRAIN: 57 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49 50 51 52 53 54 55 56] +TEST: 15 [57 58 59 60 61 62 63 64 65 66 67 68 69 70 71] + +TRAIN: 57 [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 + 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 + 63 64 65 66 67 68 69 70 71] +TEST: 15 [72 73 74 75 76 77 78 79 80 81 82 83 84 85 86] + +TRAIN: 57 [30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 + 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 + 78 79 80 81 82 83 84 85 86] +TEST: 13 [87 88 89 90 91 92 93 94 95 96 97 98 99] +``` +Gives the output of 3 sets (default is `n_splits=3`) of training and test indices with the proportion of 80:20 proportion (default is `train_size=0.80`) for the training and testing indices + + +## Specific Training Size and Number of Splits +``` +>>> X = np.random.random(100) +>>> for train_indices, test_indices in walk_forward_split(X, train_size=25, n_splits=2): + print("TRAIN:",len(train_indices), train_indices) + print("TEST: ", len(test_indices) ,test_indices) + print() +``` + +``` +TRAIN: 25 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24] +TEST: 38 [25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 + 49 50 51 52 53 54 55 56 57 58 59 60 61 62] + +TRAIN: 25 [38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 + 62] +TEST: 37 [63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 + 87 88 89 90 91 92 93 94 95 96 97 98 99] +``` +When `train_size` and `n_splits` are specifed, the size of the test indices will adjust. + + +## Specific Training and Testing Sizes +``` +>>> X = np.random.random(100) +>>> for train_indices, test_indices in walk_forward_split(X, train_size=50, test_size=10): + print("TRAIN:",len(train_indices), train_indices) + print("TEST: ", len(test_indices) ,test_indices) + print() +``` + +``` +TRAIN: 50 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49] +TEST: 10 [50 51 52 53 54 55 56 57 58 59] + +TRAIN: 50 [10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 + 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 + 58 59] +TEST: 10 [60 61 62 63 64 65 66 67 68 69] + +TRAIN: 50 [20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 + 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 + 68 69] +TEST: 10 [70 71 72 73 74 75 76 77 78 79] + +TRAIN: 50 [30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 + 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 + 78 79] +TEST: 10 [80 81 82 83 84 85 86 87 88 89] + +TRAIN: 50 [40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 + 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 + 88 89] +TEST: 10 [90 91 92 93 94 95 96 97 98 99] + +``` +When `train_size` and `test_size` are specifed, the number of splits (`n_splits`) changes to utilize the entire dataset + + +## Sliding vs Expanding modes +``` +>>> X = np.random.random(100) +>>> for train_indices, test_indices in walk_forward_split(X, mode='expanding'): + print("TRAIN:",len(train_indices), train_indices) + print("TEST: ", len(test_indices) ,test_indices) + print() +``` + +``` +TRAIN: 57 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49 50 51 52 53 54 55 56] +TEST: 15 [57 58 59 60 61 62 63 64 65 66 67 68 69 70 71] + +TRAIN: 72 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71] +TEST: 15 [72 73 74 75 76 77 78 79 80 81 82 83 84 85 86] + +TRAIN: 87 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 + 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86] +TEST: 13 [87 88 89 90 91 92 93 94 95 96 97 98 99] +``` +When `mode` is set to `expanding`, the training indices will include indices from the previous splits + + +## Overlap with training data + +There may be cases that you might want to some data from training added to the test data. +In this case, you can set the size of the data which will be added to the test indices + +``` +>>> X = np.random.random(100) +>>> for train_indices, test_indices in walk_forward_split(X, training_overlap_size=5): + print("TRAIN:",len(train_indices), train_indices) + print("TEST: ", len(test_indices) ,test_indices) + print() +``` + +``` +TRAIN: 57 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 + 48 49 50 51 52 53 54 55 56] +TEST: 20 [52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71] + +TRAIN: 57 [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 + 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 + 63 64 65 66 67 68 69 70 71] +TEST: 20 [67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86] + +TRAIN: 57 [30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 + 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 + 78 79 80 81 82 83 84 85 86] +TEST: 18 [82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99] + +``` diff --git a/dependencies/fastquant/docs/docusaurus/sidebars.js b/dependencies/fastquant/docs/docusaurus/sidebars.js new file mode 100644 index 0000000..25e0ade --- /dev/null +++ b/dependencies/fastquant/docs/docusaurus/sidebars.js @@ -0,0 +1,6 @@ +module.exports = { + someSidebar: { + Docs: ['getting_started'], + Reference: ['backtest', 'get_stock_data', 'get_crypto_data', 'walk_forward_data_split'], + }, +}; diff --git a/dependencies/fastquant/examples/2020-04-10-disclosures.ipynb b/dependencies/fastquant/examples/2020-04-10-disclosures.ipynb new file mode 100644 index 0000000..8e89c9b --- /dev/null +++ b/dependencies/fastquant/examples/2020-04-10-disclosures.ipynb @@ -0,0 +1,1294 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"Analyzing PSE disclosures data\"\n", + "> \"Studying the relationship between JFC's price movements and its company disclosures\"\n", + "\n", + "- toc: true\n", + "- branch: master\n", + "- badges: true\n", + "- comments: true\n", + "- author: Jerome de Leon\n", + "- categories: [disclosures]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment to install in colab\n", + "# !pip install -e git+https://github.com/enzoampil/fastquant.git@master#egg=fastquant" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-10T03:37:10.980964Z", + "start_time": "2020-04-10T03:37:10.879219Z" + } + }, + "outputs": [], + "source": [ + "from fastquant import DisclosuresPSE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## fetching company disclosures" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pulling JFC disclosures summary...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00\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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Company NameTemplate NamePSE Form NumberAnnounce Date and TimeCircular Numberedge_nourl
0Jollibee Foods CorporationPress Release4-312020-04-15 07:41:00C02771-20202fd88ba354823b280de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...
1Jollibee Foods CorporationDeclaration of Cash Dividends6-12020-04-07 10:16:00C02610-20204b9121b34dd8b8e80de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...
2Jollibee Foods CorporationPress Release4-312020-03-20 07:16:00C02127-2020a5df62b1a9558fe60de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...
3Jollibee Foods CorporationPress Release4-312020-03-19 07:31:00C02092-20206a7705d00b3e6fb50de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...
4Jollibee Foods CorporationMaterial Information/Transactions4-302020-03-16 12:49:00C01925-20205b6a51f239ad5a6f0de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...
\n", + "" + ], + "text/plain": [ + " Company Name Template Name \\\n", + "0 Jollibee Foods Corporation Press Release \n", + "1 Jollibee Foods Corporation Declaration of Cash Dividends \n", + "2 Jollibee Foods Corporation Press Release \n", + "3 Jollibee Foods Corporation Press Release \n", + "4 Jollibee Foods Corporation Material Information/Transactions \n", + "\n", + " PSE Form Number Announce Date and Time Circular Number \\\n", + "0 4-31 2020-04-15 07:41:00 C02771-2020 \n", + "1 6-1 2020-04-07 10:16:00 C02610-2020 \n", + "2 4-31 2020-03-20 07:16:00 C02127-2020 \n", + "3 4-31 2020-03-19 07:31:00 C02092-2020 \n", + "4 4-30 2020-03-16 12:49:00 C01925-2020 \n", + "\n", + " edge_no \\\n", + "0 2fd88ba354823b280de8473cebbd6407 \n", + "1 4b9121b34dd8b8e80de8473cebbd6407 \n", + "2 a5df62b1a9558fe60de8473cebbd6407 \n", + "3 6a7705d00b3e6fb50de8473cebbd6407 \n", + "4 5b6a51f239ad5a6f0de8473cebbd6407 \n", + "\n", + " url \n", + "0 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "1 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "2 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "3 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "4 https://edge.pse.com.ph/openDiscViewer.do?edge... " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# summary of each disclosure \n", + "dpse.company_disclosures.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "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", + " \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", + " \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", + "
Company NameTemplate NamePSE Form NumberAnnounce Date and TimeCircular Numberedge_nourldisclosure_tableBackground/Description of the DisclosureSubject of the Disclosure
0Jollibee Foods CorporationPress Release4-312020-04-15 07:41:00C02771-20202fd88ba354823b280de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...JFC Reports 2019 Results Based on Audited Fina...Press Release: 2019 Audited Financial Results
1Jollibee Foods CorporationDeclaration of Cash Dividends6-12020-04-07 10:16:00C02610-20204b9121b34dd8b8e80de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...Jollibee Foods Corporation (JFC) announced tod...JFC Declares Cash Dividend, Delivery Business ...
2Jollibee Foods CorporationPress Release4-312020-03-20 07:16:00C02127-2020a5df62b1a9558fe60de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...Jollibee Foods Corporation (JFC) Chairman and ...Jollibee Group allocates Php1 Billion Emergenc...
3Jollibee Foods CorporationPress Release4-312020-03-19 07:31:00C02092-20206a7705d00b3e6fb50de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...In support of health workers and other frontli...Jollibee Group Donates Php 100 Million worth o...
4Jollibee Foods CorporationMaterial Information/Transactions4-302020-03-16 12:49:00C01925-20205b6a51f239ad5a6f0de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...This provides a brief summary for Jollibee Foo...Risks, Impact on the Business and Mitigation M...
\n", + "
" + ], + "text/plain": [ + " Company Name Template Name \\\n", + "0 Jollibee Foods Corporation Press Release \n", + "1 Jollibee Foods Corporation Declaration of Cash Dividends \n", + "2 Jollibee Foods Corporation Press Release \n", + "3 Jollibee Foods Corporation Press Release \n", + "4 Jollibee Foods Corporation Material Information/Transactions \n", + "\n", + " PSE Form Number Announce Date and Time Circular Number \\\n", + "0 4-31 2020-04-15 07:41:00 C02771-2020 \n", + "1 6-1 2020-04-07 10:16:00 C02610-2020 \n", + "2 4-31 2020-03-20 07:16:00 C02127-2020 \n", + "3 4-31 2020-03-19 07:31:00 C02092-2020 \n", + "4 4-30 2020-03-16 12:49:00 C01925-2020 \n", + "\n", + " edge_no \\\n", + "0 2fd88ba354823b280de8473cebbd6407 \n", + "1 4b9121b34dd8b8e80de8473cebbd6407 \n", + "2 a5df62b1a9558fe60de8473cebbd6407 \n", + "3 6a7705d00b3e6fb50de8473cebbd6407 \n", + "4 5b6a51f239ad5a6f0de8473cebbd6407 \n", + "\n", + " url \\\n", + "0 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "1 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "2 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "3 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "4 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "\n", + " disclosure_table \\\n", + "0 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "1 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "2 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "3 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "4 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "\n", + " Background/Description of the Disclosure \\\n", + "0 JFC Reports 2019 Results Based on Audited Fina... \n", + "1 Jollibee Foods Corporation (JFC) announced tod... \n", + "2 Jollibee Foods Corporation (JFC) Chairman and ... \n", + "3 In support of health workers and other frontli... \n", + "4 This provides a brief summary for Jollibee Foo... \n", + "\n", + " Subject of the Disclosure \n", + "0 Press Release: 2019 Audited Financial Results \n", + "1 JFC Declares Cash Dividend, Delivery Business ... \n", + "2 Jollibee Group allocates Php1 Billion Emergenc... \n", + "3 Jollibee Group Donates Php 100 Million worth o... \n", + "4 Risks, Impact on the Business and Mitigation M... " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# includes details\n", + "dpse.disclosures_combined.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6, 2)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get details in each disclosure given edge_no\n", + "dpse.disclosure_tables['a5df62b1a9558fe60de8473cebbd6407'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 Press Release: 2019 Audited Financial Results\n", + "1 JFC Declares Cash Dividend, Delivery Business ...\n", + "2 Jollibee Group allocates Php1 Billion Emergenc...\n", + "3 Jollibee Group Donates Php 100 Million worth o...\n", + "4 Risks, Impact on the Business and Mitigation M...\n", + "5 Jollibee Foods Corporation (JFC) and Dim Sum P...\n", + "6 Results of the 4th Quarter Unaudited Financial...\n", + "7 Press Release: 2019 4th Quarter Financial Results\n", + "8 JFC Provides Statement on Business in China\n", + "9 JFC to Issue US$600 Million Guaranteed Senior ...\n", + "10 JFC to Issue US$600 Million Guaranteed Senior ...\n", + "11 JFC Mandates Banks for U.S.$ Senior Guaranteed...\n", + "Name: Subject of the Disclosure, dtype: object" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpse.disclosures_combined['Subject of the Disclosure']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 JFC Reports 2019 Results Based on Audited Fina...\n", + "1 Jollibee Foods Corporation (JFC) announced tod...\n", + "2 Jollibee Foods Corporation (JFC) Chairman and ...\n", + "3 In support of health workers and other frontli...\n", + "4 This provides a brief summary for Jollibee Foo...\n", + "5 Golden Plate Pte. Ltd. (GPPL), a wholly owned ...\n", + "6 4th Quarter Unaudited Financial Statements for...\n", + "7 JFC Same Store Sales Growth Improves, Gains fr...\n", + "8 Jollibee Foods Corporation makes the following...\n", + "9 Jollibee Foods Corporation (JFC, the “Guaranto...\n", + "10 Jollibee Foods Corporation (JFC, the “Guaranto...\n", + "11 Jollibee Worldwide Pte. Ltd. (JWPL, the “Issue...\n", + "Name: Background/Description of the Disclosure, dtype: object" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpse.disclosures_combined['Background/Description of the Disclosure']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Press Release', 'Declaration of Cash Dividends',\n", + " 'Material Information/Transactions', 'Joint Ventures'],\n", + " dtype=object)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpse.disclosure_types" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pulling JFC stock data...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#all disclosures superposed with percent change\n", + "fig = dpse.plot_disclosures()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#all disclosures superposed with close price\n", + "fig = dpse.plot_disclosures(indicator='close', diff=False, percent=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## filtering disclosures" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "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", + " \n", + " \n", + " \n", + "
Company NameTemplate NamePSE Form NumberAnnounce Date and TimeCircular Numberedge_nourldisclosure_tableBackground/Description of the DisclosureSubject of the Disclosure
5Jollibee Foods Corporation[Amend-1]Joint Ventures4-222020-03-13 15:49:00C01685-202021b9a26e7aa00f960de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"COMMON\", \"Subject of ...Golden Plate Pte. Ltd. (GPPL), a wholly owned ...Jollibee Foods Corporation (JFC) and Dim Sum P...
\n", + "
" + ], + "text/plain": [ + " Company Name Template Name PSE Form Number \\\n", + "5 Jollibee Foods Corporation [Amend-1]Joint Ventures 4-22 \n", + "\n", + " Announce Date and Time Circular Number edge_no \\\n", + "5 2020-03-13 15:49:00 C01685-2020 21b9a26e7aa00f960de8473cebbd6407 \n", + "\n", + " url \\\n", + "5 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "\n", + " disclosure_table \\\n", + "5 {\"Title of Each Class\": \"COMMON\", \"Subject of ... \n", + "\n", + " Background/Description of the Disclosure \\\n", + "5 Golden Plate Pte. Ltd. (GPPL), a wholly owned ... \n", + "\n", + " Subject of the Disclosure \n", + "5 Jollibee Foods Corporation (JFC) and Dim Sum P... " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#disclosures co-incident with max percent change\n", + "maximum = dpse.filter_disclosures()\n", + "maximum" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "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", + " \n", + " \n", + " \n", + "
Company NameTemplate NamePSE Form NumberAnnounce Date and TimeCircular Numberedge_nourldisclosure_tableBackground/Description of the DisclosureSubject of the Disclosure
0Jollibee Foods CorporationPress Release4-312020-04-15 07:41:00C02771-20202fd88ba354823b280de8473cebbd6407https://edge.pse.com.ph/openDiscViewer.do?edge...{\"Title of Each Class\": \"Common\", \"Subject of ...JFC Reports 2019 Results Based on Audited Fina...Press Release: 2019 Audited Financial Results
\n", + "
" + ], + "text/plain": [ + " Company Name Template Name PSE Form Number \\\n", + "0 Jollibee Foods Corporation Press Release 4-31 \n", + "\n", + " Announce Date and Time Circular Number edge_no \\\n", + "0 2020-04-15 07:41:00 C02771-2020 2fd88ba354823b280de8473cebbd6407 \n", + "\n", + " url \\\n", + "0 https://edge.pse.com.ph/openDiscViewer.do?edge... \n", + "\n", + " disclosure_table \\\n", + "0 {\"Title of Each Class\": \"Common\", \"Subject of ... \n", + "\n", + " Background/Description of the Disclosure \\\n", + "0 JFC Reports 2019 Results Based on Audited Fina... \n", + "\n", + " Subject of the Disclosure \n", + "0 Press Release: 2019 Audited Financial Results " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#disclosures co-incident with min percent change\n", + "minimum = dpse.filter_disclosures(operation='min')\n", + "minimum" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Golden Plate Pte. Ltd. (GPPL), a wholly owned subsidiary of JFC, and DSPL executed a Joint Venture Agreement to establish a joint venture company (the “JV”) to be incorporated in the People’s Republic of China (PRC). The JV shall sign a Unit Franchise Agreement with Tim Ho Wan Pte. Ltd. (“Franchisor”), authorized master franchisor of Tim Ho Wan in the Asia-Pacific, to develop and operate Tim Ho Wan stores in Shanghai and such other cities within the PRC as may be agreed with the Franchisor.'],\n", + " dtype=object)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#what happened then?\n", + "maximum['Background/Description of the Disclosure'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Jollibee Foods Corporation (JFC) and Dim Sum Pte. Ltd. (DSPL) Signs Agreement to Expand and Operate the Tim Ho Wan Brand in China.'],\n", + " dtype=object)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#details\n", + "maximum['Subject of the Disclosure'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['https://edge.pse.com.ph/openDiscViewer.do?edge_no=21b9a26e7aa00f960de8473cebbd6407'],\n", + " dtype=object)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get url\n", + "maximum['url'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['JFC Reports 2019 Results Based on Audited Financial Statements'],\n", + " dtype=object)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#what happened during minimum?\n", + "minimum['Background/Description of the Disclosure'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Press Release: 2019 Audited Financial Results'], dtype=object)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#details\n", + "minimum['Subject of the Disclosure'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['https://edge.pse.com.ph/openDiscViewer.do?edge_no=2fd88ba354823b280de8473cebbd6407'],\n", + " dtype=object)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get url\n", + "minimum['url'].values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Investagrams disclosures" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from fastquant import DisclosuresInvestagrams" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "dinv = DisclosuresInvestagrams(symbol='JFC', from_date='2018-01-01', to_date='2020-04-01')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "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", + " \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", + " \n", + " \n", + "
idtimecolorlabelCash DividendsEx-DateRecord DatePayment Date
0timediv6072018-04-19#0496FFD1.14Thu Apr 19, 2018Tue Apr 24, 2018Wed May 09, 2018
1timediv7862018-11-21#0496FFD1.34Wed Nov 21, 2018Mon Nov 26, 2018Mon Dec 10, 2018
2timediv9342019-04-23#0496FFD1.23Tue Apr 23, 2019Fri Apr 26, 2019Thu May 09, 2019
3timediv11122019-11-21#0496FFD1.35Thu Nov 21, 2019Tue Nov 26, 2019Tue Dec 10, 2019
\n", + "
" + ], + "text/plain": [ + " id time color label Cash Dividends Ex-Date \\\n", + "0 timediv607 2018-04-19 #0496FF D 1.14 Thu Apr 19, 2018 \n", + "1 timediv786 2018-11-21 #0496FF D 1.34 Wed Nov 21, 2018 \n", + "2 timediv934 2019-04-23 #0496FF D 1.23 Tue Apr 23, 2019 \n", + "3 timediv1112 2019-11-21 #0496FF D 1.35 Thu Nov 21, 2019 \n", + "\n", + " Record Date Payment Date \n", + "0 Tue Apr 24, 2018 Wed May 09, 2018 \n", + "1 Mon Nov 26, 2018 Mon Dec 10, 2018 \n", + "2 Fri Apr 26, 2019 Thu May 09, 2019 \n", + "3 Tue Nov 26, 2019 Tue Dec 10, 2019 " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dinv.dividends" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "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", + " \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", + " \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", + " \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", + " \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", + " \n", + "
idtimecolorlabelTotal RevenueNet IncomeEPSDatePeriod EndingRevenue UnitNI UnitNet Income AmountNet Income YoY Growth (%)
0timeearnings48201752018-04-11 06:26:00#DC143CE133.396.67B (10.23%)6.58Wed Apr 11, 2018Dec 31, 2017BB (%)6.6710.23
1timeearnings48201812018-05-10 00:32:00#DC143CE35.051.67B (13.14%)1.66Thu May 10, 2018Mar 31, 2018BB (%)1.6713.14
2timeearnings48201822018-08-14 01:21:00#DC143CE40.782.1B (10.55%)2.07Tue Aug 14, 2018Jun 30, 2018BB (%)2.1010.55
3timeearnings48201832018-11-12 05:18:00#DC143CE40.491.93B (26.90%)1.87Mon Nov 12, 2018Sep 30, 2018BB (%)1.9326.90
4timeearnings48201852019-04-11 00:33:00#DC143CE164.357.77B (16.47%)7.66Thu Apr 11, 2019Dec 31, 2018BB (%)7.7716.47
5timeearnings48201912019-05-15 06:37:00#DC143CE40.621.43B (-14.06%)1.41Wed May 15, 2019Mar 31, 2019BB (-%)1.43-14.06
6timeearnings48201922019-08-05 07:13:00#DC143CE44.22985.48M (-53.10%)1.03Mon Aug 05, 2019Jun 30, 2019BM (-%)985.48-53.10
7timeearnings48201932019-11-14 03:46:00#DC143CE45.172.01B (4.48%)1.71Thu Nov 14, 2019Sep 30, 2019BB (%)2.014.48
\n", + "
" + ], + "text/plain": [ + " id time color label Total Revenue \\\n", + "0 timeearnings4820175 2018-04-11 06:26:00 #DC143C E 133.39 \n", + "1 timeearnings4820181 2018-05-10 00:32:00 #DC143C E 35.05 \n", + "2 timeearnings4820182 2018-08-14 01:21:00 #DC143C E 40.78 \n", + "3 timeearnings4820183 2018-11-12 05:18:00 #DC143C E 40.49 \n", + "4 timeearnings4820185 2019-04-11 00:33:00 #DC143C E 164.35 \n", + "5 timeearnings4820191 2019-05-15 06:37:00 #DC143C E 40.62 \n", + "6 timeearnings4820192 2019-08-05 07:13:00 #DC143C E 44.22 \n", + "7 timeearnings4820193 2019-11-14 03:46:00 #DC143C E 45.17 \n", + "\n", + " Net Income EPS Date Period Ending Revenue Unit \\\n", + "0 6.67B (10.23%) 6.58 Wed Apr 11, 2018 Dec 31, 2017 B \n", + "1 1.67B (13.14%) 1.66 Thu May 10, 2018 Mar 31, 2018 B \n", + "2 2.1B (10.55%) 2.07 Tue Aug 14, 2018 Jun 30, 2018 B \n", + "3 1.93B (26.90%) 1.87 Mon Nov 12, 2018 Sep 30, 2018 B \n", + "4 7.77B (16.47%) 7.66 Thu Apr 11, 2019 Dec 31, 2018 B \n", + "5 1.43B (-14.06%) 1.41 Wed May 15, 2019 Mar 31, 2019 B \n", + "6 985.48M (-53.10%) 1.03 Mon Aug 05, 2019 Jun 30, 2019 B \n", + "7 2.01B (4.48%) 1.71 Thu Nov 14, 2019 Sep 30, 2019 B \n", + "\n", + " NI Unit Net Income Amount Net Income YoY Growth (%) \n", + "0 B (%) 6.67 10.23 \n", + "1 B (%) 1.67 13.14 \n", + "2 B (%) 2.10 10.55 \n", + "3 B (%) 1.93 26.90 \n", + "4 B (%) 7.77 16.47 \n", + "5 B (-%) 1.43 -14.06 \n", + "6 M (-%) 985.48 -53.10 \n", + "7 B (%) 2.01 4.48 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dinv.earnings" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/2020-04-20-backtest_with_grid_search.ipynb b/dependencies/fastquant/examples/2020-04-20-backtest_with_grid_search.ipynb new file mode 100644 index 0000000..d0d09fc --- /dev/null +++ b/dependencies/fastquant/examples/2020-04-20-backtest_with_grid_search.ipynb @@ -0,0 +1,4184 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"# backtesting with grid search\"\n", + "> \"Easily backtest a grid of parameters in a given trading strategy\"\n", + "\n", + "- toc: true\n", + "- branch: master\n", + "- badges: true\n", + "- comments: true\n", + "- author: Jerome de Leon\n", + "- categories: [grid search, backtest]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment to install in colab\n", + "# !pip3 install fastquant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## backtest SMAC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`fastquant` offers a convenient way to backtest several trading strategies. To backtest using Simple Moving Average Crossover (`SMAC`), we do the following.\n", + "\n", + "```python\n", + "backtest('smac', dcv_data, fast_period=15, slow_period=40)\n", + "```\n", + "\n", + "`fast_period` and `slow_period` are two `SMAC` parameters that can be changed depending on the user's preferences. A simple way to fine tune these parameters is to run `backtest` on a grid of values and find which combination of `fast_period` and `slow_period` yields the highest net profit.\n", + "\n", + "First, we fetch `JFC`'s historical data comprised of date, close price, and volume." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "849it [04:08, 4.04it/s]\n" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
closevolume
dt
2018-01-03255.4745780
2018-01-04255.0617010
2018-01-05255.0946040
2018-01-08256.0840630
2018-01-09255.8978180
\n", + "
" + ], + "text/plain": [ + " close volume\n", + "dt \n", + "2018-01-03 255.4 745780\n", + "2018-01-04 255.0 617010\n", + "2018-01-05 255.0 946040\n", + "2018-01-08 256.0 840630\n", + "2018-01-09 255.8 978180" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from fastquant import get_stock_data, backtest\n", + "\n", + "symbol='JFC'\n", + "dcv_data = get_stock_data(symbol, \n", + " start_date='2018-01-01', \n", + " end_date='2020-04-28',\n", + " format='cv',\n", + " )\n", + "dcv_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as pl\n", + "pl.style.use(\"default\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + "Final PnL: -31257.65\n", + "Time used (seconds): 0.10944700241088867\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'fast_period': 15, 'slow_period': 40}\n", + "Optimal metrics: {'rtot': -0.37480465562458976, 'ravg': -0.0006645472617457265, 'rnorm': -0.15419454966091925, 'rnorm100': -15.419454966091925, 'sharperatio': -0.9821454406209409, 'pnl': -31257.65, 'final_value': 68742.35499999995}\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.colors as mcolors\n", + "import matplotlib.pyplot as pl\n", + "pl.style.use(\"default\")\n", + "\n", + "fig, ax = pl.subplots(1,1, figsize=(8,4))\n", + "xmin, xmax = slow_periods[0],slow_periods[-1]\n", + "ymin, ymax = fast_periods[0],fast_periods[-1]\n", + "\n", + "#make a diverging color map such that profit<0 is red and blue otherwise\n", + "cmap = pl.get_cmap('RdBu')\n", + "norm = mcolors.TwoSlopeNorm(vmin=period_grid.min(), \n", + " vmax = period_grid.max(), \n", + " vcenter=0\n", + " )\n", + "#plot matrix\n", + "cbar = ax.imshow(period_grid, \n", + " origin='lower', \n", + " interpolation='none', \n", + " extent=[xmin, xmax, ymin, ymax], \n", + " cmap=cmap,\n", + " norm=norm\n", + " )\n", + "pl.colorbar(cbar, ax=ax, shrink=0.9,\n", + " label='net profit', orientation=\"horizontal\")\n", + "\n", + "# search position with highest net profit\n", + "y, x = np.unravel_index(np.argmax(period_grid), period_grid.shape)\n", + "best_slow_period = slow_periods[x]\n", + "best_fast_period = fast_periods[y]\n", + "# mark position\n", + "# ax.annotate(f\"max profit={period_grid[y, x]:.0f}@({best_slow_period}, {best_fast_period}) days\", \n", + "# (best_slow_period+5,best_fast_period+1)\n", + "# )\n", + "ax.axvline(best_slow_period, 0, 1, c='k', ls='--')\n", + "ax.axhline(best_fast_period+0.5, 0, 1, c='k', ls='--')\n", + "\n", + "# add labels\n", + "ax.set_aspect(5)\n", + "pl.setp(ax,\n", + " xlim=(xmin,xmax),\n", + " ylim=(ymin,ymax),\n", + " xlabel='slow period (days)',\n", + " ylabel='fast period (days)',\n", + " title='JFC w/ SMAC',\n", + " );" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max profit=7042 @ (105,3) days\n" + ] + } + ], + "source": [ + "print(f\"max profit={period_grid[y, x]:.0f} @ ({best_slow_period},{best_fast_period}) days\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the plot above, there are only a few period combinations which we can guarantee non-negative net profit using SMAC strategy. The best result is achieved with (105,30) for period_slow and period_fast, respectively.\n", + "\n", + "In fact SMAC strategy is so bad such that there is only 9% chance it will yield profit when using any random period combinations in our grid, which is smaller than the 12% chance it will yield break even at least." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "9.005847953216374" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "percent_positive_profit=(period_grid>0).sum()/np.product(period_grid.shape)*100\n", + "percent_positive_profit" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12.397660818713451" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "percent_breakeven=(period_grid==0).sum()/np.product(period_grid.shape)*100\n", + "percent_breakeven" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Anyway, let's check the results of backtest using the `best_fast_period` and `best_slow_period`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Portfolio Value: 100000.00\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 3\n", + "slow_period : 105\n", + "2018-08-22, BUY CREATE, 286.00\n", + "2018-08-22, Cash: 100000.0\n", + "2018-08-22, Price: 286.0\n", + "2018-08-22, Buy prop size: 346\n", + "2018-08-22, Afforded size: 346\n", + "2018-08-22, Final size: 346\n", + "2018-08-23, BUY EXECUTED, Price: 286.00, Cost: 98956.00, Comm 742.17\n", + "2018-09-12, SELL CREATE, 277.00\n", + "2018-09-13, SELL EXECUTED, Price: 277.00, Cost: 98956.00, Comm 718.81\n", + "2018-09-13, OPERATION PROFIT, GROSS -3114.00, NET -4574.98\n", + "2018-10-23, BUY CREATE, 268.00\n", + "2018-10-23, Cash: 95425.015\n", + "2018-10-23, Price: 268.0\n", + "2018-10-23, Buy prop size: 353\n", + "2018-10-23, Afforded size: 353\n", + "2018-10-23, Final size: 353\n", + "2018-10-24, BUY EXECUTED, Price: 268.00, Cost: 94604.00, Comm 709.53\n", + "2018-10-25, SELL CREATE, 270.00\n", + "2018-10-26, SELL EXECUTED, Price: 270.00, Cost: 94604.00, Comm 714.83\n", + "2018-10-26, OPERATION PROFIT, GROSS 706.00, NET -718.36\n", + "2018-10-30, BUY CREATE, 264.00\n", + "2018-10-30, Cash: 94706.66\n", + "2018-10-30, Price: 264.0\n", + "2018-10-30, Buy prop size: 355\n", + "2018-10-30, Afforded size: 355\n", + "2018-10-30, Final size: 355\n", + "2018-10-31, BUY EXECUTED, Price: 264.00, Cost: 93720.00, Comm 702.90\n", + "2019-04-17, SELL CREATE, 303.00\n", + "2019-04-22, SELL EXECUTED, Price: 303.00, Cost: 93720.00, Comm 806.74\n", + "2019-04-22, OPERATION PROFIT, GROSS 13845.00, NET 12335.36\n", + "Final PnL: 7042.02\n", + "==================================================\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'fast_period': 3, 'slow_period': 105}\n", + "OrderedDict([('rtot', 0.06805130501900258), ('ravg', 0.00012065834223227409), ('rnorm', 0.03087288265827186), ('rnorm100', 3.087288265827186)])\n", + "OrderedDict([('sharperatio', 0.7850452330792583)])\n", + "Time used (seconds): 0.11643362045288086\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'fast_period': 3, 'slow_period': 105}\n", + "Optimal metrics: {'rtot': 0.06805130501900258, 'ravg': 0.00012065834223227409, 'rnorm': 0.03087288265827186, 'rnorm100': 3.087288265827186, 'sharperatio': 0.7850452330792583, 'pnl': 7042.02, 'final_value': 107042.0225}\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = pl.subplots(1,1, figsize=(8,4))\n", + "\n", + "#make a diverging color map such that profit<0 is red and blue otherwise\n", + "cmap = pl.get_cmap('RdBu')\n", + "norm = mcolors.TwoSlopeNorm(vmin=period_grid.min(), \n", + " vmax = period_grid.max(), \n", + " vcenter=0\n", + " )\n", + "#plot scatter\n", + "results['net_profit'] = results['final_value']-results['init_cash']\n", + "df = results[['slow_period','fast_period','net_profit']]\n", + "ax2 = df.plot.scatter(x='slow_period', y='fast_period', c='net_profit',\n", + " norm=norm, cmap=cmap, ax=ax\n", + " )\n", + "ymin,ymax = df.fast_period.min(), df.fast_period.max()\n", + "xmin,xmax = df.slow_period.min(), df.slow_period.max()\n", + "\n", + "# best performance (instead of highest profit)\n", + "best_fast_period, best_slow_period, net_profit = df.loc[0,['fast_period','slow_period','net_profit']]\n", + "# mark position\n", + "# ax.annotate(f\"max profit={net_profit:.0f}@({best_slow_period}, {best_fast_period}) days\", \n", + "# (best_slow_period-100,best_fast_period+1), color='r'\n", + "# )\n", + "ax.axvline(best_slow_period, 0, 1, c='r', ls='--')\n", + "ax.axhline(best_fast_period+0.5, 0, 1, c='r', ls='--')\n", + "\n", + "ax.set_aspect(5)\n", + "pl.setp(ax,\n", + " xlim=(xmin,xmax),\n", + " ylim=(ymin,ymax),\n", + " xlabel='slow period (days)',\n", + " ylabel='fast period (days)',\n", + " title='JFC w/ SMAC',\n", + " );\n", + "\n", + "# fig.colorbar(ax2, orientation=\"horizontal\", shrink=0.9, label='net profit')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max profit=7042 @ (105.0,3.0) days\n" + ] + } + ], + "source": [ + "print(f\"max profit={net_profit:.0f} @ ({best_slow_period},{best_fast_period}) days\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note also that built-in grid search in `backtest` is optimized and slightly faster than the basic loop-based grid search." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0497938879462785" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#time\n", + "time_basic/time_optimized" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final notes\n", + "\n", + "While it is tempting to do a grid search over larger search space and finer resolutions, it is computationally expensive, inefficient, and prone to overfitting. There are better methods than brute force grid search which we will tackle in the next example.\n", + "\n", + "As an exercise, it is good to try the following:\n", + "* Use different trading strategies and compare their results\n", + "* Use a longer data baseline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/2020-05-10-backtest_multi_strategy.ipynb b/dependencies/fastquant/examples/2020-05-10-backtest_multi_strategy.ipynb new file mode 100644 index 0000000..ea764b8 --- /dev/null +++ b/dependencies/fastquant/examples/2020-05-10-backtest_multi_strategy.ipynb @@ -0,0 +1,1437 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"backtesting a grid of multi-strategy parameters\"\n", + "> \"multi-strategy parameter optimization cannot be easier than this\"\n", + "\n", + "- toc: true\n", + "- branch: master\n", + "- badges: true\n", + "- comments: true\n", + "- author: Jerome de Leon\n", + "- categories: [backtest, grid search, multi-strat]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment to install in colab\n", + "# !pip3 install fastquant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define strategies in a dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Portfolio Value: 100000.00\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 35\n", + "slow_period : 50\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 30\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 100000.0\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 395\n", + "2018-07-06, Afforded size: 395\n", + "2018-07-06, Final size: 395\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 99145.00, Comm 743.59\n", + "2018-08-01, SELL CREATE, 276.00\n", + "2018-08-02, SELL EXECUTED, Price: 276.00, Cost: 99145.00, Comm 817.65\n", + "2018-08-02, OPERATION PROFIT, GROSS 9875.00, NET 8313.76\n", + "2018-08-29, BUY CREATE, 287.40\n", + "2018-08-29, Cash: 108313.76250000001\n", + "2018-08-29, Price: 287.4\n", + "2018-08-29, Buy prop size: 373\n", + "2018-08-29, Afforded size: 373\n", + "2018-08-29, Final size: 373\n", + "2018-08-30, BUY EXECUTED, Price: 287.40, Cost: 107200.20, Comm 804.00\n", + "2018-10-08, SELL CREATE, 252.40\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 309.5610000000147\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 1\n", + "2018-10-08, Afforded size: 1\n", + "2018-10-08, Final size: 1\n", + "2018-10-09, SELL EXECUTED, Price: 252.40, Cost: 107200.20, Comm 706.09\n", + "2018-10-09, OPERATION PROFIT, GROSS -13055.00, NET -14565.09\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 243.00, Comm 1.82\n", + "2018-11-22, BUY CREATE, 285.00\n", + "2018-11-22, Cash: 93503.84950000003\n", + "2018-11-22, Price: 285.0\n", + "2018-11-22, Buy prop size: 325\n", + "2018-11-22, Afforded size: 325\n", + "2018-11-22, Final size: 325\n", + "2018-11-23, BUY EXECUTED, Price: 285.00, Cost: 92625.00, Comm 694.69\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 92868.00, Comm 740.83\n", + "Final PnL: -1778.67\n", + "Final PnL: -1778.67\n", + "==================================================\n", + "Number of strat runs: 1\n", + "Number of strats per run: 2\n", + "Strat names: ['smac', 'rsi']\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 35, 'smac.slow_period': 50, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', -0.0179468149815959), ('ravg', -7.385520568557983e-05), ('rnorm', -0.018439387134145634), ('rnorm100', -1.8439387134145633)])\n", + "OrderedDict([('sharperatio', None)])\n", + "Time used (seconds): 0.06001472473144531\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 35, 'smac.slow_period': 50, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "Optimal metrics: {'rtot': -0.0179468149815959, 'ravg': -7.385520568557983e-05, 'rnorm': -0.018439387134145634, 'rnorm100': -1.8439387134145633, 'sharperatio': None, 'pnl': -1778.67, 'final_value': 98221.32700000002}\n" + ] + }, + { + "data": { + "text/plain": [ + "(1, 16)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from fastquant import backtest, get_stock_data\n", + "df = get_stock_data(\"JFC\", \"2018-01-01\", \"2019-01-01\")\n", + "\n", + "# Utilize single set of parameters\n", + "strats = { \n", + " \"smac\": {\"fast_period\": 35, \"slow_period\": 50}, \n", + " \"rsi\": {\"rsi_lower\": 30, \"rsi_upper\": 70}\n", + "} \n", + "res = backtest(\"multi\", df, strats=strats)\n", + "res.shape\n", + "# (1, 16)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Utilize auto grid search" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Portfolio Value: 100000.00\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 20\n", + "2018-04-12, BUY CREATE, 300.00\n", + "2018-04-12, Cash: 100000.0\n", + "2018-04-12, Price: 300.0\n", + "2018-04-12, Buy prop size: 330\n", + "2018-04-12, Afforded size: 330\n", + "2018-04-12, Final size: 330\n", + "2018-04-13, BUY EXECUTED, Price: 300.00, Cost: 99000.00, Comm 742.50\n", + "2018-04-13, SELL CREATE, 291.60\n", + "2018-04-16, SELL EXECUTED, Price: 291.60, Cost: 99000.00, Comm 721.71\n", + "2018-04-16, OPERATION PROFIT, GROSS -2772.00, NET -4236.21\n", + "2018-08-03, BUY CREATE, 277.00\n", + "2018-08-03, Cash: 95763.79\n", + "2018-08-03, Price: 277.0\n", + "2018-08-03, Buy prop size: 342\n", + "2018-08-03, Afforded size: 342\n", + "2018-08-03, Final size: 342\n", + "2018-08-06, BUY EXECUTED, Price: 277.00, Cost: 94734.00, Comm 710.50\n", + "2018-09-19, SELL CREATE, 271.00\n", + "2018-09-20, SELL EXECUTED, Price: 271.00, Cost: 94734.00, Comm 695.12\n", + "2018-09-20, OPERATION PROFIT, GROSS -2052.00, NET -3457.62\n", + "2018-10-30, BUY CREATE, 264.00\n", + "2018-10-30, Cash: 92306.16999999998\n", + "2018-10-30, Price: 264.0\n", + "2018-10-30, Buy prop size: 346\n", + "2018-10-30, Afforded size: 346\n", + "2018-10-30, Final size: 346\n", + "2018-10-31, BUY EXECUTED, Price: 264.00, Cost: 91344.00, Comm 685.08\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 91344.00, Comm 786.28\n", + "Final PnL: 4328.8\n", + "Final PnL: 4328.8\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 20\n", + "2018-04-12, BUY CREATE, 300.00\n", + "2018-04-12, Cash: 100000.0\n", + "2018-04-12, Price: 300.0\n", + "2018-04-12, Buy prop size: 330\n", + "2018-04-12, Afforded size: 330\n", + "2018-04-12, Final size: 330\n", + "2018-04-13, BUY EXECUTED, Price: 300.00, Cost: 99000.00, Comm 742.50\n", + "2018-04-13, SELL CREATE, 291.60\n", + "2018-04-16, SELL EXECUTED, Price: 291.60, Cost: 99000.00, Comm 721.71\n", + "2018-04-16, OPERATION PROFIT, GROSS -2772.00, NET -4236.21\n", + "2018-08-03, BUY CREATE, 277.00\n", + "2018-08-03, Cash: 95763.79\n", + "2018-08-03, Price: 277.0\n", + "2018-08-03, Buy prop size: 342\n", + "2018-08-03, Afforded size: 342\n", + "2018-08-03, Final size: 342\n", + "2018-08-06, BUY EXECUTED, Price: 277.00, Cost: 94734.00, Comm 710.50\n", + "2018-09-19, SELL CREATE, 271.00\n", + "2018-09-20, SELL EXECUTED, Price: 271.00, Cost: 94734.00, Comm 695.12\n", + "2018-09-20, OPERATION PROFIT, GROSS -2052.00, NET -3457.62\n", + "2018-10-30, BUY CREATE, 264.00\n", + "2018-10-30, Cash: 92306.16999999998\n", + "2018-10-30, Price: 264.0\n", + "2018-10-30, Buy prop size: 346\n", + "2018-10-30, Afforded size: 346\n", + "2018-10-30, Final size: 346\n", + "2018-10-31, BUY EXECUTED, Price: 264.00, Cost: 91344.00, Comm 685.08\n", + "Final PnL: 1239.89\n", + "Final PnL: 1239.89\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 30\n", + "2018-04-12, BUY CREATE, 300.00\n", + "2018-04-12, Cash: 100000.0\n", + "2018-04-12, Price: 300.0\n", + "2018-04-12, Buy prop size: 330\n", + "2018-04-12, Afforded size: 330\n", + "2018-04-12, Final size: 330\n", + "2018-04-13, BUY EXECUTED, Price: 300.00, Cost: 99000.00, Comm 742.50\n", + "2018-04-13, SELL CREATE, 291.60\n", + "2018-04-16, SELL EXECUTED, Price: 291.60, Cost: 99000.00, Comm 721.71\n", + "2018-04-16, OPERATION PROFIT, GROSS -2772.00, NET -4236.21\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 95763.79\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 378\n", + "2018-07-06, Afforded size: 378\n", + "2018-07-06, Final size: 378\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 94878.00, Comm 711.59\n", + "2018-08-01, SELL CREATE, 276.00\n", + "2018-08-02, SELL EXECUTED, Price: 276.00, Cost: 94878.00, Comm 782.46\n", + "2018-08-02, OPERATION PROFIT, GROSS 9450.00, NET 7955.95\n", + "2018-08-03, BUY CREATE, 277.00\n", + "2018-08-03, Cash: 103719.74499999998\n", + "2018-08-03, Price: 277.0\n", + "2018-08-03, Buy prop size: 371\n", + "2018-08-03, Afforded size: 371\n", + "2018-08-03, Final size: 371\n", + "2018-08-06, BUY EXECUTED, Price: 277.00, Cost: 102767.00, Comm 770.75\n", + "2018-09-19, SELL CREATE, 271.00\n", + "2018-09-20, SELL EXECUTED, Price: 271.00, Cost: 102767.00, Comm 754.06\n", + "2018-09-20, OPERATION PROFIT, GROSS -2226.00, NET -3750.81\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 99968.93499999998\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 407\n", + "2018-10-08, Afforded size: 407\n", + "2018-10-08, Final size: 407\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 98901.00, Comm 741.76\n", + "2018-10-30, BUY CREATE, 264.00\n", + "2018-10-30, Cash: 326.1774999999832\n", + "2018-10-30, Price: 264.0\n", + "2018-10-30, Buy prop size: 1\n", + "2018-10-30, Afforded size: 1\n", + "2018-10-30, Final size: 1\n", + "2018-10-31, BUY EXECUTED, Price: 264.00, Cost: 264.00, Comm 1.98\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 99165.00, Comm 927.18\n", + "Final PnL: 22757.02\n", + "Final PnL: 22757.02\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 30\n", + "2018-04-12, BUY CREATE, 300.00\n", + "2018-04-12, Cash: 100000.0\n", + "2018-04-12, Price: 300.0\n", + "2018-04-12, Buy prop size: 330\n", + "2018-04-12, Afforded size: 330\n", + "2018-04-12, Final size: 330\n", + "2018-04-13, BUY EXECUTED, Price: 300.00, Cost: 99000.00, Comm 742.50\n", + "2018-04-13, SELL CREATE, 291.60\n", + "2018-04-16, SELL EXECUTED, Price: 291.60, Cost: 99000.00, Comm 721.71\n", + "2018-04-16, OPERATION PROFIT, GROSS -2772.00, NET -4236.21\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 95763.79\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 378\n", + "2018-07-06, Afforded size: 378\n", + "2018-07-06, Final size: 378\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 94878.00, Comm 711.59\n", + "2018-09-19, SELL CREATE, 271.00\n", + "2018-09-20, SELL EXECUTED, Price: 271.00, Cost: 94878.00, Comm 768.28\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 101843.91999999998\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 415\n", + "2018-10-08, Afforded size: 415\n", + "2018-10-08, Final size: 415\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 100845.00, Comm 756.34\n", + "Final PnL: 21339.58\n", + "Final PnL: 21339.58\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 20\n", + "2018-04-23, BUY CREATE, 294.00\n", + "2018-04-23, Cash: 100000.0\n", + "2018-04-23, Price: 294.0\n", + "2018-04-23, Buy prop size: 337\n", + "2018-04-23, Afforded size: 337\n", + "2018-04-23, Final size: 337\n", + "2018-04-24, BUY EXECUTED, Price: 294.00, Cost: 99078.00, Comm 743.08\n", + "2018-04-26, SELL CREATE, 282.00\n", + "2018-04-27, SELL EXECUTED, Price: 282.00, Cost: 99078.00, Comm 712.75\n", + "2018-04-27, OPERATION PROFIT, GROSS -4044.00, NET -5499.84\n", + "2018-08-08, BUY CREATE, 276.80\n", + "2018-08-08, Cash: 94500.15999999999\n", + "2018-08-08, Price: 276.8\n", + "2018-08-08, Buy prop size: 338\n", + "2018-08-08, Afforded size: 338\n", + "2018-08-08, Final size: 338\n", + "2018-08-09, BUY EXECUTED, Price: 276.80, Cost: 93558.40, Comm 701.69\n", + "2018-09-28, SELL CREATE, 252.00\n", + "2018-10-01, SELL EXECUTED, Price: 252.00, Cost: 93558.40, Comm 638.82\n", + "2018-10-01, OPERATION PROFIT, GROSS -8382.40, NET -9722.91\n", + "2018-11-06, BUY CREATE, 278.60\n", + "2018-11-06, Cash: 84777.25199999998\n", + "2018-11-06, Price: 278.6\n", + "2018-11-06, Buy prop size: 301\n", + "2018-11-06, Afforded size: 301\n", + "2018-11-06, Final size: 301\n", + "2018-11-07, BUY EXECUTED, Price: 278.60, Cost: 83858.60, Comm 628.94\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 83858.60, Comm 684.02\n", + "Final PnL: -9191.31\n", + "Final PnL: -9191.31\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 20\n", + "2018-04-23, BUY CREATE, 294.00\n", + "2018-04-23, Cash: 100000.0\n", + "2018-04-23, Price: 294.0\n", + "2018-04-23, Buy prop size: 337\n", + "2018-04-23, Afforded size: 337\n", + "2018-04-23, Final size: 337\n", + "2018-04-24, BUY EXECUTED, Price: 294.00, Cost: 99078.00, Comm 743.08\n", + "2018-04-26, SELL CREATE, 282.00\n", + "2018-04-27, SELL EXECUTED, Price: 282.00, Cost: 99078.00, Comm 712.75\n", + "2018-04-27, OPERATION PROFIT, GROSS -4044.00, NET -5499.84\n", + "2018-08-08, BUY CREATE, 276.80\n", + "2018-08-08, Cash: 94500.15999999999\n", + "2018-08-08, Price: 276.8\n", + "2018-08-08, Buy prop size: 338\n", + "2018-08-08, Afforded size: 338\n", + "2018-08-08, Final size: 338\n", + "2018-08-09, BUY EXECUTED, Price: 276.80, Cost: 93558.40, Comm 701.69\n", + "2018-09-28, SELL CREATE, 252.00\n", + "2018-10-01, SELL EXECUTED, Price: 252.00, Cost: 93558.40, Comm 638.82\n", + "2018-10-01, OPERATION PROFIT, GROSS -8382.40, NET -9722.91\n", + "2018-11-06, BUY CREATE, 278.60\n", + "2018-11-06, Cash: 84777.25199999998\n", + "2018-11-06, Price: 278.6\n", + "2018-11-06, Buy prop size: 301\n", + "2018-11-06, Afforded size: 301\n", + "2018-11-06, Final size: 301\n", + "2018-11-07, BUY EXECUTED, Price: 278.60, Cost: 83858.60, Comm 628.94\n", + "Final PnL: -11878.49\n", + "Final PnL: -11878.49\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 30\n", + "2018-04-23, BUY CREATE, 294.00\n", + "2018-04-23, Cash: 100000.0\n", + "2018-04-23, Price: 294.0\n", + "2018-04-23, Buy prop size: 337\n", + "2018-04-23, Afforded size: 337\n", + "2018-04-23, Final size: 337\n", + "2018-04-24, BUY EXECUTED, Price: 294.00, Cost: 99078.00, Comm 743.08\n", + "2018-04-26, SELL CREATE, 282.00\n", + "2018-04-27, SELL EXECUTED, Price: 282.00, Cost: 99078.00, Comm 712.75\n", + "2018-04-27, OPERATION PROFIT, GROSS -4044.00, NET -5499.84\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 94500.15999999999\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 373\n", + "2018-07-06, Afforded size: 373\n", + "2018-07-06, Final size: 373\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 93623.00, Comm 702.17\n", + "2018-08-01, SELL CREATE, 276.00\n", + "2018-08-02, SELL EXECUTED, Price: 276.00, Cost: 93623.00, Comm 772.11\n", + "2018-08-02, OPERATION PROFIT, GROSS 9325.00, NET 7850.72\n", + "2018-08-08, BUY CREATE, 276.80\n", + "2018-08-08, Cash: 102350.87749999999\n", + "2018-08-08, Price: 276.8\n", + "2018-08-08, Buy prop size: 366\n", + "2018-08-08, Afforded size: 366\n", + "2018-08-08, Final size: 366\n", + "2018-08-09, BUY EXECUTED, Price: 276.80, Cost: 101308.80, Comm 759.82\n", + "2018-09-28, SELL CREATE, 252.00\n", + "2018-10-01, SELL EXECUTED, Price: 252.00, Cost: 101308.80, Comm 691.74\n", + "2018-10-01, OPERATION PROFIT, GROSS -9076.80, NET -10528.36\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 91822.52149999997\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 374\n", + "2018-10-08, Afforded size: 374\n", + "2018-10-08, Final size: 374\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 90882.00, Comm 681.61\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 90882.00, Comm 849.91\n", + "2018-12-20, OPERATION PROFIT, GROSS 22440.00, NET 20908.47\n", + "Final PnL: 12730.99\n", + "Final PnL: 12730.99\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 10\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2018-04-23, BUY CREATE, 294.00\n", + "2018-04-23, Cash: 100000.0\n", + "2018-04-23, Price: 294.0\n", + "2018-04-23, Buy prop size: 337\n", + "2018-04-23, Afforded size: 337\n", + "2018-04-23, Final size: 337\n", + "2018-04-24, BUY EXECUTED, Price: 294.00, Cost: 99078.00, Comm 743.08\n", + "2018-04-26, SELL CREATE, 282.00\n", + "2018-04-27, SELL EXECUTED, Price: 282.00, Cost: 99078.00, Comm 712.75\n", + "2018-04-27, OPERATION PROFIT, GROSS -4044.00, NET -5499.84\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 94500.15999999999\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 373\n", + "2018-07-06, Afforded size: 373\n", + "2018-07-06, Final size: 373\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 93623.00, Comm 702.17\n", + "2018-09-28, SELL CREATE, 252.00\n", + "2018-10-01, SELL EXECUTED, Price: 252.00, Cost: 93623.00, Comm 704.97\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 93466.01749999999\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 381\n", + "2018-10-08, Afforded size: 381\n", + "2018-10-08, Final size: 381\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 92583.00, Comm 694.37\n", + "Final PnL: 11364.44\n", + "Final PnL: 11364.44\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 20\n", + "2018-08-07, BUY CREATE, 270.00\n", + "2018-08-07, Cash: 100000.0\n", + "2018-08-07, Price: 270.0\n", + "2018-08-07, Buy prop size: 367\n", + "2018-08-07, Afforded size: 367\n", + "2018-08-07, Final size: 367\n", + "2018-08-08, BUY EXECUTED, Price: 270.00, Cost: 99090.00, Comm 743.17\n", + "2018-09-21, SELL CREATE, 271.00\n", + "2018-09-24, SELL EXECUTED, Price: 271.00, Cost: 99090.00, Comm 745.93\n", + "2018-09-24, OPERATION PROFIT, GROSS 367.00, NET -1122.10\n", + "2018-11-05, BUY CREATE, 280.00\n", + "2018-11-05, Cash: 98877.89749999999\n", + "2018-11-05, Price: 280.0\n", + "2018-11-05, Buy prop size: 350\n", + "2018-11-05, Afforded size: 350\n", + "2018-11-05, Final size: 350\n", + "2018-11-06, BUY EXECUTED, Price: 280.00, Cost: 98000.00, Comm 735.00\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 98000.00, Comm 795.38\n", + "Final PnL: 5397.52\n", + "Final PnL: 5397.52\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 20\n", + "2018-08-07, BUY CREATE, 270.00\n", + "2018-08-07, Cash: 100000.0\n", + "2018-08-07, Price: 270.0\n", + "2018-08-07, Buy prop size: 367\n", + "2018-08-07, Afforded size: 367\n", + "2018-08-07, Final size: 367\n", + "2018-08-08, BUY EXECUTED, Price: 270.00, Cost: 99090.00, Comm 743.17\n", + "2018-09-21, SELL CREATE, 271.00\n", + "2018-09-24, SELL EXECUTED, Price: 271.00, Cost: 99090.00, Comm 745.93\n", + "2018-09-24, OPERATION PROFIT, GROSS 367.00, NET -1122.10\n", + "2018-11-05, BUY CREATE, 280.00\n", + "2018-11-05, Cash: 98877.89749999999\n", + "2018-11-05, Price: 280.0\n", + "2018-11-05, Buy prop size: 350\n", + "2018-11-05, Afforded size: 350\n", + "2018-11-05, Final size: 350\n", + "2018-11-06, BUY EXECUTED, Price: 280.00, Cost: 98000.00, Comm 735.00\n", + "Final PnL: 2272.9\n", + "Final PnL: 2272.9\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 30\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 100000.0\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 395\n", + "2018-07-06, Afforded size: 395\n", + "2018-07-06, Final size: 395\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 99145.00, Comm 743.59\n", + "2018-08-01, SELL CREATE, 276.00\n", + "2018-08-02, SELL EXECUTED, Price: 276.00, Cost: 99145.00, Comm 817.65\n", + "2018-08-02, OPERATION PROFIT, GROSS 9875.00, NET 8313.76\n", + "2018-08-07, BUY CREATE, 270.00\n", + "2018-08-07, Cash: 108313.76250000001\n", + "2018-08-07, Price: 270.0\n", + "2018-08-07, Buy prop size: 397\n", + "2018-08-07, Afforded size: 397\n", + "2018-08-07, Final size: 397\n", + "2018-08-08, BUY EXECUTED, Price: 270.00, Cost: 107190.00, Comm 803.92\n", + "2018-09-21, SELL CREATE, 271.00\n", + "2018-09-24, SELL EXECUTED, Price: 271.00, Cost: 107190.00, Comm 806.90\n", + "2018-09-24, OPERATION PROFIT, GROSS 397.00, NET -1213.83\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 107099.93500000001\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 437\n", + "2018-10-08, Afforded size: 437\n", + "2018-10-08, Final size: 437\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 106191.00, Comm 796.43\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 106191.00, Comm 993.08\n", + "2018-12-20, OPERATION PROFIT, GROSS 26220.00, NET 24430.49\n", + "Final PnL: 31530.42\n", + "Final PnL: 31530.42\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 30\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 100000.0\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 395\n", + "2018-07-06, Afforded size: 395\n", + "2018-07-06, Final size: 395\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 99145.00, Comm 743.59\n", + "2018-09-21, SELL CREATE, 271.00\n", + "2018-09-24, SELL EXECUTED, Price: 271.00, Cost: 99145.00, Comm 802.84\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 106353.57500000001\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 433\n", + "2018-10-08, Afforded size: 433\n", + "2018-10-08, Final size: 433\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 105219.00, Comm 789.14\n", + "2018-11-05, BUY CREATE, 280.00\n", + "2018-11-05, Cash: 345.4325000000116\n", + "2018-11-05, Price: 280.0\n", + "2018-11-05, Buy prop size: 1\n", + "2018-11-05, Afforded size: 1\n", + "2018-11-05, Final size: 1\n", + "2018-11-06, BUY EXECUTED, Price: 280.00, Cost: 280.00, Comm 2.10\n", + "Final PnL: 26704.53\n", + "Final PnL: 26704.53\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 20\n", + "2018-08-14, BUY CREATE, 273.40\n", + "2018-08-14, Cash: 100000.0\n", + "2018-08-14, Price: 273.4\n", + "2018-08-14, Buy prop size: 362\n", + "2018-08-14, Afforded size: 362\n", + "2018-08-14, Final size: 362\n", + "2018-08-15, BUY EXECUTED, Price: 273.40, Cost: 98970.80, Comm 742.28\n", + "2018-10-01, SELL CREATE, 250.00\n", + "2018-10-02, SELL EXECUTED, Price: 250.00, Cost: 98970.80, Comm 678.75\n", + "2018-10-02, OPERATION PROFIT, GROSS -8470.80, NET -9891.83\n", + "2018-11-08, BUY CREATE, 280.00\n", + "2018-11-08, Cash: 90108.16900000001\n", + "2018-11-08, Price: 280.0\n", + "2018-11-08, Buy prop size: 319\n", + "2018-11-08, Afforded size: 319\n", + "2018-11-08, Final size: 319\n", + "2018-11-09, BUY EXECUTED, Price: 280.00, Cost: 89320.00, Comm 669.90\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 89320.00, Comm 724.93\n", + "Final PnL: -3949.66\n", + "Final PnL: -3949.66\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 20\n", + "2018-08-14, BUY CREATE, 273.40\n", + "2018-08-14, Cash: 100000.0\n", + "2018-08-14, Price: 273.4\n", + "2018-08-14, Buy prop size: 362\n", + "2018-08-14, Afforded size: 362\n", + "2018-08-14, Final size: 362\n", + "2018-08-15, BUY EXECUTED, Price: 273.40, Cost: 98970.80, Comm 742.28\n", + "2018-10-01, SELL CREATE, 250.00\n", + "2018-10-02, SELL EXECUTED, Price: 250.00, Cost: 98970.80, Comm 678.75\n", + "2018-10-02, OPERATION PROFIT, GROSS -8470.80, NET -9891.83\n", + "2018-11-08, BUY CREATE, 280.00\n", + "2018-11-08, Cash: 90108.16900000001\n", + "2018-11-08, Price: 280.0\n", + "2018-11-08, Buy prop size: 319\n", + "2018-11-08, Afforded size: 319\n", + "2018-11-08, Final size: 319\n", + "2018-11-09, BUY EXECUTED, Price: 280.00, Cost: 89320.00, Comm 669.90\n", + "Final PnL: -6797.53\n", + "Final PnL: -6797.53\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 70\n", + "rsi_lower : 30\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 100000.0\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 395\n", + "2018-07-06, Afforded size: 395\n", + "2018-07-06, Final size: 395\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 99145.00, Comm 743.59\n", + "2018-08-01, SELL CREATE, 276.00\n", + "2018-08-02, SELL EXECUTED, Price: 276.00, Cost: 99145.00, Comm 817.65\n", + "2018-08-02, OPERATION PROFIT, GROSS 9875.00, NET 8313.76\n", + "2018-08-14, BUY CREATE, 273.40\n", + "2018-08-14, Cash: 108313.76250000001\n", + "2018-08-14, Price: 273.4\n", + "2018-08-14, Buy prop size: 392\n", + "2018-08-14, Afforded size: 392\n", + "2018-08-14, Final size: 392\n", + "2018-08-15, BUY EXECUTED, Price: 273.40, Cost: 107172.80, Comm 803.80\n", + "2018-10-01, SELL CREATE, 250.00\n", + "2018-10-02, SELL EXECUTED, Price: 250.00, Cost: 107172.80, Comm 735.00\n", + "2018-10-02, OPERATION PROFIT, GROSS -9172.80, NET -10711.60\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 97602.16650000002\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 398\n", + "2018-10-08, Afforded size: 398\n", + "2018-10-08, Final size: 398\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 96714.00, Comm 725.36\n", + "2018-12-19, SELL CREATE, 303.00\n", + "2018-12-20, SELL EXECUTED, Price: 303.00, Cost: 96714.00, Comm 904.45\n", + "2018-12-20, OPERATION PROFIT, GROSS 23880.00, NET 22250.19\n", + "Final PnL: 19852.36\n", + "Final PnL: 19852.36\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 60\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "===Strategy level arguments===\n", + "rsi_period : 14\n", + "rsi_upper : 80\n", + "rsi_lower : 30\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-06, Cash: 100000.0\n", + "2018-07-06, Price: 251.0\n", + "2018-07-06, Buy prop size: 395\n", + "2018-07-06, Afforded size: 395\n", + "2018-07-06, Final size: 395\n", + "2018-07-09, BUY EXECUTED, Price: 251.00, Cost: 99145.00, Comm 743.59\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2018-10-01, SELL CREATE, 250.00\n", + "2018-10-02, SELL EXECUTED, Price: 250.00, Cost: 99145.00, Comm 740.62\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-08, Cash: 98120.7875\n", + "2018-10-08, Price: 243.0\n", + "2018-10-08, Buy prop size: 400\n", + "2018-10-08, Afforded size: 400\n", + "2018-10-08, Final size: 400\n", + "2018-10-09, BUY EXECUTED, Price: 243.00, Cost: 97200.00, Comm 729.00\n", + "Final PnL: 16911.79\n", + "Final PnL: 16911.79\n", + "==================================================\n", + "Number of strat runs: 16\n", + "Number of strats per run: 2\n", + "Strat names: ['smac', 'rsi']\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', 0.042377312386123134), ('ravg', 0.000174392232041659), ('rnorm', 0.04492680768865365), ('rnorm100', 4.492680768865364)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', 0.012322663161177035), ('ravg', 5.071054798838286e-05), ('rnorm', 0.012861059182548444), ('rnorm100', 1.2861059182548444)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.2050367480952209), ('ravg', 0.0008437726259062589), ('rnorm', 0.23692777159818812), ('rnorm100', 23.69277715981881)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.19342289577512692), ('ravg', 0.00079597899495937), ('rnorm', 0.2221195736378016), ('rnorm100', 22.21195736378016)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', -0.0964152001144457), ('ravg', -0.0003967703708413403), ('rnorm', -0.0951500349055751), ('rnorm100', -9.51500349055751)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', -0.12645350010683382), ('ravg', -0.0005203847741021968), ('rnorm', -0.12290236382425088), ('rnorm100', -12.290236382425087)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.11983418838139474), ('ravg', 0.0004931448081538878), ('rnorm', 0.13232437790797075), ('rnorm100', 13.232437790797075)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 10, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.10763792539049269), ('ravg', 0.00044295442547527856), ('rnorm', 0.11809295492841805), ('rnorm100', 11.809295492841805)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', 0.052568944150307696), ('ravg', 0.00021633310349920864), ('rnorm', 0.05602931158519976), ('rnorm100', 5.602931158519977)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', 0.022474520295117782), ('ravg', 9.248773783999087e-05), ('rnorm', 0.02358063841261683), ('rnorm100', 2.358063841261683)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.2740679696753637), ('ravg', 0.0011278517270591098), ('rnorm', 0.3287234047301618), ('rnorm100', 32.87234047301618)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.23668767417980946), ('ravg', 0.0009740233505341953), ('rnorm', 0.2782013371264516), ('rnorm100', 27.820133712645163)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', -0.04029774133997106), ('ravg', -0.00016583432650193853), ('rnorm', -0.04092907566388783), ('rnorm100', -4.092907566388783)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 20}\n", + "OrderedDict([('rtot', -0.07039597323112812), ('ravg', -0.00028969536309106223), ('rnorm', -0.07040217397345756), ('rnorm100', -7.0402173973457565)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.18109043677660316), ('ravg', 0.0007452281348831406), ('rnorm', 0.20658914422764327), ('rnorm100', 20.658914422764326)])\n", + "OrderedDict([('sharperatio', None)])\n", + "**************************************************\n", + "--------------------------------------------------\n", + "{'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 60, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 80, 'rsi.rsi_lower': 30}\n", + "OrderedDict([('rtot', 0.15624951145271396), ('ravg', 0.0006430021047436788), ('rnorm', 0.1759031967451431), ('rnorm100', 17.59031967451431)])\n", + "OrderedDict([('sharperatio', None)])\n", + "Time used (seconds): 0.9437069892883301\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'execution_type': 'close', 'smac.fast_period': 15, 'smac.slow_period': 40, 'rsi.rsi_period': 14, 'rsi.rsi_upper': 70, 'rsi.rsi_lower': 30}\n", + "Optimal metrics: {'rtot': 0.2740679696753637, 'ravg': 0.0011278517270591098, 'rnorm': 0.3287234047301618, 'rnorm100': 32.87234047301618, 'sharperatio': None, 'pnl': 31530.42, 'final_value': 131530.42}\n" + ] + }, + { + "data": { + "text/plain": [ + "(16, 16)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "strats_opt = { \n", + " \"smac\": {\"fast_period\": [10,15], \"slow_period\": [40, 60]}, \n", + " \"rsi\": {\"rsi_lower\": [20, 30], \"rsi_upper\": [70, 80]} \n", + "}\n", + "\n", + "res_opt = backtest(\"multi\", df, strats=strats_opt)\n", + "res_opt.shape\n", + "# (4, 16)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + "
init_cashbuy_propsell_propexecution_typesmac.fast_periodsmac.slow_periodrsi.rsi_periodrsi.rsi_upperrsi.rsi_lowerrtotravgrnormrnorm100sharperatiopnlfinal_value
010000011close15401470300.2740680.0011280.32872332.872340None31530.42131530.4200
110000011close15401480300.2366880.0009740.27820127.820134None26704.53126704.5325
210000011close10401470300.2050370.0008440.23692823.692777None22757.02122757.0175
310000011close10401480300.1934230.0007960.22212022.211957None21339.58121339.5825
410000011close15601470300.1810900.0007450.20658920.658914None19852.36119852.3565
510000011close15601480300.1562500.0006430.17590317.590320None16911.79116911.7875
610000011close10601470300.1198340.0004930.13232413.232438None12730.99112730.9915
710000011close10601480300.1076380.0004430.11809311.809295None11364.44111364.4450
810000011close15401470200.0525690.0002160.0560295.602931None5397.52105397.5225
910000011close10401470200.0423770.0001740.0449274.492681None4328.80104328.8050
1010000011close15401480200.0224750.0000920.0235812.358064None2272.90102272.8975
1110000011close10401480200.0123230.0000510.0128611.286106None1239.89101239.8900
1210000011close1560147020-0.040298-0.000166-0.040929-4.092908None-3949.6696050.3415
1310000011close1560148020-0.070396-0.000290-0.070402-7.040217None-6797.5393202.4690
1410000011close1060147020-0.096415-0.000397-0.095150-9.515003None-9191.3190808.6900
1510000011close1060148020-0.126454-0.000520-0.122902-12.290236None-11878.4988121.5125
\n", + "
" + ], + "text/plain": [ + " init_cash buy_prop sell_prop execution_type smac.fast_period \\\n", + "0 100000 1 1 close 15 \n", + "1 100000 1 1 close 15 \n", + "2 100000 1 1 close 10 \n", + "3 100000 1 1 close 10 \n", + "4 100000 1 1 close 15 \n", + "5 100000 1 1 close 15 \n", + "6 100000 1 1 close 10 \n", + "7 100000 1 1 close 10 \n", + "8 100000 1 1 close 15 \n", + "9 100000 1 1 close 10 \n", + "10 100000 1 1 close 15 \n", + "11 100000 1 1 close 10 \n", + "12 100000 1 1 close 15 \n", + "13 100000 1 1 close 15 \n", + "14 100000 1 1 close 10 \n", + "15 100000 1 1 close 10 \n", + "\n", + " smac.slow_period rsi.rsi_period rsi.rsi_upper rsi.rsi_lower rtot \\\n", + "0 40 14 70 30 0.274068 \n", + "1 40 14 80 30 0.236688 \n", + "2 40 14 70 30 0.205037 \n", + "3 40 14 80 30 0.193423 \n", + "4 60 14 70 30 0.181090 \n", + "5 60 14 80 30 0.156250 \n", + "6 60 14 70 30 0.119834 \n", + "7 60 14 80 30 0.107638 \n", + "8 40 14 70 20 0.052569 \n", + "9 40 14 70 20 0.042377 \n", + "10 40 14 80 20 0.022475 \n", + "11 40 14 80 20 0.012323 \n", + "12 60 14 70 20 -0.040298 \n", + "13 60 14 80 20 -0.070396 \n", + "14 60 14 70 20 -0.096415 \n", + "15 60 14 80 20 -0.126454 \n", + "\n", + " ravg rnorm rnorm100 sharperatio pnl final_value \n", + "0 0.001128 0.328723 32.872340 None 31530.42 131530.4200 \n", + "1 0.000974 0.278201 27.820134 None 26704.53 126704.5325 \n", + "2 0.000844 0.236928 23.692777 None 22757.02 122757.0175 \n", + "3 0.000796 0.222120 22.211957 None 21339.58 121339.5825 \n", + "4 0.000745 0.206589 20.658914 None 19852.36 119852.3565 \n", + "5 0.000643 0.175903 17.590320 None 16911.79 116911.7875 \n", + "6 0.000493 0.132324 13.232438 None 12730.99 112730.9915 \n", + "7 0.000443 0.118093 11.809295 None 11364.44 111364.4450 \n", + "8 0.000216 0.056029 5.602931 None 5397.52 105397.5225 \n", + "9 0.000174 0.044927 4.492681 None 4328.80 104328.8050 \n", + "10 0.000092 0.023581 2.358064 None 2272.90 102272.8975 \n", + "11 0.000051 0.012861 1.286106 None 1239.89 101239.8900 \n", + "12 -0.000166 -0.040929 -4.092908 None -3949.66 96050.3415 \n", + "13 -0.000290 -0.070402 -7.040217 None -6797.53 93202.4690 \n", + "14 -0.000397 -0.095150 -9.515003 None -9191.31 90808.6900 \n", + "15 -0.000520 -0.122902 -12.290236 None -11878.49 88121.5125 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res_opt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/2020-05-20-backtest_crypto.ipynb b/dependencies/fastquant/examples/2020-05-20-backtest_crypto.ipynb new file mode 100644 index 0000000..6d3b03f --- /dev/null +++ b/dependencies/fastquant/examples/2020-05-20-backtest_crypto.ipynb @@ -0,0 +1,2628 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"backtesting crypto\"\n", + "> \"How to fetch and backtest crypto data using fastquant\"\n", + "\n", + "- toc: true\n", + "- branch: master\n", + "- badges: true\n", + "- comments: true\n", + "- author: Jerome de Leon\n", + "- categories: [crypto, backtest, grid search]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment to install in colab\n", + "# !pip3 install fastquant --update\n", + "# or pip install git+https://www.github.com/enzoampil/fastquant.git@history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## fetch data from binance" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from fastquant import get_crypto_data\n", + "\n", + "crypto = get_crypto_data(\"BTC/USDT\", \n", + " \"2018-12-01\", \n", + " \"2019-12-31\",\n", + " time_resolution='1d'\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "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", + " \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", + " \n", + " \n", + " \n", + "
openhighlowclosevolume
dt
2019-12-277202.007275.867076.427254.7433642.701861
2019-12-287254.777365.017238.677316.1426848.982199
2019-12-297315.367528.457288.007388.2431387.106085
2019-12-307388.437408.247220.007246.0029605.911782
2019-12-317246.007320.007145.017195.2325954.453533
\n", + "
" + ], + "text/plain": [ + " open high low close volume\n", + "dt \n", + "2019-12-27 7202.00 7275.86 7076.42 7254.74 33642.701861\n", + "2019-12-28 7254.77 7365.01 7238.67 7316.14 26848.982199\n", + "2019-12-29 7315.36 7528.45 7288.00 7388.24 31387.106085\n", + "2019-12-30 7388.43 7408.24 7220.00 7246.00 29605.911782\n", + "2019-12-31 7246.00 7320.00 7145.01 7195.23 25954.453533" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "crypto.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run backtest with a grid of values" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 7\n", + "slow_period : 30\n", + "Final Portfolio Value: 167957.05730000004\n", + "Final PnL: 67957.06\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 7\n", + "slow_period : 45\n", + "Final Portfolio Value: 200109.894525\n", + "Final PnL: 100109.89\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 7\n", + "slow_period : 60\n", + "Final Portfolio Value: 189298.80590000006\n", + "Final PnL: 89298.81\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 7\n", + "slow_period : 75\n", + "Final Portfolio Value: 258316.23405000006\n", + "Final PnL: 158316.23\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 14\n", + "slow_period : 30\n", + "Final Portfolio Value: 161429.22347500004\n", + "Final PnL: 61429.22\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 14\n", + "slow_period : 45\n", + "Final Portfolio Value: 166675.70495000004\n", + "Final PnL: 66675.7\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 14\n", + "slow_period : 60\n", + "Final Portfolio Value: 149527.12537499995\n", + "Final PnL: 49527.13\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 14\n", + "slow_period : 75\n", + "Final Portfolio Value: 229555.53917499998\n", + "Final PnL: 129555.54\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 21\n", + "slow_period : 30\n", + "Final Portfolio Value: 119204.3985\n", + "Final PnL: 19204.4\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 21\n", + "slow_period : 45\n", + "Final Portfolio Value: 162617.28744999995\n", + "Final PnL: 62617.29\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 21\n", + "slow_period : 60\n", + "Final Portfolio Value: 185407.30802499995\n", + "Final PnL: 85407.31\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 21\n", + "slow_period : 75\n", + "Final Portfolio Value: 218637.07270000002\n", + "Final PnL: 118637.07\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 28\n", + "slow_period : 30\n", + "Final Portfolio Value: 99122.65879999999\n", + "Final PnL: -877.34\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 28\n", + "slow_period : 45\n", + "Final Portfolio Value: 200118.49420000007\n", + "Final PnL: 100118.49\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 28\n", + "slow_period : 60\n", + "Final Portfolio Value: 253832.4204\n", + "Final PnL: 153832.42\n", + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 28\n", + "slow_period : 75\n", + "Final Portfolio Value: 215884.7391\n", + "Final PnL: 115884.74\n", + "Time used (seconds): 1.2722818851470947\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'commission': 0.0075, 'execution_type': 'close', 'channel': None, 'symbol': None, 'fast_period': 7, 'slow_period': 75}\n", + "Optimal metrics: {'rtot': 0.9490143617322465, 'ravg': 0.002396500913465269, 'rnorm': 0.8292722866407841, 'rnorm100': 82.92722866407841, 'sharperatio': 0.9873670567519415, 'pnl': 158316.23, 'final_value': 258316.23405000006}\n" + ] + } + ], + "source": [ + "from fastquant import backtest\n", + "\n", + "results = backtest('smac', \n", + " crypto, \n", + " fast_period=[7,14,21,28], \n", + " slow_period=[30,45,60,75],\n", + " plot=False,\n", + " verbose=False\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
strat_idinit_cashbuy_propsell_propcommissionexecution_typechannelsymbolfast_periodslow_periodrtotravgrnormrnorm100sharperatiopnlfinal_value
03100000110.0075closeNoneNone7750.9490140.0023970.82927282.9272290.987367158316.23258316.234050
114100000110.0075closeNoneNone28600.9315040.0023520.80900280.9002050.986999153832.42253832.420400
27100000110.0075closeNoneNone14750.8309750.0020980.69689869.6898470.984563129555.54229555.539175
311100000110.0075closeNoneNone21750.7822430.0019750.64508364.5083230.983142118637.07218637.072700
415100000110.0075closeNoneNone28750.7695740.0019430.63187463.1874260.982741115884.74215884.739100
\n", + "
" + ], + "text/plain": [ + " strat_id init_cash buy_prop sell_prop commission execution_type \\\n", + "0 3 100000 1 1 0.0075 close \n", + "1 14 100000 1 1 0.0075 close \n", + "2 7 100000 1 1 0.0075 close \n", + "3 11 100000 1 1 0.0075 close \n", + "4 15 100000 1 1 0.0075 close \n", + "\n", + " channel symbol fast_period slow_period rtot ravg rnorm \\\n", + "0 None None 7 75 0.949014 0.002397 0.829272 \n", + "1 None None 28 60 0.931504 0.002352 0.809002 \n", + "2 None None 14 75 0.830975 0.002098 0.696898 \n", + "3 None None 21 75 0.782243 0.001975 0.645083 \n", + "4 None None 28 75 0.769574 0.001943 0.631874 \n", + "\n", + " rnorm100 sharperatio pnl final_value \n", + "0 82.927229 0.987367 158316.23 258316.234050 \n", + "1 80.900205 0.986999 153832.42 253832.420400 \n", + "2 69.689847 0.984563 129555.54 229555.539175 \n", + "3 64.508323 0.983142 118637.07 218637.072700 \n", + "4 63.187426 0.982741 115884.74 215884.739100 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's a 258% maximum profit using only SMAC because bitcoin was bullish all time long!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7, 75)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get best parameters on top row \n", + "fast_best, slow_best = results.iloc[0][[\"fast_period\",\"slow_period\"]]\n", + "fast_best, slow_best" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run backtest using optimum values" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as pl\n", + "pl.style.use(\"default\")\n", + "pl.rcParams[\"figure.figsize\"] = (9,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 7\n", + "slow_period : 75\n", + "Final Portfolio Value: 258316.23405000006\n", + "Final PnL: 158316.23\n", + "Time used (seconds): 0.10248279571533203\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'commission': 0.0075, 'execution_type': 'close', 'channel': None, 'symbol': None, 'fast_period': 7, 'slow_period': 75}\n", + "Optimal metrics: {'rtot': 0.9490143617322465, 'ravg': 0.002396500913465269, 'rnorm': 0.8292722866407841, 'rnorm100': 82.92722866407841, 'sharperatio': 0.9873670567519415, 'pnl': 158316.23, 'final_value': 258316.23405000006}\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "result, history = backtest(MAMAStrategy,df, verbose=False, return_history=True)\n", + "# result" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "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", + " \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", + "
strat_idinit_cashbuy_propsell_propcommissionstop_lossstop_trailexecution_typechannelsymbol...rnorm100lendrawdownmoneydownmaxmaxdrawdownmaxdrawdownperiodsharperatiopnlfinal_value
00100000110.0075NoneNonecloseNoneNone...-15.2730584912.74288313638.337586{'len': 49, 'drawdown': 12.742882982202364, 'm...12.74288349None-6611.2493388.758285
\n", + "

1 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " strat_id init_cash buy_prop sell_prop commission stop_loss stop_trail \\\n", + "0 0 100000 1 1 0.0075 None None \n", + "\n", + " execution_type channel symbol ... rnorm100 len drawdown moneydown \\\n", + "0 close None None ... -15.273058 49 12.742883 13638.337586 \n", + "\n", + " max maxdrawdown \\\n", + "0 {'len': 49, 'drawdown': 12.742882982202364, 'm... 12.742883 \n", + "\n", + " maxdrawdownperiod sharperatio pnl final_value \n", + "0 49 None -6611.24 93388.758285 \n", + "\n", + "[1 rows x 31 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "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", + " \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", + " \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", + " \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", + "
strat_idstrat_namedttypepricesizevaluecommissionpnl
002019-03-13buy45.227501219299138.682007743.5401150.000000
102019-03-26sell46.697498-219299138.682007767.7068723222.234314
202019-04-04buy48.8375022065100849.440651756.3708050.000000
302019-04-12sell49.717499-2065100849.440651769.9997621817.194328
402019-04-24buy51.8699991949101094.627918758.2097090.000000
502019-04-26sell51.075001-1949101094.627918746.588824-1549.451431
602019-05-06buy52.937500185398093.187500735.6989060.000000
702019-05-07sell50.715000-185398093.187500704.811715-4118.292217
\n", + "
" + ], + "text/plain": [ + " strat_id strat_name dt type price size value \\\n", + "0 0 2019-03-13 buy 45.227501 2192 99138.682007 \n", + "1 0 2019-03-26 sell 46.697498 -2192 99138.682007 \n", + "2 0 2019-04-04 buy 48.837502 2065 100849.440651 \n", + "3 0 2019-04-12 sell 49.717499 -2065 100849.440651 \n", + "4 0 2019-04-24 buy 51.869999 1949 101094.627918 \n", + "5 0 2019-04-26 sell 51.075001 -1949 101094.627918 \n", + "6 0 2019-05-06 buy 52.937500 1853 98093.187500 \n", + "7 0 2019-05-07 sell 50.715000 -1853 98093.187500 \n", + "\n", + " commission pnl \n", + "0 743.540115 0.000000 \n", + "1 767.706872 3222.234314 \n", + "2 756.370805 0.000000 \n", + "3 769.999762 1817.194328 \n", + "4 758.209709 0.000000 \n", + "5 746.588824 -1549.451431 \n", + "6 735.698906 0.000000 \n", + "7 704.811715 -4118.292217 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "history['orders']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "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", + " \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", + " \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", + " \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", + "
strat_idstrat_namedtMACD (12, 16, 9)CrossOverALMA
002019-01-02NaNNaN39.309765
102019-01-03NaNNaN38.916997
202019-01-04NaNNaN38.217196
302019-01-07NaNNaN37.482952
402019-01-08NaNNaN37.115681
.....................
9902019-05-24-0.5309100.045.578881
10002019-05-28-0.5532830.045.182577
10102019-05-29-0.5676640.044.788032
10202019-05-30-0.5598010.044.557318
10302019-05-31-0.5730300.044.396019
\n", + "

104 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " strat_id strat_name dt MACD (12, 16, 9) CrossOver ALMA\n", + "0 0 2019-01-02 NaN NaN 39.309765\n", + "1 0 2019-01-03 NaN NaN 38.916997\n", + "2 0 2019-01-04 NaN NaN 38.217196\n", + "3 0 2019-01-07 NaN NaN 37.482952\n", + "4 0 2019-01-08 NaN NaN 37.115681\n", + ".. ... ... ... ... ... ...\n", + "99 0 2019-05-24 -0.530910 0.0 45.578881\n", + "100 0 2019-05-28 -0.553283 0.0 45.182577\n", + "101 0 2019-05-29 -0.567664 0.0 44.788032\n", + "102 0 2019-05-30 -0.559801 0.0 44.557318\n", + "103 0 2019-05-31 -0.573030 0.0 44.396019\n", + "\n", + "[104 rows x 6 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "history['indicators']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/2021-12-07-backtest_crypto-hourly.ipynb b/dependencies/fastquant/examples/2021-12-07-backtest_crypto-hourly.ipynb new file mode 100644 index 0000000..56b0efb --- /dev/null +++ b/dependencies/fastquant/examples/2021-12-07-backtest_crypto-hourly.ipynb @@ -0,0 +1,26587 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"backtesting crypto hourly intervals\"\n", + "> \"How to fetch and backtest crypto data using fastquant\"\n", + "\n", + "- toc: true\n", + "- branch: master\n", + "- badges: true\n", + "- comments: true\n", + "- author: Jerome de Leon (original), Mikee Jazmines (hourly)\n", + "- categories: [crypto, backtest, grid search]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment to install in colab\n", + "# !pip3 install fastquant --update\n", + "# or pip install git+https://www.github.com/enzoampil/fastquant.git@history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## fetch data from binance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### If a timestamp is given, it will return upto that timestamp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from fastquant import get_crypto_data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "crypto = get_crypto_data(\"BTC/USDT\", \n", + " \"2020-11-01 00:00:00\", \n", + " \"2021-11-30 05:00:00\",\n", + " time_resolution='1h'\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "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", + " \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", + " \n", + " \n", + " \n", + "
openhighlowclosevolume
dt
2021-11-30 01:00:0057707.3857775.7057036.5457260.062307.00578
2021-11-30 02:00:0057260.0557512.4157215.1357357.851058.06476
2021-11-30 03:00:0057357.8657414.1156770.0157092.921577.44633
2021-11-30 04:00:0057092.9157277.3356983.9757205.00928.50736
2021-11-30 05:00:0057205.0057282.1156280.3756286.071646.18148
\n", + "
" + ], + "text/plain": [ + " open high low close volume\n", + "dt \n", + "2021-11-30 01:00:00 57707.38 57775.70 57036.54 57260.06 2307.00578\n", + "2021-11-30 02:00:00 57260.05 57512.41 57215.13 57357.85 1058.06476\n", + "2021-11-30 03:00:00 57357.86 57414.11 56770.01 57092.92 1577.44633\n", + "2021-11-30 04:00:00 57092.91 57277.33 56983.97 57205.00 928.50736\n", + "2021-11-30 05:00:00 57205.00 57282.11 56280.37 56286.07 1646.18148" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "crypto.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### If no timestamp is given, it will return upto 00:00:00" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "crypto = get_crypto_data(\"BTC/USDT\", \n", + " \"2020-11-01\", \n", + " \"2021-11-30\",\n", + " time_resolution='1h'\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "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", + " \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", + " \n", + " \n", + " \n", + "
openhighlowclosevolume
dt
2021-11-29 20:00:0057880.6758249.9957703.5758038.631210.67577
2021-11-29 21:00:0058034.2158400.0057987.8258247.181430.54047
2021-11-29 22:00:0058247.1758353.0158020.2558048.281303.51091
2021-11-29 23:00:0058048.2758099.6457667.0057776.251203.66000
2021-11-30 00:00:0057776.2557964.1857515.3857707.381404.65505
\n", + "
" + ], + "text/plain": [ + " open high low close volume\n", + "dt \n", + "2021-11-29 20:00:00 57880.67 58249.99 57703.57 58038.63 1210.67577\n", + "2021-11-29 21:00:00 58034.21 58400.00 57987.82 58247.18 1430.54047\n", + "2021-11-29 22:00:00 58247.17 58353.01 58020.25 58048.28 1303.51091\n", + "2021-11-29 23:00:00 58048.27 58099.64 57667.00 57776.25 1203.66000\n", + "2021-11-30 00:00:00 57776.25 57964.18 57515.38 57707.38 1404.65505" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "crypto.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run backtest with a grid of values" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from fastquant import backtest\n", + "\n", + "results = backtest('smac', \n", + " crypto, \n", + " fast_period=[7,14,21,28], \n", + " slow_period=[30,45,60,75],\n", + " plot=False,\n", + " verbose=False\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "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", + " \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", + " \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", + " \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", + " \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", + " \n", + "
strat_idinit_cashbuy_propsell_propfractionalcommissionstop_lossstop_trailtake_profitexecution_type...wonlostwon_avgwon_avg_prcntlost_avglost_avg_prcntwon_maxwon_max_prcntlost_maxlost_max_prcnt
0210000011False0000close...476711002.16297911.002163-4879.040000-4.87904044452.8644.45286-20958.42-20.95842
1010000011False0000close...801279914.9552509.914955-4755.445748-4.75544641070.1241.07012-14097.00-14.09700
2310000011False0000close...325615546.61062515.546611-5427.451607-5.42745252285.6652.28566-22280.58-22.28058
3110000011False0000close...569811869.05946411.869059-4863.816327-4.86381643645.7743.64577-20649.60-20.64960
41110000011False0000close...303713528.38533313.528385-7040.034324-7.04003441067.5441.06754-22302.12-22.30212
\n", + "

5 rows × 44 columns

\n", + "
" + ], + "text/plain": [ + " strat_id init_cash buy_prop sell_prop fractional commission \\\n", + "0 2 100000 1 1 False 0 \n", + "1 0 100000 1 1 False 0 \n", + "2 3 100000 1 1 False 0 \n", + "3 1 100000 1 1 False 0 \n", + "4 11 100000 1 1 False 0 \n", + "\n", + " stop_loss stop_trail take_profit execution_type ... won lost \\\n", + "0 0 0 0 close ... 47 67 \n", + "1 0 0 0 close ... 80 127 \n", + "2 0 0 0 close ... 32 56 \n", + "3 0 0 0 close ... 56 98 \n", + "4 0 0 0 close ... 30 37 \n", + "\n", + " won_avg won_avg_prcnt lost_avg lost_avg_prcnt won_max \\\n", + "0 11002.162979 11.002163 -4879.040000 -4.879040 44452.86 \n", + "1 9914.955250 9.914955 -4755.445748 -4.755446 41070.12 \n", + "2 15546.610625 15.546611 -5427.451607 -5.427452 52285.66 \n", + "3 11869.059464 11.869059 -4863.816327 -4.863816 43645.77 \n", + "4 13528.385333 13.528385 -7040.034324 -7.040034 41067.54 \n", + "\n", + " won_max_prcnt lost_max lost_max_prcnt \n", + "0 44.45286 -20958.42 -20.95842 \n", + "1 41.07012 -14097.00 -14.09700 \n", + "2 52.28566 -22280.58 -22.28058 \n", + "3 43.64577 -20649.60 -20.64960 \n", + "4 41.06754 -22302.12 -22.30212 \n", + "\n", + "[5 rows x 44 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's a 258% maximum profit using only SMAC because bitcoin was bullish all time long!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7, 60)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get best parameters on top row \n", + "fast_best, slow_best = results.iloc[0][[\"fast_period\",\"slow_period\"]]\n", + "fast_best, slow_best" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run backtest using optimum values" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as pl\n", + "pl.style.use(\"default\")\n", + "pl.rcParams[\"figure.figsize\"] = (9,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
init_cashbuy_propsell_propexecution_typesentirtotravgrnormrnorm100sharperatiopnlfinal_value
010000011close0.20.079530.0006210.16949816.9497730.758398277.79108277.786758
\n", + "
" + ], + "text/plain": [ + " init_cash buy_prop sell_prop execution_type senti rtot ravg \\\n", + "0 100000 1 1 close 0.2 0.07953 0.000621 \n", + "\n", + " rnorm rnorm100 sharperatio pnl final_value \n", + "0 0.169498 16.949773 0.75839 8277.79 108277.786758 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from fastquant import backtest\n", + "\n", + "#initiate buy/sell if senti>0.2/senti<-0.2\n", + "backtest(\"sentiment\", data, sentiments=sentiments, senti=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/chart.png b/dependencies/fastquant/examples/chart.png new file mode 100644 index 0000000..7e3c474 Binary files /dev/null and b/dependencies/fastquant/examples/chart.png differ diff --git a/dependencies/fastquant/examples/fastquant_demo.ipynb b/dependencies/fastquant/examples/fastquant_demo.ipynb new file mode 100644 index 0000000..ca5bd32 --- /dev/null +++ b/dependencies/fastquant/examples/fastquant_demo.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "dLC0ASP1o6B8" + }, + "source": [ + "# Installation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "colab_type": "code", + "id": "KLi7LnCKdure", + "outputId": "e045fc92-a73f-4623-96d8-6b95cc64212f" + }, + "outputs": [], + "source": [ + "# !pip install -e git+https://github.com/enzoampil/fastquant.git@master#egg=fastquant" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "GHJNCDsVpD4i" + }, + "source": [ + "# Get stock data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 235 + }, + "colab_type": "code", + "id": "-RoozEvNrxGn", + "outputId": "fc8591d9-7a1c-465c-d833-3c12a571b7be" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + "
close
dt
2018-01-03255.4
2018-01-04255.0
2018-01-05255.0
2018-01-08256.0
2018-01-09255.8
\n", + "
" + ], + "text/plain": [ + " close\n", + "dt \n", + "2018-01-03 255.4\n", + "2018-01-04 255.0\n", + "2018-01-05 255.0\n", + "2018-01-08 256.0\n", + "2018-01-09 255.8" + ] + }, + "execution_count": 3, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "from fastquant import get_stock_data\n", + "df = get_stock_data('JFC', '2018-01-01', '2019-01-01')\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "t3J0y8tApNPg" + }, + "source": [ + "# Plot daily closing prices" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 451 + }, + "colab_type": "code", + "id": "_kyvYm6LsOAu", + "outputId": "424fef24-a465-4b9e-fb09-7c529d3dd639" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Daily Closing Prices of JFC\\nfrom 2018-01-01 to 2019-01-01')" + ] + }, + "execution_count": 4, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "df.close.plot(figsize=(10, 6))\n", + "plt.title(\"Daily Closing Prices of JFC\\nfrom 2018-01-01 to 2019-01-01\", fontsize=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "reBMiCPipO8O" + }, + "source": [ + "# Analyze with a simple moving average (SMA) trading strategy" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 451 + }, + "colab_type": "code", + "id": "5UNQLarRs7Uv", + "outputId": "675f1fa0-b837-4099-8530-c3e6ec8fab81" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Daily Closing Prices vs 30 day SMA of JFC\\nfrom 2018-01-01 to 2019-01-01')" + ] + }, + "execution_count": 5, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "ma30 = df.close.rolling(30).mean()\n", + "close_ma30 = pd.concat([df.close, ma30], axis=1).dropna()\n", + "close_ma30.columns = ['Closing Price', 'Simple Moving Average (30 day)']\n", + "\n", + "close_ma30.plot(figsize=(10, 6))\n", + "plt.title(\"Daily Closing Prices vs 30 day SMA of JFC\\nfrom 2018-01-01 to 2019-01-01\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "-8g2USkR7U_G" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "include_colab_link": true, + "name": "fastquant_demo.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/dependencies/fastquant/examples/feature_extraction_crypto_20200824.ipynb b/dependencies/fastquant/examples/feature_extraction_crypto_20200824.ipynb new file mode 100644 index 0000000..4fef138 --- /dev/null +++ b/dependencies/fastquant/examples/feature_extraction_crypto_20200824.ipynb @@ -0,0 +1,1814 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Extraction and Selection" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting ta\n", + " Downloading https://files.pythonhosted.org/packages/90/ec/e4f5aea8c7f0f55f92b52ffbafa389ea82f3a10d9cab2760e40af34c5b3f/ta-0.5.25.tar.gz\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/site-packages (from ta) (1.18.0)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/site-packages (from ta) (1.0.3)\n", + "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/site-packages (from pandas->ta) (2019.3)\n", + "Requirement already satisfied: python-dateutil>=2.6.1 in /usr/local/lib/python3.7/site-packages (from pandas->ta) (2.8.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/site-packages (from python-dateutil>=2.6.1->pandas->ta) (1.13.0)\n", + "Building wheels for collected packages: ta\n", + " Building wheel for ta (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for ta: filename=ta-0.5.25-cp37-none-any.whl size=24879 sha256=7f53b78a9fc5a542b536b1bd6fd928280409e9e22a683b29a49a901add30898a\n", + " Stored in directory: /Users/enzoampil/Library/Caches/pip/wheels/2e/93/b7/cf649194508e53cee4145ffb949e9f26877a5a8dd12db9ed5b\n", + "Successfully built ta\n", + "Installing collected packages: ta\n", + "Successfully installed ta-0.5.25\n" + ] + } + ], + "source": [ + "!pip3 install ta" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from ta import add_all_ta_features\n", + "from ta.utils import dropna\n" + ] + }, + { + "cell_type": "code", + "execution_count": 382, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib.pylab as plt\n", + "\n", + "from tsfresh import extract_features, extract_relevant_features, select_features\n", + "from tsfresh.utilities.dataframe_functions import impute\n", + "from tsfresh.feature_extraction import ComprehensiveFCParameters\n", + "\n", + "from sklearn.tree import DecisionTreeRegressor\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import preprocessing\n", + "from sklearn.linear_model import LogisticRegression, LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 313, + "metadata": {}, + "outputs": [], + "source": [ + "from fastquant import get_crypto_data\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 330, + "metadata": {}, + "outputs": [], + "source": [ + "df = get_crypto_data(\"BTC/USDT\", \"2019-05-13\", \"2020-08-23\").reset_index().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 331, + "metadata": {}, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexdtopenhighlowclosevolume
002019-05-136968.248100.006870.007790.7185804.735333
112019-05-147795.628366.007599.567947.5676583.722603
222019-05-157945.268249.007850.008169.8737884.327211
332019-05-168169.088320.007705.007866.5969630.513996
442019-05-177868.677925.006913.007355.2688752.008159
........................
4644642020-08-1911945.1012020.0811561.0011754.5973940.169606
4654652020-08-2011754.3811888.0011668.0011853.5546085.254351
4664662020-08-2111853.5411878.0011485.8111531.3464448.306142
4674672020-08-2211531.2311686.0011376.8111662.9643678.701646
4684682020-08-2311663.5111718.0711514.1311648.1337900.004690
\n", + "

469 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " index dt open high low close volume\n", + "0 0 2019-05-13 6968.24 8100.00 6870.00 7790.71 85804.735333\n", + "1 1 2019-05-14 7795.62 8366.00 7599.56 7947.56 76583.722603\n", + "2 2 2019-05-15 7945.26 8249.00 7850.00 8169.87 37884.327211\n", + "3 3 2019-05-16 8169.08 8320.00 7705.00 7866.59 69630.513996\n", + "4 4 2019-05-17 7868.67 7925.00 6913.00 7355.26 88752.008159\n", + ".. ... ... ... ... ... ... ...\n", + "464 464 2020-08-19 11945.10 12020.08 11561.00 11754.59 73940.169606\n", + "465 465 2020-08-20 11754.38 11888.00 11668.00 11853.55 46085.254351\n", + "466 466 2020-08-21 11853.54 11878.00 11485.81 11531.34 64448.306142\n", + "467 467 2020-08-22 11531.23 11686.00 11376.81 11662.96 43678.701646\n", + "468 468 2020-08-23 11663.51 11718.07 11514.13 11648.13 37900.004690\n", + "\n", + "[469 rows x 7 columns]" + ] + }, + "execution_count": 331, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract Features" + ] + }, + { + "cell_type": "code", + "execution_count": 332, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "X = add_all_ta_features(\n", + " df, open=\"open\", high=\"high\", low=\"low\", close=\"close\", volume=\"volume\")" + ] + }, + { + "cell_type": "code", + "execution_count": 333, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "volume_sma_em -2.291602e+06\n", + "volume_em -1.486544e+06\n", + "momentum_wr -4.675613e+01\n", + "trend_dpo -1.208690e+01\n", + "trend_psar_up_indicator 4.051173e-02\n", + " ... \n", + "volatility_bbh 1.002699e+04\n", + "volume 5.965989e+04\n", + "volume_fi 5.500383e+05\n", + "volume_obv 5.638757e+05\n", + "volume_adi 1.153206e+06\n", + "Length: 78, dtype: float64" + ] + }, + "execution_count": 333, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.mean().sort_values()" + ] + }, + { + "cell_type": "code", + "execution_count": 334, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((469, 79), (469, 79))" + ] + }, + "execution_count": 334, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 335, + "metadata": {}, + "outputs": [], + "source": [ + "X = X.iloc[: -1]\n", + "X[\"pct_change\"] = df.close.pct_change()\n", + "X[\"pct_change_lag1\"] = X[\"pct_change\"].shift()\n", + "X = X.fillna(-1)\n", + "y = df.close.pct_change().shift(-1).iloc[:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 336, + "metadata": {}, + "outputs": [], + "source": [ + "del X[\"dt\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 337, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((468, 80), (468,))" + ] + }, + "execution_count": 337, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 338, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 338, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 339, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['index', 'open', 'high', 'low', 'close', 'volume', 'volume_adi',\n", + " 'volume_obv', 'volume_cmf', 'volume_fi', 'momentum_mfi', 'volume_em',\n", + " 'volume_sma_em', 'volume_vpt', 'volume_nvi', 'volume_vwap',\n", + " 'volatility_atr', 'volatility_bbm', 'volatility_bbh', 'volatility_bbl',\n", + " 'volatility_bbw', 'volatility_bbp', 'volatility_bbhi',\n", + " 'volatility_bbli', 'volatility_kcc', 'volatility_kch', 'volatility_kcl',\n", + " 'volatility_kcw', 'volatility_kcp', 'volatility_kchi',\n", + " 'volatility_kcli', 'volatility_dcl', 'volatility_dch', 'trend_macd',\n", + " 'trend_macd_signal', 'trend_macd_diff', 'trend_sma_fast',\n", + " 'trend_sma_slow', 'trend_ema_fast', 'trend_ema_slow', 'trend_adx',\n", + " 'trend_adx_pos', 'trend_adx_neg', 'trend_vortex_ind_pos',\n", + " 'trend_vortex_ind_neg', 'trend_vortex_ind_diff', 'trend_trix',\n", + " 'trend_mass_index', 'trend_cci', 'trend_dpo', 'trend_kst',\n", + " 'trend_kst_sig', 'trend_kst_diff', 'trend_ichimoku_conv',\n", + " 'trend_ichimoku_base', 'trend_ichimoku_a', 'trend_ichimoku_b',\n", + " 'trend_visual_ichimoku_a', 'trend_visual_ichimoku_b', 'trend_aroon_up',\n", + " 'trend_aroon_down', 'trend_aroon_ind', 'trend_psar_up',\n", + " 'trend_psar_down', 'trend_psar_up_indicator',\n", + " 'trend_psar_down_indicator', 'momentum_rsi', 'momentum_tsi',\n", + " 'momentum_uo', 'momentum_stoch', 'momentum_stoch_signal', 'momentum_wr',\n", + " 'momentum_ao', 'momentum_kama', 'momentum_roc', 'others_dr',\n", + " 'others_dlr', 'others_cr', 'pct_change', 'pct_change_lag1'],\n", + " dtype='object')" + ] + }, + "execution_count": 339, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Train and evaluate classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's train a boosted decision tree on the filtered as well as the full set of extracted features." + ] + }, + { + "cell_type": "code", + "execution_count": 340, + "metadata": {}, + "outputs": [], + "source": [ + "X_full_train, X_full_test, y_train, y_test = X.iloc[:-50], X.iloc[-50:], y.iloc[:-50], y.iloc[-50:]\n", + "#X_filtered_train, X_filtered_test = X_full_train[X_filtered.columns], X_full_test[X_filtered.columns]\n", + "X_filtered_train, X_filtered_test = X_full_train, X_full_test" + ] + }, + { + "cell_type": "code", + "execution_count": 341, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0 0.020133\n", + " 1 0.027972\n", + " 2 -0.037122\n", + " 3 -0.065000\n", + " 4 -0.013298\n", + " ... \n", + " 413 -0.005875\n", + " 414 0.010226\n", + " 415 -0.015756\n", + " 416 -0.003112\n", + " 417 0.008523\n", + " Name: close, Length: 418, dtype: float64,\n", + " index open high low close volume volume_adi \\\n", + " 0 0 6968.24 8100.00 6870.00 7790.71 85804.735333 4.265263e+04 \n", + " 1 1 7795.62 8366.00 7599.56 7947.56 76583.722603 3.561417e+04 \n", + " 2 2 7945.26 8249.00 7850.00 8169.87 37884.327211 5.847199e+04 \n", + " 3 3 8169.08 8320.00 7705.00 7866.59 69630.513996 2.543203e+04 \n", + " 4 4 7868.67 7925.00 6913.00 7355.26 88752.008159 1.425209e+04 \n", + " .. ... ... ... ... ... ... ... \n", + " 413 413 9116.16 9238.00 9024.67 9192.56 42120.293261 2.249072e+06 \n", + " 414 414 9192.93 9205.00 9064.89 9138.55 31463.162801 2.250691e+06 \n", + " 415 415 9138.08 9292.00 9080.10 9232.00 38488.528699 2.267384e+06 \n", + " 416 416 9231.99 9261.96 8940.00 9086.54 45725.168076 2.263282e+06 \n", + " 417 417 9086.54 9125.00 9037.47 9058.26 28943.420177 2.248088e+06 \n", + " \n", + " volume_obv volume_cmf volume_fi ... momentum_stoch_signal \\\n", + " 0 8.580474e+04 -1.000000 -1.000000e+00 ... -1.000000 \n", + " 1 1.623885e+05 -1.000000 -1.000000e+00 ... -1.000000 \n", + " 2 2.002728e+05 -1.000000 -1.000000e+00 ... -1.000000 \n", + " 3 1.306423e+05 -1.000000 -1.000000e+00 ... -1.000000 \n", + " 4 4.189026e+04 -1.000000 -1.000000e+00 ... -1.000000 \n", + " .. ... ... ... ... ... \n", + " 413 1.271013e+06 0.138373 -1.316667e+06 ... 28.930306 \n", + " 414 1.239550e+06 0.129728 -1.371332e+06 ... 33.384724 \n", + " 415 1.278038e+06 0.221278 -6.616059e+05 ... 37.455473 \n", + " 416 1.232313e+06 0.193137 -1.517260e+06 ... 33.723689 \n", + " 417 1.203370e+06 0.153633 -1.417440e+06 ... 30.897571 \n", + " \n", + " momentum_wr momentum_ao momentum_kama momentum_roc others_dr \\\n", + " 0 -1.000000 -1.000000 -1.000000 -1.000000 -13.584355 \n", + " 1 -1.000000 -1.000000 -1.000000 -1.000000 2.013295 \n", + " 2 -1.000000 -1.000000 -1.000000 -1.000000 2.797211 \n", + " 3 -1.000000 -1.000000 -1.000000 -1.000000 -3.712177 \n", + " 4 -1.000000 -1.000000 -1.000000 -1.000000 -6.500021 \n", + " .. ... ... ... ... ... \n", + " 413 -62.031679 -338.369441 9352.992996 -2.879831 0.835971 \n", + " 414 -67.734952 -349.778265 9347.375709 -2.639693 -0.587540 \n", + " 415 -57.866948 -341.569588 9346.407205 -0.840259 1.022591 \n", + " 416 -73.227033 -313.513765 9309.077553 -2.910690 -1.575607 \n", + " 417 -76.213305 -297.808647 9274.625812 -2.543710 -0.311230 \n", + " \n", + " others_dlr others_cr pct_change pct_change_lag1 \n", + " 0 -1.000000 0.000000 -1.000000 -1.000000 \n", + " 1 1.993297 2.013295 0.020133 -1.000000 \n", + " 2 2.758803 4.866822 0.027972 0.020133 \n", + " 3 -3.782832 0.973981 -0.037122 0.027972 \n", + " 4 -6.720897 -5.589349 -0.065000 -0.037122 \n", + " .. ... ... ... ... \n", + " 413 0.832496 17.993867 0.008360 0.011579 \n", + " 414 -0.589273 17.300605 -0.005875 0.008360 \n", + " 415 1.017398 18.500111 0.010226 -0.005875 \n", + " 416 -1.588151 16.633015 -0.015756 0.010226 \n", + " 417 -0.311715 16.270019 -0.003112 -0.015756 \n", + " \n", + " [418 rows x 80 columns])" + ] + }, + "execution_count": 341, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train, X_full_train" + ] + }, + { + "cell_type": "code", + "execution_count": 342, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 342, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_train.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 394, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 394, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#regressor_full = RandomForestRegressor()\n", + "regressor_full = LinearRegression()\n", + "regressor_full.fit(X_full_train, y_train)\n", + "#print(classification_report(y_test, classifier_full.predict(X_full_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 395, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 395, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Out of sample\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "pdf = pd.DataFrame(dict(pred=regressor_full.predict(X_full_test), actual=y_test))\n", + "\n", + "pdf.plot.scatter(0, 1)\n", + "#plt.xlim(-0.025, 0.025)\n", + "#plt.ylim(-0.15, 0.15)" + ] + }, + { + "cell_type": "code", + "execution_count": 396, + "metadata": {}, + "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", + "
predactual
pred1.0000000.332945
actual0.3329451.000000
\n", + "
" + ], + "text/plain": [ + " pred actual\n", + "pred 1.000000 0.332945\n", + "actual 0.332945 1.000000" + ] + }, + "execution_count": 396, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdf.corr()" + ] + }, + { + "cell_type": "code", + "execution_count": 397, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.1, 0.1)" + ] + }, + "execution_count": 397, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# In sample\n", + "# The in sample predictions from linear regression are not too overfit, compared to random forest - looks promising\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "pdf = pd.DataFrame(dict(pred=regressor_full.predict(X_full_train), actual=y_train))\n", + "\n", + "pdf.plot.scatter(0, 1)\n", + "plt.xlim(-0.1, 0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 398, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'LinearRegression' object has no attribute 'feature_importances_'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfeat_importance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"importance\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mregressor_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeature_importances_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"feat\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mX_full_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'LinearRegression' object has no attribute 'feature_importances_'" + ] + } + ], + "source": [ + "feat_importance = pd.DataFrame({\"importance\": regressor_full.feature_importances_, \"feat\": X_full_train.columns})" + ] + }, + { + "cell_type": "code", + "execution_count": 348, + "metadata": {}, + "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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
importancefeat
00.010040index
10.011414open
20.022711high
30.015858low
40.022280close
.........
750.008654others_dr
760.017034others_dlr
770.021043others_cr
780.008210pct_change
790.022445pct_change_lag1
\n", + "

80 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " importance feat\n", + "0 0.010040 index\n", + "1 0.011414 open\n", + "2 0.022711 high\n", + "3 0.015858 low\n", + "4 0.022280 close\n", + ".. ... ...\n", + "75 0.008654 others_dr\n", + "76 0.017034 others_dlr\n", + "77 0.021043 others_cr\n", + "78 0.008210 pct_change\n", + "79 0.022445 pct_change_lag1\n", + "\n", + "[80 rows x 2 columns]" + ] + }, + "execution_count": 348, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_importance" + ] + }, + { + "cell_type": "code", + "execution_count": 349, + "metadata": {}, + "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", + " \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", + "
importance
feat
trend_dpo0.039516
volume_adi0.034599
trend_cci0.030592
volume_obv0.029656
trend_visual_ichimoku_a0.028776
......
volatility_bbli0.000416
trend_psar_down_indicator0.000392
volatility_kchi0.000119
volatility_kcli0.000078
volatility_bbhi0.000066
\n", + "

80 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " importance\n", + "feat \n", + "trend_dpo 0.039516\n", + "volume_adi 0.034599\n", + "trend_cci 0.030592\n", + "volume_obv 0.029656\n", + "trend_visual_ichimoku_a 0.028776\n", + "... ...\n", + "volatility_bbli 0.000416\n", + "trend_psar_down_indicator 0.000392\n", + "volatility_kchi 0.000119\n", + "volatility_kcli 0.000078\n", + "volatility_bbhi 0.000066\n", + "\n", + "[80 rows x 1 columns]" + ] + }, + "execution_count": 349, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_importance.set_index(\"feat\").sort_values(ascending=False, by=\"importance\")" + ] + }, + { + "cell_type": "code", + "execution_count": 350, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'TA Feature Importance for Predicting BTC returns')" + ] + }, + "execution_count": 350, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "feat_importance.set_index(\"feat\").sort_values(ascending=True, by=\"importance\").plot.barh(figsize=(10, 15))\n", + "plt.title(\"TA Feature Importance for Predicting BTC returns\", fontsize=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrain on top features\n", + "\n", + "Improved corrrelation by 5 percentage points!" + ] + }, + { + "cell_type": "code", + "execution_count": 426, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 426, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "top_feats = feat_importance.set_index(\"feat\").importance.sort_values(ascending=False).head(20).index.values\n", + "#regressor_top = RandomForestRegressor()\n", + "regressor_top = LinearRegression()\n", + "regressor_top.fit(X_full_train[top_feats], y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 427, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 427, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Out of sample\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "pdf = pd.DataFrame(dict(pred=regressor_top.predict(X_full_test[top_feats]), actual=y_test))\n", + "pdf['pos_pred'] = pdf.pred.gt(0)\n", + "pdf['pos_actual'] = pdf.actual.gt(0)\n", + "\n", + "pdf.plot.scatter(0, 1)\n", + "#plt.xlim(-0.1, 0.1)\n", + "#plt.ylim(-0.10, 0.10)" + ] + }, + { + "cell_type": "code", + "execution_count": 428, + "metadata": {}, + "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", + "
predactual
pred1.0000000.217987
actual0.2179871.000000
\n", + "
" + ], + "text/plain": [ + " pred actual\n", + "pred 1.000000 0.217987\n", + "actual 0.217987 1.000000" + ] + }, + "execution_count": 428, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdf[[\"pred\", \"actual\"]].corr()" + ] + }, + { + "cell_type": "code", + "execution_count": 386, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06142693380160941" + ] + }, + "execution_count": 386, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(pdf.actual.subtract(pdf.pred).pow(2).mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 390, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.55" + ] + }, + "execution_count": 390, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Overall accuracy\n", + "(pdf['pos_pred'] == pdf['pos_actual']).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 391, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.56" + ] + }, + "execution_count": 391, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdf['pos_actual'].mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 423, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: actual R-squared: 0.111\n", + "Model: OLS Adj. R-squared: 0.102\n", + "Method: Least Squares F-statistic: 12.22\n", + "Date: Mon, 24 Aug 2020 Prob (F-statistic): 0.000713\n", + "Time: 15:53:08 Log-Likelihood: 146.11\n", + "No. Observations: 100 AIC: -288.2\n", + "Df Residuals: 98 BIC: -283.0\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -0.0118 0.007 -1.680 0.096 -0.026 0.002\n", + "pred 0.1393 0.040 3.495 0.001 0.060 0.218\n", + "==============================================================================\n", + "Omnibus: 102.398 Durbin-Watson: 2.133\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 1986.483\n", + "Skew: -3.128 Prob(JB): 0.00\n", + "Kurtosis: 23.919 Cond. No. 7.11\n", + "==============================================================================\n", + "\n", + "Warnings:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n" + ] + }, + { + "data": { + "text/plain": [ + "(-0.1, 0.2)" + ] + }, + "execution_count": 423, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAFkCAYAAAD8LPojAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de3jcZ3Xo+++au662ZFu+SraUOHESyFV2bo4JNEBoIWkhgEOAAEkcutvdnM3uPtCHbtoT9t4PnJ62Jz2btnEuECjgQKDgFkrIBWM7xLGdG8GJkziSbUm+SNZdmvv83vPHb2Y8UnSZkTQzv5lZn+fxY83Mb2beiZylV+td73rFGINSSilncRV7AEoppd5Og7NSSjmQBmellHIgDc5KKeVAGpyVUsqBNDgrpZQDFTU4i8iNIvK6iBwRkS9N8fgXRORVEfmtiDwlImszHrtdRN5M/rm9sCNXSqn8kmLVOYuIG3gDeC/QDRwAbjXGvJpxzbuB54wxQRH5Y+B6Y8zHRaQROAi0AwZ4HrjCGDNY6M+hlFL5UMyZ8ybgiDGmwxgTBXYAN2deYIz5lTEmmLy5D1iT/Pr9wBPGmIFkQH4CuLFA41ZKqbzzFPG9VwNdGbe7gStnuP4O4D9meO7qqZ4kItuAbQAXXnjhFYcOHZrreJVSaqHJdA+UxIKgiHwSO4XxN7k+1xiz3RjTboxpr6qqWvjBKaVUHhQzOPcAzRm31yTvm0BEbgC+DNxkjInk8lyllCpVxQzOB4D1ItIqIj5gK7Az8wIRuQy4Hzsw92Y89DjwPhFpEJEG4H3J+5RSqiwULedsjImLyJ9iB1U38LAx5pCI3AscNMbsxE5j1AI/FBGA48aYm4wxAyLyVewAD3CvMWagCB9DKaXyomildMXQ3t5uDh48WOxhKKVUSmkvCCqlVKXR4KyUUg6kwVkppRxIg7NSSjmQBmellHIgDc5KKeVAGpyVUsqBNDgrpZQDaXBWSikH0uCslFIOpMFZKaUcSIOzUko5kAZnpZRyIA3OSinlQBqclVLKgTQ4K6WUA2lwVkopB9LgrJRSDqTBWSmlHEiDs1JKOZAGZ6WUciANzkop5UAanJVSyoE0OCullANpcFZKKQfS4KyUUg6kwVkppRxIg7NSSjmQBmellHIgDc5KKeVAnmIPQCmlSs2uw73cv7uDrsEgzQ3V3L2ljes3NC3oe+jMWSmlcrDrcC9f2XmI3tEwi6u89I6G+crOQ+w63Lug76PBWSmlcnD/7g68bqHa50HE/tvrFu7f3bGg76PBWSmlctA1GKTK655wX5XXTfdgcEHfR4OzUkrloLmhmlAsMeG+UCzBmobqBX0fDc5KKZWDu7e0EUsYxiMxjDEEo3FiCcPdW9oW9H00OCulVA6u39DEF99/Pg3VfoZDMZrqAtx700ULXq2hpXRKKZWD/rEIF6yq5x8/eTnL6wN5ex8NzkoplQVjDL2jEcYj8YK8nwZnpZSaRcIynBoJE5m0EJhPGpyVUmoGkXiC3pEIsYRV0PfV4KyUUtMYi8TpG41gjCn4exe1WkNEbhSR10XkiIh8aYrHt4jICyISF5FbJj2WEJGXkn92Fm7USqlyZ4yhfyxC70i4KIEZijhzFhE38A3gvUA3cEBEdhpjXs247DjwGeDPp3iJkDHm0rwPVClVURKW4fRImHAB88tTKWZaYxNwxBjTASAiO4CbgXRwNsYcTT5W2GSPUqoihWN2fjluFT/kFDOtsRroyrjdnbwvWwEROSgi+0TkDxd2aEqpSjMajnFyOOyIwAylvSC41hjTIyJtwNMi8oox5q3JF4nINmAbQEtLS6HHqJQqAWfGIoyEYsUexgTFnDn3AM0Zt9ck78uKMaYn+XcHsAu4bJrrthtj2o0x7cuWLZv7aJVSZceyDKeGw44LzFDc4HwAWC8irSLiA7YCWVVdiEiDiPiTXy8FriUjV62UUrOJJyxODIcIRguz4y9XRQvOxpg48KfA48BrwA+MMYdE5F4RuQlARDaKSDfwUeB+ETmUfPoFwEEReRn4FfC1SVUeSik1rUg8wYmhMNG4M/LLU5Fi1fAVQ3t7uzl48GCxh6HKTCHOk1MLJxiN0zsSwZpn7Kvxexai8ZFM94C2DFVqHgp1npxaGMOhGKeGw/MOzIWgwVmpeSjUeXJq/s6MRegfixR7GFnT4KzUPBTqPDk1d1Zyx58TKzJmosFZqXko1Hlyam7iCYuTI+GC9WBeSBqclZqH1HlywWg8r+fJqdylKjIK2YN5IWlwVmoert/QxL03XURTXSCv58mp3ASjcU4OOWcr9lyU8vZtpRzh+g1NGowdZDgYo3+8dBb+pqPBWSlVFowxnBmLMhourYW/6WhwVnmnmzRUviUsQ+9omFC0NPPLU9Gcs8or3aSh8i2WsDgxFCqrwAwanFWe6SYNlU/hWIITQ6GCH75aCBqcVV7pJg2VL2OROCeHwyQs52/FngsNziqvdJOGyoehYLSoh68WggZnlVe6SUMtJGMMfaMRBsajxR5K3mlwVnmlmzTUQrEsw6mRcNmUys1GS+lU3ukmDTVfsYTFqeFwWS78TUeDs1LK0cKxBKdHynfhbzoanJVSjjUeidM7Ginrhb/paHBWSjlSufTImCsNzkopx+kbjVTMwt90NDgrpRzDsgy9oxGC0dJrjr/QNDgrpRwhnrA4NRImGq+cioyZaHBWShVdJJ7g9HCkpJvjLzQNzkqpogpG4/SORLAqsCJjJhqclVJFMxyK0T9WuRUZM9HgrJQqijNjEUZClV2RMRMNzkqpgtKKjOxocFZKFYxWZGRPg7NSqiC0IiM3GpyVUnmnFRm50+CslMqrkXCMM6NakZErDc5KZWHX4V7u391B12CQ5oZq7t7Spj2qs9A/FmFYKzLmRE9CUWoWuw738pWdh+gdDbO4ykvvaJiv7DzErsO9xR6aYxljOD0S1sA8DxqclZrF/bs78LqFap8HEftvr1u4f3dHsYfmSAnLcGI4zHhES+XmQ9MaSs2iazDI4irvhPuqvG66B4NFGpFzhWMJeke0ImMh6MxZqVk0N1QTiiUm3BeKJVjTUF2kETnTWCTOyeGwBuYFosFZqVncvaWNWMIQjMYxxv47ljDcvaWt2ENzBGMM/WMRekfCFXmcVL5ocFZqFtdvaOLemy6iqS7AcChGU12Ae2+6SKs1sPPLJ4d14S8fNOesVBau39CkwXgSzS/nlwZnpVTOhkMxBsajmsbIIw3OSqmsGWPoG40wpmVynB4J4xJhWZ0/L6+vOWelVFZiCYueoVDFB+axSJwH9nTw0X9+lr95/HDe3kdnzkqpWY1H4vSNVnbjomjcYufLJ/iXfccYCds/oH79Rh9jkTi1/oUPpUWdOYvIjSLyuogcEZEvTfH4FhF5QUTiInLLpMduF5E3k39uL9yolaosA+NRTo+EKzYwW8bw1Gu9fPZbB/jHXW8xEo4T8Lq467pWnv6v1+clMEMRZ84i4ga+AbwX6AYOiMhOY8yrGZcdBz4D/Pmk5zYCfwW0AwZ4PvncwUKMXalKkLAMvaNhQtHE7BeXqReOD7J9dwdvnB4DwO0SPvjOlXzq6rU0N1ZTk6fADMVNa2wCjhhjOgBEZAdwM5AOzsaYo8nHJtfqvB94whgzkHz8CeBG4Pv5H7ZS5S8UTdA3Wrllcm/1jfHAnk72dw6k79uyfil3bG6lubEwO0OLGZxXA10Zt7uBK+fx3NVTXSgi24BtAC0tLbmPUqkKMxSMMjAeLfYwiqJ3JMw3f3OUXx46TSqJ887Vi7h7SxsXrqov6FjKfkHQGLMd2A7Q3t5emUkzpbJgWYa+sUhFdpMbC8f53v7j/PjFnvT5hi2N1dx1XSvXnLMEESn4mIoZnHuA5ozba5L3Zfvc6yc9d9eCjEqpChRLWJwaDhNLVFYaIxq3+OlLPXz3uePpCozGGh+fuWYdH3jHCtyuwgfllGIG5wPAehFpxQ62W4FPZPncx4H/JSINydvvA/5i4YeoVPkLxxKcHgmTsCrnF0vLGJ4+3MtDezs5PWIfoVXldbN1YzO3tK+hyusu8giLGJyNMXER+VPsQOsGHjbGHBKRe4GDxpidIrIR+FegAfiQiPxfxpiLjDEDIvJV7AAPcG9qcVAplb2RcIz+scrahv38sUHu393Bkd6zFRgfutiuwGio9hV5dGdJJX1T2tvbzcGDB4s9DEfRs/Eq15mxCCMV1E3uSO8Y23d3cPDY2YrbLect5c7NrXPqzV3j97C8PjDfYU2bNyn7BUE1vdTZeF63TDgb717QAF3GLMtwuoLql0+NhPnmM0d58tWzFRgXr7ErMC5YWdgKjFxocK5gmWfjAVT7PASjce7f3aHBuUxF4xanRypj4W80HOO7zx3nX1/sIZaww/LaJXYFxtVtxanAyIUG5wqmZ+NVllA0Qe9o+S/8ReMW//piD9/bf5zRZAXGklofn7l6HTcWuQIjFxqcK1hzQzW9o+H0zBn0bLxyVQn9ly1jePK1Xh7e20nvqF2BUe1zc+umZj5y+RoCDqjAyIUG5wp295Y2vrLzEMFonCqvm1AsUVJn4+li5uyMMfSPR8t+4e/A0QEe2N3JkT67AsPjEm66ZBWfvKqFxQ6qwMiFBucKdv2GJu7Fzj13DwZZU0IBThczZ1cJjYvePD3K9t0dPH98KH3fu89fxuc2t7J6cVURRzZ/GpwrXKmejaeLmTMr94W/U8NhHn6mkydf603fd2nzIrZtaWPDCudWYORCg7MqSbqYOb1QNFG2/ZdHQnYFxk9eOluBsW5JNdu2tHFla6PjKzByocFZlSRdzJzacChG/1ik2MNYcJFYIlmB0ZU+JmtprY/PXtvK+y5cXjIVGLnQ4KwKYqEX70p9MXOhGWM4MxZlNFxeC38Jy/Dka6f55jNH0xUYNT43t25q4cOXry65CoxcaHBWeZePxbtSXsxcaOW48GeM4cDRQbbv6aCjbxywKzD+8LJV3HblWhZNSmmVIw3OKu/ytXhXqouZC6kcF/7eOD3K/bs7eDGjAuM9G5r43LXrWFXiFRi50OCs8k4X7/IjGI3TO1I+J2KfHA7x0N6jPH04swJjMZ9/VxvnLa8r4siKQ4OzyjtdvFt4w8EY/ePlsfA3HIrxL/uO8dOXThBPbi1vW1rDti1tbFzXUFYVGLnQ4KzyThfvFk45LfxFYgl+9EIP3z9wnPGInS9vqvPz2WvXccMF5VmBkQsNzirvdPFuYSQsw+mRMOFYaS/8JSzDLw+d4pu/OcqZMfsg2Rq/m9s2tfBHl63GX8YVGLnQ4KwKQhfv5qccFv6MMTzXOcADezrpPGNXYHjdwh9euppPXNlSERUYudDgrJTDlcPC3+unRrl/91u81DWcvu+GC5r43LWtrFg079NEypIGZ6UcrNQX/nqGQjy8t5Nfvd6Xvu+KlsXctaUyKzByocFZlZRKaRNqjKFvLMJYsll8qRkKRvmXfcfZ+XJGBcayGu7e0sbGdY1FHl1p0OCsSkaltAkt5YW/cCzBj17oZsf+LsajZyswPre5lRsuaMJVoWVxc6HBWZWMSmgTGokn6B2JlNzCX8IyPJ6swOhPVmDU+j3cdqVdgeHzuIo8wtKjwVmVjHLfaTgeidM3WloLf8YY9nUMsH1PB8f67e+D1y380WWr+cSmFuq1AmPONDirklHOOw2HglEGxqPFHkZOXjs5wv27O/htt12BIcANFy7ns9euY0W9VmDMlwZnVTLKcadhKS789QyGeHBvJ79+42wFRvvaBrZtaePcptoijqy8aHBWJaPcdhrGExanRyNESmThbzAY5TvPHuPffnuSRLIC49xltWzb0kq7VmAsOA3OqqSUy07DcMxe+Itbzl/4C8USPPa8XYERSv4gWV7v547Nrbxng1Zg5IsGZ6UKbCgYZTAYwzh84S9hGf7jd6d45DdH6U/mw+sCHj551VpuvmSVVmDkmQZnpQokGrfoG3N+GsMYw2/e6ueBPZ0cHzhbgfHhy+weGHUBrcAoBA3OShXAcCjGwHjU8bPlV0/YFRiv9JytwHjfRcv5zDXrWK4VGAWlwVmpPEpYhr7RCMGos6sxugaCPLS3k91vnknft2ldA3dtaeOcZVqBUQwanJXKk1LY7TcwnqrAOEGyAIPzlteybUsbl7c0FHdwFU6Ds1J54PQ2n6Fogh8+38WjB7rTFRgr6gPcsbmVd29YphUYDjBjcBaRUWCqf10CGGNMfV5GpVQJGw7F6B9zZpvPhGX4+SsneeTZY+kdifXJCoybtALDUWYMzsYYbbiqVA76xyIMh5x3vp8xhr1H+nlwTwddgyEAfB4XH7l8NbdubKE2oL9EO01O3xERaQLSS7bGmOMLPiJVlsq9D7Mx9sLfWMR5C3+/6xnm/t0dHDoxApytwPjcta0sq/MXd3BqWlkFZxG5CfhbYBXQC6wFXgMuyt/QVLko9z7M+ei/vL9jgB0Hujg5EmJlfRVbNzazqS23LdLHB4I8uKeTvUfOVmBc2drIXde10qYVGI6X7cz5q8BVwJPGmMtE5N3AJ/M3LFVOyrkPcyxhcWp4YQ9e3d8xwH1Pv4nHJdQHPPSPR7jv6Te5h/VZBeiB8SiPPHuUn/32ZLoC4/zldWzb0splWoFRMrINzjFjTL+IuETEZYz5lYj8v3kdmSob5dqHORRN0DsaTjcBWig7DnThcQlVXjdAugPfjgNdMwbnYDTODw5284ODXYRj9g+LlYsC3Lm5lXedrxUYpSbb4DwkIrXAbuC7ItILjOdvWKqclGMf5nzu+Ds5EqJ+0gJdwOvi1EhoyuvjCYufvXKKbz97lMGgvRhZH/Dw6avX8qFLVuF1awVGKco2ON8MhIH/AtwGLALuzdegVGmbvPh3dVsjj73QUxZ9mAvRf3llfRX945H0zBkgHLNYUV/1trHsOXKGB/d00p2swPB7XNxyxRo+vrGZWr9WYJSyrL57xpjMWfIjeRqLKgNTLf499kIPt1y+mmc7Bkq6D3M8YXFqJEw0nt8df1s3NnPf028SiiUIeF2EYxZxy7B1Y3P6mle67QqMV0/aFRgugRsvWsHt16zTCowykW21RuZmFB/gBcbnuwlFRG4E7gPcwIPGmK9NetwPfBu4AugHPm6MOSoi67CrRV5PXrrPGPP5+YxF5Wa60rjpFv+e7Rjg+9uuKvKo5y4ST3B6uDD9lze1NXIP69lxoItTIyFWZFRrHOsf58E9nTzzVn/6+qvaGrnrujZal9bkfWyqcLKdOac3o4iIYKc55vV/moi4gW8A7wW6gQMistMY82rGZXcAg8aYc0VkK/B14OPJx94yxlw6nzGouZmpNK4cF//CsQSnhsMF3Yq9qa1xwuJf/1iEv3viDX7+SkYFxoo6Pr+ljUuaFxdsXKpwck5KGXsF5Cci8lfAl+bx3puAI8aYDgAR2YEd9DOD883AXye/fgz438kfDqqIZiqNK7fFv/FInN7RSNFafQajcR490MUPD3YTTqZTVi1OVmCctwz936F8ZZvW+HDGTRfQjr1AOB+rga6M293AldNdY4yJi8gwsCT5WKuIvAiMAH9pjNkzzdi3AdsAWlpa5jlk5yvETryZZsdfvfkdZXMI62g4xpmx4vRgjics/v23J/nOvmPpCoxFVV4+ddVaPnTJSq3AqADZzpw/lPF1HDiKPastlpNAS7L2+grsmfxFxpiRyRcaY7YD2wHa29ud2SJsgRRqJ95Ms+NyOYR1KBhNNwYqJGMMv37jDA/t7aRnyK7ACHhc3NK+ho+3N1OjFRgVI9vv9IPGmGcy7xCRa7G3cs9VD9CccXtN8r6prukWEQ92CV9/MrUSATDGPC8ibwHnAQfnMR7Hm21WPJedeHOZad+9pW3G2XEpH8IaT1j0jkYWdCt2tl7uHmL77g5eOzkK2BUYH3jHSm6/Zi1La7UCo9JkG5z/P+DyLO7LxQFgvYi0YgfhrcAnJl2zE7gdeBa4BXjaGGNEZBkwYIxJiEgbsB7omMdYHC+bWXGui3FznWmXy+x4srFInDOjhe/BfLR/nAd2d/Jsx9kKjGvOWcKd17WybolWYFSq2fo5Xw1cAywTkS9kPFSPXf42Z8kc8p8Cjydf62FjzCERuRc4aIzZCTwEfEdEjgAD2AEcYAtwr4jEAAv4vDFmYD7jcbpsZsW5LsbNp+fFTLPjUutAZ1mGM+P53VgylTNjEb71m6P84nen0hUYF66sY9uWNi5eoxUYlW62mbMPqE1el9nbeQR7JjsvxpifAz+fdN9XMr4OAx+d4nk/An403/cvJdnMimdLN8zlNXNVah3owrEEfaOFPUpqPBJnx4EuHnu+m0iyAmNNQxV3bm7luvVLtQJDAbM32/818GsR+ZYx5liBxqSmkM2sONd0w3zK3nLdhOLEDnRDwSiDwVjBqjFiCYt/e/kE39l3PN2Qf3GVl09fvZYPXrwSj1ZgqAxZLwiKyEeNMUMAItIA7DDGvD9/Q1OZsp0V57IYl+tMO6XUN6HEExZ9YxFC0cIs+hlj2PV6Hw8908mJIbsCNeBx8bH2Zj62cc2EH45KpWT7r2JpKjADGGMGk6eiqALJxyLcXF+zlDeh5KvN53Re7hrin3d38PqpsxUYf/DOlXz66rUs0QoMNYNsg7MlIi2pY6mSvS3KumbYifJRojaX1yzVTSiD41EGg4WpXe48M84DezrY13F2nXrzuUu5c3MrLUuc8YNKzU++VwayDc5fBvaKyK+xx3QdyV13amGUUoVDqW1CSViG3tFwQdIYfaN2BcbjhzIrMOr5/LvaeMfqRXl/f5UfHpcLv9eFz+3C53Hh97jyvkYg2S6GJNMY24AXgSqg1xizO49jW3Dt7e3m4EHn7VPJzOFmzjbvvekiRwbo+Y63kD+IwrEEvSP57yY3FrF7YEyuwLjrujY2n7tEKzAcINtzGb1uO/j6PW58HjsYu115+/5N+8JZBWcRuRO4B3sX30vYHemeNca8Z6FGWAhODc63bt/3tploMBqnqS7g2DabqQCb6+y4kD+IRsIx+vPcGyMat/i3357gO88eYyRZJ91Q7eX2a9bx++9YoRUYDpF5LmNmj+z/+t7zeNf5TenZsM/twpW/QDyVad8s27TGPcBG7L7J7xaRDcD/WoiRqfzVG+dzdjrX/HchSu2MMZwZizIaji3I603FSlVg7O3k5HCyAsPr4uPtzXysvZkq37z2aKkFtuNgF77kvzsRwedxE4rG+dELPdzS3jz7CxRBtsE5bIwJiwgi4jfGHBaR8/M6sgqy0BUOTt4Iku9Su2jconc0v6eVvHB8kO27O3jj9BhgV2B88OJVfPrqtTTW+PL2vio7LhH83rNpCb/HxZmxCIurvBPSS9U+j6NKPCfLNjh3i8hi4CfAEyIyCOimlAUy13rj6Th5I0g+S+3GI3H68tgbo6NvjO17OtnfebYC47r1S7ljcystjVqBUSxulxDwugl43AR8dlCezOklnlPJ9iSUP0p++dci8ivs7nC/yNuoKsxCVzg4eSPITD+I5pOKyWeZXO9ImG/+5ii/PHQ6XT/6ztX1bNvSxkWrtAKj0Nwue73C73UT8E4djCdb6AlQIczlJJRf52MglW4ha5idPEuY7gcRMKdUjGXZp2GPRxa+adFYOM739h/nxy/2pNMkLY3V3HVdK9ecoxUYheJxuQh4XQR89uzY58l9kdWJJZ6zybqUrhw4tVpjoWVTEeG0uuq5VKzkq2lRNG7x05dP8N19ZyswGmt8fOaatXzgHSvzWValSJayeV1Ued0EvO5yP/Vl3tUaqoTMNkvIDN5ugRe7Brnj2wc5r6mWL964oShBOtdUzHAwxkBwYcvkLGP41eFeHtp7lFMj4fQYPr5xDR9tb6bKqxUY+eB1u+yccTIga/mhTYNzmZopTZJaMIwnDCeGw7iwg3TnmfGiVXVkm4rJV9OiF44Ncv/uDt7stSsw3C7hgxfbPTAaqrUCYyF53S6qfO7kIl7+d9qVKg3OFSg1S+0cHseF4HIJBnubs9ctRanqyGbBJh8nlbzVO8b2PR0cODqYvu9d5y3jjs3rHJGjLwc+z9kURcDr1rRQljQ4O1i+8sKpWWo0YeFOLmoZAz63q2hVHTOlYvJxUsnpkTDffOYoT7yaWYGxiLu3tHHhqvoFe59KY2/wcBHwJGfHHnehd9yVDQ3ODpXPjSSpWarbJViWQbCD87I6f1GrOqZKxSz0ot9oOMb3nrMrMGIJOyyvbazmri2tXN2mFRi5crsEv8eN32Pnjf2egm9/LlsanB0qnxtJUrPUr/3Ha7zZN4ZXhBWL/LhdknWz/UJUeizkSSXRuMVPXurhu88dZzQ5A19S6+Oz16zj/Ret0F+1s+QSOZsvzrLGWM2NBmeHyvdGktQsNbOBUVNdYNZAO3lG//qpET77rQMA1AU83Lm5lT+74bx5jS2WsOgbjRCOzX/RzzKGp17r5aG9nfSORgCo9rnZurGZj1yxRiswZiFiNwoKeNxU+eyZsf52URganB2qUBtJct38kjmj7x0JMxC0mwuJ2OO77+kjAHMO0MOhGAPjC1Mid/DoANt3d3Kk72wFxoeSFRiLtQJjSi6R9Kw4labQYFwcGpwdyqnbTTNn9H1jETtfjZ2zTlgGy8B9Tx/h4jWLcwr6C1ki9+bpUbbv6eT5Y2crMK4/bxl3bG5ldUPVvF+/nKR23/k9bvzJgKycQYOzQzl1u2nmjN4yE7c3pU7+SFgmp8XLkXCMgbHovEvkTo2EeXhvJ0+91puuwLi0eRHbtrSxYYVWYKQW71Kd2gpxmoeaOw3ODpaPMwPnK3NGn5o1p0jyDhGyqpeOJyzOjEUJRudXIjcSivHd547zk5fOVmCsW1LNti1tXNnaWJG/lruSJW1+jwt/Mj1R5tugy44GZ5WTzBl932gk3XsCAGMH66Zaf3rxcrrKjoWYLUfjFj9+sYfvPXecscjZCozPXbOO91VQBYZkBmJP6ow7TU+UOm18VAbmWto21fOAnF7rH558g/uePkLCMrgEltX6aaoPEIzG8bldjEcTExowReMW/8cN67mspWHOnzdhGZ567TQPP3M0XYFR43Nz66YWPnz56rLPm6YaA6Xqi3XRrqTN73LyMVYAACAASURBVAzBclGOwXmuZ/JN9bzhUAwB6qu8836tWMJQ7XURswzVPg/GGBKWYSwSZ0mNn7/7+CU5f1ZjDAeODrJ9TwcdfeMAeFzCTZeu4lNXrmVRtXeWVyg9maVsusmjLGlXunI1180qUz2vZygEBlYsqsrptaZbvPzLn/6OxVVeLGOIJwzGGAJeF6dGQjl/zjdOj7J9dwcvHB9K3/fu8+0KjFWLJ1ZgZHvKshOJSHq3XbXWFVc0Dc4lbq6bVaZ6XsIyb6svznbjy1SLl2t+XcWpkTC+jIWocMxiRX325Wwnh0M8vPcoTx3uTd93afNi7t7Sxvkr6t52feYpy/UBD/3jEe57+k3uYb3jAnQqV+x1C3732SoKnRkr0OBc8ua6WWXy80ZCsXSdckffGEtr/dRXeee88SUcS3DLFWv42yfeIGGZCcfRb904+2nHw6EY333uGD996US6AqNtaQ13bWll07rpKzB2HOjCkzzGCEinWXYc6CpqcE6lJzJL2bR6Qs1Eg3OJm+tmlcznxRMWPUNhBHALRBMWJ4ZDROIJfB53ThtfonGLwWCU8Uicy9c2cM971rPjQBenRkKsyCLFEIkl7AqM/ccZj9gbUpbV+vnstet474XLZ63AODkSoj4w8Z/1XFMp85XqW1zltf/ojFjlQoNzkc23idBcN6tkPu+F44N4XJLONfeNRgjHEwSjCb724YunfK3J475zcysXNy9mNBybcN2mtsasZqwJy/DLV0/zrWeO0jd2tgLjE1e28OHLVuPPsgJjZX0V/eORCT0zck2lzFVq63OVz84X68xYzYdWaxSRU8762/z1p1lc5Z2QKjDGMByKseeL75lx3AGPXS4XiVvc857c87rGGJ7rHOCBPZ10nrErMLxu4eZLV3HblWtZVJVbBUZmzjkzlTKXsc3G43KlUxTaFEjNkVZrONFslRb57OmcKde8dWrcfo+buGXwuV0kLJPO62ZbLfH6qVHu393BS11nKzB+b0MTn9u8jpWL5jbT3dTWyD3klkrJhtc9cYOHz+OqmE0uqjg0OBfRbJUW2QTvmWbV2c66797Sxn977GV6BkPELQuPy0VdwMN//4MLpxz38YFxanwe4hkN8FN53WyqJU4MhXhobye/er0v/fzLWxazbUsb5y1/ewVGrrJNpUzH40rOhL0ufG7d5KGKQ4NzEc02Y50peM82q8511m0AxK4qQCb2zEiJxi2GglGW1QamzevOVC1x/oo6vvPcMXa+dIJ4sktS27Ia7t7SRvvahrwHwJlm9B6Xi9qAhxq/W7c+K0fQFYsiuntLG7GEIRiNY4z9d2alRXNDNaFJDedTwTtzVi1i/51qNgTM+nim+3d3sKjKy/qmOjasqGd9Ux2LqrzpayPxBL2jYboHg4xF4mzd2EzcMoRiCQz236kSuZMjIQLeif+sfB7hSN8on3zoOX78Qg9xy9BU5+eLN57P/Z+8go0zlMYtlNSMvn88Qn3Aw0Awwj/86k1e7Rlh5aIqWpZU01jj08CsHEODcxFdv6GJe2+6iKa6AMOhGE11gQmLgTMF767B4NtO8chMicz2eMquw728cHyQ4wNBOvrGGAnF0tceHxjn5HCInsHQhMNVN7U1cs971rOkxs9o2N6OnVpwW1lfRThmpztSi4pHzwQZiyQYjyao9XvYtqWNb39uU0GPh9pxoAuvW6j1e/C53dQH7C3q391/nCqfBmTlPJrWKLKZ2oLOVCbXvNtOiSQsQ99oJH2SduvSGiC7Rb5U6kOwl4zjCUPPUBDLqkJcsKw2QCiamDYdkLn49/dPvUHNHg/jkRi9o1HsKjJJpy/APh5q3ZJq2pbU4PMUZl7gdbuo9rnpGwvTUO2bMEMv1knjSmVDg7PDTRe8U4t4g8EYLkkGV8vQNxZh1+HerDanpFIfKxYF6BkMgdgncZ8eC7Okxs/Wjc0zLvAB6cdicYuOkfH0a8ctSGWufW5hSY2P2oCH4VAs79upvW57QbPa50n/EGhprCnIsV9KLRRNa5So6zc0saTGh8ctGOyAtHpxVTpXPFvKBOyqC7sawU1TvX36tmXsI6dSaYrMBT7B/tvjEnYc6Eo/ZhmTPkswk9dl10Evrw/gcgndgyF6hkKcHA7zlz99hS88+jL7OwYW5L+H1+1icbWP1Q1VNDdWs7jaN2F2Plt+Xymn0Zmzw+Sy6WQsmuDcZbVv2zyS+lV9qll3qm1nMBpnWV2A/jG76qLG56HG5yEUS7Ckxp+e1c60HdpgpyqO9U+9NTpmGeKWIWFZ9I3ajfVTWY64BT1D4/OaRfs8Lmp8HqqzqLBw6rFfSk2nqMFZRG4E7gPcwIPGmK9NetwPfBu4AugHPm6MOZp87C+AO4AE8GfGmMcLOPS8yLX8LdvNI7sO9/JPv36L4wNBltcH2Npu54y3tjdz39NvEoolpm1MNN126KbaAL1jEY6eCU5ZdpdisLeDI4JlTXxsLJJgaa0n66ZELhH8XhfVPg81PnfO59858dgvpaZTtLSGiLiBbwAfAC4EbhWRybse7gAGjTHnAn8PfD353AuBrcBFwI3APyZfr6TlUv4G2f2q/rePH2bbdw5y8OgAQ8Eo3QP2bHV/x8CMVRcpk8vmgtE4I+EYnQPjnBoJzxiYAer8bmIWYMyEaz0CsYQ1a1OiKp+bZXV+mhurWbe0hpWL7NSNHkyqyl0xZ86bgCPGmA4AEdkB3Ay8mnHNzcBfJ79+DPjfYv8OfzOwwxgTATpF5Ejy9Z4t0NjzItfezNP9qn7t+qUMjkd58tXT/PPuDowxuF1CPGEYCsVYXEV6tjrbbrrUdujv7z/OsYFxQjGLiL3ah9ctXN22hOc6+okk3h6m3QIrFgUI9o0jLkkfz+0REJfgccmUTYm8bhe1fg+1AY82D1IVq5jBeTXQlXG7G7hyumuMMXERGQaWJO/fN+m5q6d6ExHZBmwDaGlpWZCB58tcejOnflWPxi2C0Tjj0QRdA3Yw/+5zx0lYBo9bEAQRsCwYDscZPjnMrQ/sy+qkkLoqDxYwFLJrnQW4rGUx4ajF66dHWd1QzenhEMGYlZ4dC7C8PkA4ZrG2sZpQ3CIWTzCUrKM2lqG2yjMhjVLj97Coylv2ZwAqlY2yXxA0xmwHtoPdla7Iw5lRLr2ZjbFTDcFoglA0QSxhve2akyMhfG4hYSC1ZmiMIW7Z5W2znRTSPRjkwb2d7H7jTPq+jesauLptCT98vjtdXheOWfi8bmoDHvrGonjcwtIanz1btwx/cv25gD1bT1hjRBMGn8fF6sU1bN3UzA0XLmdRlVdnyRSmC6EqDcUMzj1A5pEYa5L3TXVNt4h4gEXYC4PZPLfkzFZRYFmGYCzBeCROKJrAmqXd68r6KizLYigYx8IgAvHkU5bV+dOlcZNPChkMRvn2s8f499+eJJFMRVR57UZAsbjh33978m39MwCW1Pj5Lzecz44DXRzrHyOaiOPzuNhxoIutG5snHOoqItQFPCzW/HFaoboQqtJQzOB8AFgvIq3YgXUr8IlJ1+wEbsfOJd8CPG2MMSKyE/ieiPwdsApYD+wv2MjzaHJFQSxhMRKOEYras+Rc+m9v3WhXYyyuhtFwnGgyL9xQbZfNpaQW5ULRBD98votHD3Sne3o0VHsxBmr9dhP5/vEIPUMhVtT7sYtsJr5GKsDf9/Sb1CZ7KmfOzq88Z4kG5WnM9bBeVZ6KFpyTOeQ/BR7H/r/8YWPMIRG5FzhojNkJPAR8J7ngN4AdwEle9wPsxcM48CfGmMSUb1RCLMsQTdgLbpF4gkjMmjJdka2pehuPhKLErIkBPhRN4HG5+NTD+xkYjwJQH/Bw21VreebNMwwGoxNmyR63cGYsSq3/7OJl5sLedJ3pfvh8Nx9pX6Ppi2nM9bBeVZ6KmnM2xvwc+Pmk+76S8XUY+Og0z/2fwP/M6wDzzBhDOGYxHo1Pmzeer8nVGKnt2KFYAr9HGAzGGUoe7gr2xo4PX7aaT2xqoTbg4ccvdL9tE8rSGh+nRiLT1kdP3rgiItT5PfSOhjUwz2Cuh/Wq8lT2C4JOYyVrhsejcYKR2fPGCy01m35obydHB8bTJ1sL8P6LVvCZa9bSVB9IXz/VJhS3y8W6xmrqq3wTThsB+MKjLzMwHmUwGGVZrb0lvH8sSjieoMbnYdfhXv0VfRpzPaxXlSc9Q7AAwrEE4WRlRSRu5ZQ3Tsn26KfZdA3YFRh73jxbgbGptZG7rmvlnGW1U75vNmfyZV5nGcOp4TBg9+lwu+1SkSU1PnweN7dcvppnOwa0ImEKqWoN3WJeMabtmavBOQ9SZW5jyaqKhDW//8YLcWjpwHiqAuNEur/Fectr2baljctbGmZ9/8ln8gETfliMhGMkLIvagBeXCKPhGMf67Vxptc/N0lo/9VVe+kbDnBmL4EmeO+h22T2W/59bLpkxCGmJmSpTesBrvtnbp+0yt2AWZW65mOnop9mCcyia4AcHu3j0YFe6Cf7KRQHu2NzK9ecvw5XFCSTT5a1Tdc4DwQjdgyGaG6rSr1cX8OJ22fnmtowZ+eB4lLhl7x50i2AsGArG+Np/vDZtsNUSM1WJNDjPQyxhpdMVuZa55WKmznDTiScsfvbKKb797FEGk+086wMePn31Wj50yap5Lcylf1j43HhcqdOoI5weiVBf5WM0HKNvNELcApcYRkIx6pNVCNGE3TPalTwBRcTeLdjZP31FgpaYqUqkwTkH8YTFeHJHXiQ+/3RFtqbrDDe5JwXYM/i9R/p5YE8H3YN28PZ5XNxy+Wq2bmqh1j/9tzzbvPapkVC6TjnVrnR5nZ/uoRBnxsKcGY2CgNsFxoKeoRBg8LhdGCDXQ1C0xExVIg3OWYonLI4PFCcYpDaTzNTaE+B3PcPcv7uDQydGAHBJqgJjHcvq/DO+x0wnnqQCtIiwqMrLuiU19I1FCMfjE47IWlkfYCQcxwB+t4ultX5E4NRwmFMjES5vaSAatzg5HMYy9o5FY+x+SOuX1Uw7Ni0xU5VIg3OWirlsOtVmksxZ7fH+IA/s7eCZI/3p51zV1shd17WlzxSczWx57YDXXtTzeVx8/l3nTHlEVjhu4fO4aGmsnnAAQK3fPp7q+9uuYtfhXv7bYy8zGo4TT1h4XC4aqr188cYN045NS8xUJdLgXCKmau3ZPxbhkWeP8fNXTqYrMM5fUcfdW9q4tHlxTq8/U157SY2fRdVn0wqpI7JGI3ESlsGXnCV73ELfqL05ZbpZ7vUbmvibWy7JqVxMTzFRlUiDcwkKRuP84EA3PzjYRTh+tgLjrutaedd5y9Kz1lxqo6fKa0fiFmuX1EwIzCmTj8gaCcU4NRwmFLNruRuqvSyt9U85y53LiSR6iomqNBqcS8T+jgG+v/84Hf3jhKIJ4smp8qIqL5+6ai0fumTlhAqMbHLImSbntYeDMYZCMYLRBLdu3/e2mWpzQzWdZ8YYDds9pFNcAtU+F4PBGPGExfrl9TrLVWoONDiXgOfe6ufrv3ydsXA8HZQB3n3+Mr7w3vOomaICI9fa6FRe+9GDXRzvH2MsarGk1ofP7eLF44Pc8e0DrF9Wy5c+cAHXb2ji6rZG9h8deFv5oGCfDbikxkfr0lq+v+2qOX1m3XSiKp12oXG433YP8dWfv8ZQMJYOzPUBD6sWBRgcj00ZmMHOIQe8E7+9s9VG/96Fy/nxf7qG81YsYk1DFX6Pm5PDEQz2hpGjA0G+svMQuw738mzHAE11vgnPF+yFUxfCaDg+51K31KaT3tHwhE0nuw73zun1lCpFOnN2qGP94zywp5PfvHW2AqMmuQ3a73FhMDMG2lQO2TKGgfEosYSFS2TK8jOXCEtqfdQF7Nxyqq6488w4IvbjBkhYJn3gbNdgkCU1fs6MRTGp8wOTpXEidr56rqVuuulEKZ05O07/WIS//eUb3PHIwXRgrva6WVbrY/XiKvzJHRzTbUJJ2bqxmbFInFPDYeIJC8EOroPBKPs7BtLX+b1uVjdUpQMz2PnkUCxBNGFlHG8FPrcrvfkjdY3P7cLtSl1kB+ZE8kDZuZa6dQ0GJyxMgm46UZVHg7NDjEfiPPxMJ596aD8/S5bGrV5cxV996EL++x9cgMftIhRLYLCbKk21CSXTprZGGqq8uN32rNfjdrG8PkCt38OOA12ICA3VdsCfvJX77i1txBIGtwiWZew/mHT1RaqULZYw1AU8ydm1ndIQ7Jn2n1x/zpxnuanAn0k3nahKo2mNIoslLP7t5ZP8y75j6ZOpF1d5+fTVa/ngxSvTRzndIzLtJpTpjMcSrG2sRjIaXxkMp0dCrFwUmPaU61Rd8dd/cZg3esfwumFVXQCPW9JlcZm1x/HESPrQ1vVNdfNevNNNJ0ppy9CsxRIWXQu4fdsYw6/f6OPBvZ2cGLJ7Hwc8Lj7avoaPtTdPu9CXiy88+vLba5cTFivrA+y4++qsXqNY/YW1r7GqENrPGZwTnF/uGuL+3R0cPjUK2CmB33/nSm6/ei1LamfugZGLzFrnKq+bmGWRsODemy7SQKeUM2g/ZyfoPDPOA3s62JexIHftOUu487pW1i6ZvQfGbDv+pnr8nves5wfPd9E7Eqa5sUZnoEqVCJ05Z2k+M+e+0QiP/OYovzh0Kt0D48KVddy95RzeuWZRVq8x22ko0z3+5Q9cwAcvXTWncetGEKXyTmfOxTAWifPogS4ee76bSLIHxpqGKu7c3Mp165dO6Nw2m9l2/E1+vNrnIZpI8N39x+cUnPX0EaWKS4NzHtgVGCf4zr7jDCcrMBqqvXz66nX8wTtXpCswsrW/Y4BDJ4exLLsiorHGR43PM2HHX2ZXOZdL8LgEr9sz59pg3QiiVHFpcF5AljHser2Ph/Z2cjJ5+nTA6+Jj7c18rH3NhDaa2UqlK1K1xHHL0DsSoaneridObURJ7Qi0z+6zZ+TBaHzOtcF6+ohSxaXBeYG8eHyQ7bs7ef302QqMD168ik9fvZbGGt8sz55eKl2xtMZP72gYMQCGvtEIS2r96Y0ot13Zwj88/SaReGJBaoP19BGlikuD8zx19I3xwJ5Onus8W4Gx+dyl3HldKy2N8w9kqXSFvZEkwGAwSizZyyK1GFjr9/CRK9awrM6/YLXBuhFEqeLS4DxHfaMRvvnMUX756tkKjItW2b2L37E6uwqMbGQ2wa/1e6j1ewjFEiyp8XPVOUtYWudPH9q6kA3p9fQRpYpLg3OOxiJxvr//OD96oYdosgKjuaGKu65r49pzl+RUgZGN6Q53vf3qtaxpqJpxcXG+pXB6+ohSxaPBOUuReILHnu/mX/YdYyQcB6CxxsftV6/l99+58mxntgX2tsNdF1Vx93VtfODilTM+z0mlcFovrVTudBNKFva82cdf/PgVugftsrUqr5utG5u55Yo1VPmmbh6UD36vm6Y6/9u6yE3l1u373ragF4zGaaoLzPl0krnI/CGRmbvWLeRKAboJZX4CXjfdgyHcLuGDF6/kU1fNrwJjLhZX+2io9madNnFKKZzWSys1Nxqcs7BxXSP/543nc9HKepoXoAIjFy4Rmur9OddIO6UUzik/JJQqNdpsP0t3XddW8MDs87hY3VA1p80rqWb4wWgcY+y/i1EKp43zlZobDc4OVRfwTnlKSbau39DEvTddRFNdgOFQjKa6QFHyvE75IaFUqdG0hsNI8rDV+oB39otn4YRSuOs3NHFL9xAP7u1kPJqgxufmzs2tRR+XUk6nwdlBvG4XTfV+/J7pK0BKrSxt1+FeHnuhh2V1flqS1RqPvdDDxWsWO3rcShWbpjUcotrnSZ6uPXNg/srOQ/SOhifULu863FvAkeYms1pDxP7b6xbu391R7KEp5WganB2godrHikUBXLNsZCnFQNc1GJxwhiFotYZS2dDgXERul7BiUYCGLGumSzHQabWGUnOjwblIfB4XqxbnViZXioFOqzWUmhsNzkVQG/DMqUyuFAOdU0r6lCo1Wq1RQCJCY42PRVVzK5Mr1TaeTijpU6rUFCU4i0gj8CiwDjgKfMwYMzjFdbcDf5m8+T+MMY8k798FrARCycfeZ4xxbskC4HHZZXIB7/waJWmgU6oyFCut8SXgKWPMeuCp5O0JkgH8r4ArgU3AX4lIQ8YltxljLk3+cXRgrvK5Wd1QNe/ArJSqHMUKzjcDjyS/fgT4wymueT/whDFmIDmrfgK4sUDjWzCNNT5WLqrKW79npVR5KlZwXm6MOZn8+hSwfIprVgNdGbe7k/elfFNEXhKR/y4LffzIAnC7hJWLqlhcXdjWokqp8pC3nLOIPAmsmOKhL2feMMYYEcm14/9txpgeEakDfgR8Cvj2NOPYBmwDaGlpyfFt5iaQbIo/0xFSSik1k7wFZ2PMDdM9JiKnRWSlMeakiKwEpsoZ9wDXZ9xeA+xKvnZP8u9REfkedk56yuBsjNkObAf7JJTcP0luFlV5aazxLfhZgkqpylKsqd1O4Pbk17cDP53imseB94lIQ3Ih8H3A4yLiEZGlACLiBT4I/K4AY56R3RQ/wJJavwZmpdS8FavO+WvAD0TkDuAY8DEAEWkHPm+MudMYMyAiXwUOJJ9zb/K+Guwg7QXcwJPAA4X/CGd53S6W1wfweZyVxiiFDnalMEalikEPeM1SLGHRNfD2Hha1fg9La/2zNi0qtPkerFqIoDl5jGfGIgwGY9QFPKxvqtNArSqBHvCaD0tq/Cyqnn9T/HyYz8GqmUEzszXpLd1DPNsxsGABO3OMI6EY/eNRAIKRePo97wUN0KoiOev38BLhErubnFMDM8yvg91UrUmj8QTf2PXWgvaSzhzjmbEILgS3S4hZpiTaoSqVTzpzzpHP46Kpznn55cnmc/r2VCdmj4bjxC1rTjPxbMYYTVi4RTAGfMkSRCe0Q9WcuCoWZ0cYBxHOHrrq9MAM8+tgN1Vr0kjcwj+pbnu+wTNzjD63i4QxGAPL6vxA8duhluLJM6p8OD/KOITH7WJZXemUyc2nVedUgd3tkrelceYbPDPHWOV14RJhSa2XWr9nTu1Qdx3u5dbt+9j89ae5dfu+eQfRUjx5RpUPTWuUsbl2sJuqNenNl6zisRd6CEbjE6o/5ttLOnOMqRTCXNqhTreIOZ8FxanSO05ItajKoMFZTWmqwH7xmsV57SU9n3ao86lOmc588vZKzZcGZ5U1J/eSzscs9+4tbXxl56EF/21BqWxozlmVhXycr6hHbKli0pmzKgv5muU6+bcFVd505qzKgs5yVbnRmbMqGzrLVeVEZ85KKeVAGpyVUsqBNDgrpZQDac45C9r8RilVaDpznoU2v1FKFYMG51lo8xulVDFocJ7FfJrWK6XUXGlwnkU+tgUrpdRsNDjPYj5N65VSaq40OM9CtwUrpYpBS+myoNuClVKFpjNnpZRyIA3OSinlQBqclVLKgTQ4K6WUA2lwVkopB9JqjRKjTZiUqgw6cy4h2oRJqcqhwbmEaBMmpSqHBucSok2YlKocGpxLiDZhUqpyaHAuIdqESanKocG5hGgTJqUqh5bSlRhtwqRUZdCZs1JKOZAGZ6WUciANzkop5UCacy5BuoVbqfKnM+cSo1u4laoMGpxLjG7hVqoyaHAuMbqFW6nKUJTgLCKNIvKEiLyZ/Lthmut+ISJDIvLvk+5vFZHnROSIiDwqIr7CjLz4dAu3UpWhWDPnLwFPGWPWA08lb0/lb4BPTXH/14G/N8acCwwCd+RllA6kW7iVqgzFCs43A48kv34E+MOpLjLGPAWMZt4nIgK8B3hstueXI93CrVRlKFYp3XJjzMnk16eA5Tk8dwkwZIyJJ293A6unu1hEtgHbkjfHROT1aS5dCpzJYRyOsWP6h0r2M01DP4/zldtnyvfn+YUx5sapHshbcBaRJ4EVUzz05cwbxhgjIiZf4zDGbAe2z3adiBw0xrTnaxzFUG6fST+P85XbZyrm58lbcDbG3DDdYyJyWkRWGmNOishKIJci3X5gsYh4krPnNUDPPIerlFKOUqyc807g9uTXtwM/zfaJxhgD/Aq4ZS7PV0qpUlCs4Pw14L0i8iZwQ/I2ItIuIg+mLhKRPcAPgd8TkW4ReX/yoS8CXxCRI9g56IcWYEyzpj5KULl9Jv08zldun6lon0fsiahSSikn0R2CSinlQBqclVLKgSo2OGezhVxELhWRZ0XkkIj8VkQ+XoyxzkREbhSR15Nb2d+201JE/Mkt7keSW97XFX6UucniM31BRF5Nfk+eEpG1xRhntmb7PBnXfUREjIg4uhQtm88jIh9Lfo8Oicj3Cj3GXGXxb65FRH4lIi8m/939ft4HZYypyD/A/w18Kfn1l4CvT3HNecD65NergJPA4mKPPWN8buAtoA3wAS8DF0665j8B/5z8eivwaLHHvQCf6d1AdfLrP3byZ8rm8ySvqwN2A/uA9mKPe57fn/XAi0BD8nZTsce9AJ9pO/DHya8vBI7me1wVO3Mmiy3kxpg3jDFvJr8+gV2PvaxgI5zdJuCIMabDGBPF3ix486RrMj/nY9iVL1LAMeZq1s9kjPmVMSbVhm8fdq27U2XzPQL4KnbPmHAhBzcH2Xyeu4BvGGMGAYwxTm82ns1nMkB98utFwIl8D6qSg3NOW8hFZBP2T9W38j2wHKwGujJuT7WVPX2NsTftDGOXHzpVNp8p0x3Af+R1RPMz6+cRkcuBZmPMzwo5sDnK5vtzHnCeiDwjIvtEZMrtyQ6SzWf6a+CTItIN/Bz4z/keVFkfU7VQW8iTuxi/A9xujLEWdpRqrkTkk0A78K5ij2WuRMQF/B3wmSIPZSF5sFMb12P/VrNbRN5pjBkq6qjm51bgW8aYvxWRq4HviMg78hkPyjo4mwXYQi4i9cDPgC8bY/blaahz1QM0Z9yeait76ppuEfFg/0rWX5jhzUk2nwkRuQH7h+y7jDGRAo1tLmb7PHXAO4BdyWzTCmCniNxkjDlYsFFmX9s+fQAAAqFJREFUL5vvTzfwnDEmBnSKyBvYwfpAYYaYs2w+0x3AjQDGmGdFJIDdFClvKZtKTmvMuoU82cT/X4FvG2Mem/y4AxwA1icPH/BhL/jtnHRN5ue8BXjaJFc1HGrWzyQilwH3AzeVQD5zxs9jjBk2xiw1xqwzxqzDzqE7NTBDdv/mfoI9a0ZElmKnOZx8jlo2n+k48HsAInIBEAD68jqqYq+UFusPdt71KeBN4EmgMXl/O/Bg8utPAjHgpYw/lxZ77JM+x+8Db2Dnwr+cvO9e7P/BSf4j+iFwBNgPtBV7zAvwmZ4ETmd8T3YWe8zz+TyTrt2Fg6s1svz+CHaq5lXgFWBrsce8AJ/pQuAZ7EqOl4D35XtMun1bKaUcqJLTGkop5VganJVSyoE0OCullANpcFZKKQfS4KyUUg6kwVmpPBGRsWKPQZUuDc5K5UBE3MUeg6oMGpyVShKRdSJyWES+KyKvichjIlItIkdF5Osi8gLwURE5R0R+ISLPi8geEdmQfH5rsv/3KyLyP4r8cVSJ0+Cs1ETnA/9ojLkAGMHuhw3Qb4y53BizA7u37382xlwB/Dnwj8lr7gP+yRjzTuze30rNme4QVCopeUrMbmNMS/L2e4A/Ay7FbrB0TERqsXsqvJ7xVL8x5gIR6QdWGGNiyYZZJ4wxtQX9EKpslHVXOqXmYPJsJXV7PPm3Cxgyxlya5fOVmhNNayg1UUuyXy/AJ4C9mQ8aY0aw22B+FEBslyQffga7oxnAbYUYrCpfGpyVmuh14E9E5DWgAfinKa65DbhDRF4GDnH2SKN7ks99hZlPb1FqVppzViopmXP+d2PMO4o8FKV05qyUUk6kM2ellHIgnTkrpZQDaXBWSikH0uCslFIOpMFZKaUcSIOzUko50P8Pr0GfBa+Ts38AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#import statsmodels.regression.linear_model as sm\n", + "import statsmodels.api as sm\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "import numpy as np\n", + "np.random.seed(0)\n", + "\n", + "comb = pdf[[\"pred\", \"actual\"]].copy()\n", + "\n", + "comb = comb.dropna()\n", + "X = pdf[[\"pred\"]]\n", + "Y = pdf[[\"actual\"]]\n", + "model2 = sm.OLS(Y,sm.add_constant(X), data=comb)\n", + "model_fit = model2.fit()\n", + "print(model_fit.summary())\n", + "\n", + "#Plot\n", + "pdf[[\"pred\", \"actual\"]].plot(kind='scatter', x=\"pred\", y=\"actual\")\n", + "#plt.ylim(-0.2, 0.2)\n", + "#plt.xlim(-0.2, 0.2)\n", + "#Seaborn\n", + "sns.lmplot(x=\"pred\", y=\"actual\", data=pdf)\n", + "plt.ylim(-0.1, 0.2)\n", + "#plt.xlim(-0.2, 0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add lag features\n", + "\n", + "Looks like adding lag features made it worse" + ] + }, + { + "cell_type": "code", + "execution_count": 402, + "metadata": {}, + "outputs": [], + "source": [ + "df = get_crypto_data(\"BTC/USDT\", \"2019-01-01\", \"2020-08-23\").reset_index().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 403, + "metadata": {}, + "outputs": [], + "source": [ + "X = add_all_ta_features(\n", + " df, open=\"open\", high=\"high\", low=\"low\", close=\"close\", volume=\"volume\")" + ] + }, + { + "cell_type": "code", + "execution_count": 404, + "metadata": {}, + "outputs": [], + "source": [ + "X = X.iloc[: -1]\n", + "X[\"pct_change\"] = df.close.pct_change()\n", + "X[\"pct_change_lag1\"] = X[\"pct_change\"].shift()\n", + "X = X.fillna(-1)\n", + "y = df.close.pct_change().shift(-1).iloc[:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 405, + "metadata": {}, + "outputs": [], + "source": [ + "if \"dt\" in X.columns:\n", + " del X[\"dt\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 406, + "metadata": {}, + "outputs": [], + "source": [ + "X_1 = X.shift().fillna(-1)\n", + "X_1.columns = [c + \"_1\" for c in X.columns]" + ] + }, + { + "cell_type": "code", + "execution_count": 407, + "metadata": {}, + "outputs": [], + "source": [ + "X_comb = pd.concat([X, X_1], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 408, + "metadata": {}, + "outputs": [], + "source": [ + "X_full_train, X_full_test, y_train, y_test = X_comb.iloc[:-100], X_comb.iloc[-100:], y.iloc[:-100], y.iloc[-100:]\n", + "#X_filtered_train, X_filtered_test = X_full_train[X_filtered.columns], X_full_test[X_filtered.columns]\n", + "X_filtered_train, X_filtered_test = X_full_train, X_full_test" + ] + }, + { + "cell_type": "code", + "execution_count": 411, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 411, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "regressor_full = LinearRegression()\n", + "#regressor_full = RandomForestRegressor()\n", + "regressor_full.fit(X_full_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 420, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.15, 0.2)" + ] + }, + "execution_count": 420, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Out of sample\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "pdf = pd.DataFrame(dict(pred=regressor_full.predict(X_full_test), actual=y_test))\n", + "\n", + "pdf.plot.scatter(0, 1)\n", + "plt.xlim(-0.1, 0.2)\n", + "plt.ylim(-0.15, 0.20)" + ] + }, + { + "cell_type": "code", + "execution_count": 424, + "metadata": {}, + "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", + "
predactual
pred1.0000000.332945
actual0.3329451.000000
\n", + "
" + ], + "text/plain": [ + " pred actual\n", + "pred 1.000000 0.332945\n", + "actual 0.332945 1.000000" + ] + }, + "execution_count": 424, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdf.corr()" + ] + }, + { + "cell_type": "code", + "execution_count": 418, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'LinearRegression' object has no attribute 'feature_importances_'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfeat_importance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"importance\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mregressor_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeature_importances_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"feat\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mX_full_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'LinearRegression' object has no attribute 'feature_importances_'" + ] + } + ], + "source": [ + "feat_importance = pd.DataFrame({\"importance\": regressor_full.feature_importances_, \"feat\": X_full_train.columns})" + ] + }, + { + "cell_type": "code", + "execution_count": 369, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(160, 2)" + ] + }, + "execution_count": 369, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_importance.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 370, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'TA Feature Importance for Predicting BTC returns')" + ] + }, + "execution_count": 370, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "feat_importance.set_index(\"feat\").sort_values(ascending=True, by=\"importance\").plot.barh(figsize=(15, 30))\n", + "plt.title(\"TA Feature Importance for Predicting BTC returns\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 371, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RandomForestRegressor()" + ] + }, + "execution_count": 371, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "top_feats = feat_importance.set_index(\"feat\").importance.sort_values(ascending=False).head(50).index.values\n", + "regressor_top = RandomForestRegressor()\n", + "regressor_top.fit(X_full_train[top_feats], y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 425, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.15, 0.15)" + ] + }, + "execution_count": 425, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Out of sample\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "pdf = pd.DataFrame(dict(pred=regressor_top.predict(X_full_test[top_feats]), actual=y_test))\n", + "\n", + "pdf.plot.scatter(0, 1)\n", + "plt.xlim(-0.1, 0.1)\n", + "plt.ylim(-0.15, 0.15)" + ] + }, + { + "cell_type": "code", + "execution_count": 373, + "metadata": {}, + "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", + "
predactual
pred1.000000.04023
actual0.040231.00000
\n", + "
" + ], + "text/plain": [ + " pred actual\n", + "pred 1.00000 0.04023\n", + "actual 0.04023 1.00000" + ] + }, + "execution_count": 373, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdf.corr()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Looking intro specifiying as classification problem" + ] + }, + { + "cell_type": "code", + "execution_count": 374, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 374, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD4CAYAAADrRI2NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAPlUlEQVR4nO3df6zdd13H8eeb1c1lF9bN4rV2lYuxIRkUC7uOEUHOzRC6kdiZkLllbC3OVMNITKwJ1f0BkSwpmoqS6cJVFjoVLnMy16wD3a5cJ4kDWpztNhyr0LmW0gp0dXdbwDve/nG/nWfl3t7z+5x7Ps9HcnO+Pz/f97v39HW/53vP+d7ITCRJ5XhZvwuQJPWWwS9JhTH4JakwBr8kFcbgl6TCrOh3AQCrVq3KsbGxpvZ59tlnOe+887pTUJ8MY09gX8vJMPYEw9vXvn37vpOZr2x2v4EI/rGxMfbu3dvUPjMzM9Rqte4U1CfD2BPY13IyjD3B8PYVEU+2sp+XeiSpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTAD8cldST9qbPuenh9z2/o5aj0/qnrNM35JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjH+BS9JL9OMvf51yaMe7+nbsknjGL0mFMfglqTAGvyQVxuCXpMIY/JJUmCWDPyLWRsQXIuKxiHg0In67Wn5hRNwfEU9UjxdUyyMiPhYRByNif0S8sdtNSJIa18gZ/xywLTMvBi4DboqIi4HtwHRmrgOmq3mAK4B11ddW4LaOVy1JatmSwZ+ZRzPzq9X0M8DXgDXAJmBXtdku4KpqehNwR857CFgZEas7XrkkqSVNXeOPiDHgDcCXgNHMPFqt+jYwWk2vAZ6q2+1wtUySNAAiMxvbMGIE+Gfglsz8bEQ8nZkr69afyMwLIuJeYEdmfrFaPg18IDP3njbeVuYvBTE6OnrJ1NRUU4XPzs4yMjLS1D6Dbhh7Avtq1YEjJ7s29mJGz4Vjz/f8sC9av+b8row7rM/BiYmJfZk53ux+Dd2yISJ+DPg74G8y87PV4mMRsTozj1aXco5Xy48Aa+t2v6ha9hKZOQlMAoyPj2etVmuq8JmZGZrdZ9ANY09gX63a0odbJ2xbP8fOA/27k8uh62pdGXdYn4OtauRdPQF8AvhaZv5x3ardwOZqejNwT93yG6p391wGnKy7JCRJ6rNGfrT/InA9cCAiHq6W/T6wA7gzIm4EngSurtbdB1wJHASeA97b0YolSW1ZMvira/WxyOrLF9g+gZvarEuS1CV+cleSCmPwS1JhDH5JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhVky+CPi9og4HhGP1C37UEQciYiHq68r69b9XkQcjIjHI+Kd3SpcktSaRs74PwlsXGD5RzNzQ/V1H0BEXAxcA7y22ufPI+KsThUrSWrfksGfmQ8C32twvE3AVGZ+PzO/CRwELm2jPklSh0VmLr1RxBhwb2a+rpr/ELAF+B9gL7AtM09ExK3AQ5n519V2nwA+l5l3LTDmVmArwOjo6CVTU1NNFT47O8vIyEhT+wy6YewJ7KtVB46c7NrYixk9F4493/PDvmj9mvO7Mu6wPgcnJib2ZeZ4s/utaPF4twEfBrJ63An8ejMDZOYkMAkwPj6etVqtqQJmZmZodp9BN4w9gX21asv2PV0bezHb1s+x80CrsdC+Q9fVujLusD4HW9XSu3oy81hmvpCZPwT+gv+/nHMEWFu36UXVMknSgGgp+CNidd3srwKn3vGzG7gmIs6JiFcD64Avt1eiJKmTlnxNFxGfBmrAqog4DHwQqEXEBuYv9RwCfhMgMx+NiDuBx4A54KbMfKE7pUuSWrFk8GfmtQss/sQZtr8FuKWdoiRJ3eMndyWpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUmCWDPyJuj4jjEfFI3bILI+L+iHiierygWh4R8bGIOBgR+yPijd0sXpLUvEbO+D8JbDxt2XZgOjPXAdPVPMAVwLrqaytwW2fKlCR1ypLBn5kPAt87bfEmYFc1vQu4qm75HTnvIWBlRKzuVLGSpPZFZi69UcQYcG9mvq6afzozV1bTAZzIzJURcS+wIzO/WK2bBj6QmXsXGHMr868KGB0dvWRqaqqpwmdnZxkZGWlqn0E3jD2BfbXqwJGTXRt7MaPnwrHne37YF61fc35Xxh3W5+DExMS+zBxvdr8V7R44MzMilv7p8aP7TQKTAOPj41mr1Zraf2Zmhmb3GXTD2BPYV6u2bN/TtbEXs239HDsPtB0LLTt0Xa0r4w7rc7BVrb6r59ipSzjV4/Fq+RFgbd12F1XLJEkDotXg3w1srqY3A/fULb+henfPZcDJzDzaZo2SpA5a8jVdRHwaqAGrIuIw8EFgB3BnRNwIPAlcXW1+H3AlcBB4DnhvF2qWJLVhyeDPzGsXWXX5AtsmcFO7RUmSusdP7kpSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMCva2TkiDgHPAC8Ac5k5HhEXAp8BxoBDwNWZeaK9MiVJndKJM/6JzNyQmePV/HZgOjPXAdPVvCRpQHTjUs8mYFc1vQu4qgvHkCS1KDKz9Z0jvgmcABL4eGZORsTTmbmyWh/AiVPzp+27FdgKMDo6esnU1FRTx56dnWVkZKTl2gfRMPYE9tWqA0dOdm3sxYyeC8ee7/lhX7R+zfldGXdYn4MTExP76q62NKyta/zAWzLzSET8JHB/RPxH/crMzIhY8CdLZk4CkwDj4+NZq9WaOvDMzAzN7jPohrEnsK9Wbdm+p2tjL2bb+jl2Hmg3Flp36LpaV8Yd1udgq9q61JOZR6rH48DdwKXAsYhYDVA9Hm+3SElS57Qc/BFxXkS8/NQ08A7gEWA3sLnabDNwT7tFSpI6p53XdKPA3fOX8VkBfCozPx8RXwHujIgbgSeBq9svU5LUKS0Hf2Z+A/j5BZZ/F7i8naIkSd3jJ3clqTAGvyQVxuCXpMIY/JJUGINfkgpj8EtSYQx+SSqMwS9JhTH4JakwBr8kFcbgl6TCGPySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMAa/JBWmnb+5KxVhbPueBZdvWz/HlkXWqTWL/Vu3a6nv1aEd7+rKcQeVZ/ySVBiDX5IKY/BLUmEMfkkqjMEvSYUx+CWpMAa/JBXG4Jekwhj8klQYg1+SCmPwS1JhDH5JKozBL0mFMfglqTDelllS8bp1O+hG9OOW0J7xS1JhDH5JKkzXLvVExEbgT4GzgL/MzB3dOpaGXz9fikvDpitn/BFxFvBnwBXAxcC1EXFxN44lSWpOt874LwUOZuY3ACJiCtgEPNbpA5X2SxlJaldkZucHjXg3sDEzf6Oavx54U2a+v26brcDWavY1wONNHmYV8J0OlDtIhrEnsK/lZBh7guHt6zWZ+fJmd+rb2zkzcxKYbHX/iNibmeMdLKnvhrEnsK/lZBh7guHuq5X9uvWuniPA2rr5i6plkqQ+61bwfwVYFxGvjoizgWuA3V06liSpCV251JOZcxHxfuAfmH875+2Z+WiHD9PyZaIBNow9gX0tJ8PYE9jXS3Tll7uSpMHlJ3clqTAGvyQVZtkEf0RcGBH3R8QT1eMFZ9j2FRFxOCJu7WWNzWqkp4h4VUR8NSIejohHI+K3+lFrMxrsa0NE/GvV0/6I+LV+1NqMRp+DEfH5iHg6Iu7tdY2NioiNEfF4RByMiO0LrD8nIj5Trf9SRIz1vsrmNdDXL1X/n+aqzxstCw309TsR8Vj1f2k6Il51pvGWTfAD24HpzFwHTFfzi/kw8GBPqmpPIz0dBd6cmRuANwHbI+Kne1hjKxrp6znghsx8LbAR+JOIWNnDGlvR6HPwj4Dre1ZVkxq8pcqNwInM/Dngo8BHeltl8xrs67+ALcCneltd6xrs69+A8cx8PXAX8IdnGnM5Bf8mYFc1vQu4aqGNIuISYBT4xx7V1Y4le8rMH2Tm96vZc1ge37NG+vp6Zj5RTX8LOA68smcVtqah52BmTgPP9KqoFrx4S5XM/AFw6pYq9ep7vQu4PCKihzW2Ysm+MvNQZu4HftiPAlvUSF9fyMznqtmHmP/s1KKWQ4icMpqZR6vpbzMf7i8RES8DdgK/28vC2rBkTwARsTYi9gNPAR+pgnKQNdTXKRFxKXA28J/dLqxNTfU1wNYw/1w65XC1bMFtMnMOOAn8RE+qa10jfS1HzfZ1I/C5Mw04UH+BKyIeAH5qgVU3189kZkbEQu9DfR9wX2YeHpSTkw70RGY+Bby+usTz9xFxV2Ye63y1jetEX9U4q4G/AjZnZt/PwjrVl9QPEfEeYBx425m2G6jgz8y3L7YuIo5FxOrMPFqFxfEFNnsz8NaIeB8wApwdEbOZeabfB3RVB3qqH+tbEfEI8FbmX373TSf6iohXAHuAmzPzoS6V2pROfr8GWCO3VDm1zeGIWAGcD3y3N+W1bFhvFdNQXxHxduZPUN5Wd3l4QcvpUs9uYHM1vRm45/QNMvO6zPyZzBxj/nLPHf0M/QYs2VNEXBQR51bTFwBvofk7mfZaI32dDdzN/Peorz/EmrBkX8tEI7dUqe/13cA/5eB/2nNYbxWzZF8R8Qbg48CvZObSJySZuSy+mL++OA08ATwAXFgtH2f+L3ydvv0W4NZ+191uT8AvA/uBf68et/a77g719R7gf4GH67429Lv2TjwHgX8B/ht4nvnrse/sd+0L9HIl8HXmf69yc7XsD6rgAPhx4G+Bg8CXgZ/td80d6usXqu/Js8y/gnm03zV3qK8HgGN1/5d2n2k8b9kgSYVZTpd6JEkdYPBLUmEMfkkqjMEvSYUx+CWpMAa/JBXG4JekwvwfhgM/rMOw+7YAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 375, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 499.000000\n", + "mean 0.002803\n", + "std 0.041368\n", + "min -0.395048\n", + "25% -0.013306\n", + "50% 0.001246\n", + "75% 0.018538\n", + "max 0.171968\n", + "Name: close, dtype: float64" + ] + }, + "execution_count": 375, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# One approach would be to specify as a ternary classification problem\n", + "#\n", + "y.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/dependencies/fastquant/examples/jfc_rsi.ipynb b/dependencies/fastquant/examples/jfc_rsi.ipynb new file mode 100644 index 0000000..a4084a1 --- /dev/null +++ b/dependencies/fastquant/examples/jfc_rsi.ipynb @@ -0,0 +1,2464 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: backtrader[plotting] in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (1.9.74.123)\r\n", + "Requirement already satisfied: matplotlib; extra == \"plotting\" in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from backtrader[plotting]) (3.0.2)\r\n", + "Requirement already satisfied: numpy>=1.10.0 in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from matplotlib; extra == \"plotting\"->backtrader[plotting]) (1.15.4)\r\n", + "Requirement already satisfied: cycler>=0.10 in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from matplotlib; extra == \"plotting\"->backtrader[plotting]) (0.10.0)\r\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from matplotlib; extra == \"plotting\"->backtrader[plotting]) (1.0.1)\r\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from matplotlib; extra == \"plotting\"->backtrader[plotting]) (2.3.0)\r\n", + "Requirement already satisfied: python-dateutil>=2.1 in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from matplotlib; extra == \"plotting\"->backtrader[plotting]) (2.7.5)\r\n", + "Requirement already satisfied: six in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from cycler>=0.10->matplotlib; extra == \"plotting\"->backtrader[plotting]) (1.12.0)\r\n", + "Requirement already satisfied: setuptools in /Users/enzoampil/anaconda3/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib; extra == \"plotting\"->backtrader[plotting]) (40.6.3)\r\n" + ] + } + ], + "source": [ + "#!pip install backtrader[plotting]" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Portfolio Value: 100000.00\n", + "2017-01-03, Cash 100000.0 Value 100000.0\n", + "2017-01-04, Cash 100000.0 Value 100000.0\n", + "2017-01-05, Cash 100000.0 Value 100000.0\n", + "2017-01-06, Cash 100000.0 Value 100000.0\n", + "2017-01-09, Cash 100000.0 Value 100000.0\n", + "2017-01-10, Cash 100000.0 Value 100000.0\n", + "2017-01-11, Cash 100000.0 Value 100000.0\n", + "2017-01-12, Cash 100000.0 Value 100000.0\n", + "2017-01-13, Cash 100000.0 Value 100000.0\n", + "2017-01-16, Cash 100000.0 Value 100000.0\n", + "2017-01-17, Cash 100000.0 Value 100000.0\n", + "2017-01-18, Cash 100000.0 Value 100000.0\n", + "2017-01-19, Cash 100000.0 Value 100000.0\n", + "2017-01-20, Cash 100000.0 Value 100000.0\n", + "2017-01-23, Cash 100000.0 Value 100000.0\n", + "2017-01-23, Close, 207.00\n", + "rsi: 57.57575757575758\n", + "2017-01-24, Cash 100000.0 Value 100000.0\n", + "2017-01-24, Close, 206.00\n", + "rsi: 56.26423690205011\n", + "2017-01-25, Cash 100000.0 Value 100000.0\n", + "2017-01-25, Close, 207.20\n", + "rsi: 57.51489361702126\n", + "2017-01-26, Cash 100000.0 Value 100000.0\n", + "2017-01-26, Close, 207.00\n", + "rsi: 57.221201818489725\n", + "2017-01-27, Cash 100000.0 Value 100000.0\n", + "2017-01-27, Close, 208.00\n", + "rsi: 58.36596252624558\n", + "2017-01-30, Cash 100000.0 Value 100000.0\n", + "2017-01-30, Close, 209.00\n", + "rsi: 59.53218282864497\n", + "2017-01-31, Cash 100000.0 Value 100000.0\n", + "2017-01-31, Close, 205.60\n", + "rsi: 53.99430206010131\n", + "2017-02-01, Cash 100000.0 Value 100000.0\n", + "2017-02-01, Close, 207.00\n", + "rsi: 55.81686334368651\n", + "2017-02-02, Cash 100000.0 Value 100000.0\n", + "2017-02-02, Close, 206.40\n", + "rsi: 54.814616278869345\n", + "2017-02-03, Cash 100000.0 Value 100000.0\n", + "2017-02-03, Close, 206.00\n", + "rsi: 54.11696844524332\n", + "2017-02-06, Cash 100000.0 Value 100000.0\n", + "2017-02-06, Close, 208.00\n", + "rsi: 57.05975699324669\n", + "2017-02-07, Cash 100000.0 Value 100000.0\n", + "2017-02-07, Close, 206.60\n", + "rsi: 54.42819498418347\n", + "2017-02-08, Cash 100000.0 Value 100000.0\n", + "2017-02-08, Close, 206.00\n", + "rsi: 53.29378982441762\n", + "2017-02-09, Cash 100000.0 Value 100000.0\n", + "2017-02-09, Close, 206.00\n", + "rsi: 53.29378982441762\n", + "2017-02-10, Cash 100000.0 Value 100000.0\n", + "2017-02-10, Close, 206.00\n", + "rsi: 53.29378982441762\n", + "2017-02-13, Cash 100000.0 Value 100000.0\n", + "2017-02-13, Close, 207.00\n", + "rsi: 55.235913091509744\n", + "2017-02-14, Cash 100000.0 Value 100000.0\n", + "2017-02-14, Close, 206.00\n", + "rsi: 52.868448924592876\n", + "2017-02-15, Cash 100000.0 Value 100000.0\n", + "2017-02-15, Close, 201.40\n", + "rsi: 43.6090812610354\n", + "2017-02-16, Cash 100000.0 Value 100000.0\n", + "2017-02-16, Close, 206.00\n", + "rsi: 52.557338977765546\n", + "2017-02-17, Cash 100000.0 Value 100000.0\n", + "2017-02-17, Close, 205.00\n", + "rsi: 50.674782315291274\n", + "2017-02-20, Cash 100000.0 Value 100000.0\n", + "2017-02-20, Close, 205.00\n", + "rsi: 50.674782315291274\n", + "2017-02-21, Cash 100000.0 Value 100000.0\n", + "2017-02-21, Close, 206.00\n", + "rsi: 52.64210867797726\n", + "2017-02-22, Cash 100000.0 Value 100000.0\n", + "2017-02-22, Close, 201.80\n", + "rsi: 44.596762950484504\n", + "2017-02-23, Cash 100000.0 Value 100000.0\n", + "2017-02-23, Close, 203.00\n", + "rsi: 47.085082745282975\n", + "2017-02-24, Cash 100000.0 Value 100000.0\n", + "2017-02-24, Close, 201.80\n", + "rsi: 44.91275459606706\n", + "2017-02-27, Cash 100000.0 Value 100000.0\n", + "2017-02-27, Close, 203.00\n", + "rsi: 47.52022129354347\n", + "2017-02-28, Cash 100000.0 Value 100000.0\n", + "2017-02-28, Close, 201.80\n", + "rsi: 45.21539233994006\n", + "2017-03-01, Cash 100000.0 Value 100000.0\n", + "2017-03-01, Close, 202.80\n", + "rsi: 47.50056143981531\n", + "2017-03-02, Cash 100000.0 Value 100000.0\n", + "2017-03-02, Close, 203.40\n", + "rsi: 48.8784056348595\n", + "2017-03-03, Cash 100000.0 Value 100000.0\n", + "2017-03-03, Close, 201.00\n", + "rsi: 43.913734369217664\n", + "2017-03-06, Cash 100000.0 Value 100000.0\n", + "2017-03-06, Close, 198.00\n", + "rsi: 38.631584880213715\n", + "2017-03-07, Cash 100000.0 Value 100000.0\n", + "2017-03-07, Close, 194.90\n", + "rsi: 34.07100206269672\n", + "2017-03-08, Cash 100000.0 Value 100000.0\n", + "2017-03-08, Close, 193.80\n", + "rsi: 32.60033113579705\n", + "2017-03-09, Cash 100000.0 Value 100000.0\n", + "2017-03-09, Close, 197.10\n", + "rsi: 40.84924603430075\n", + "2017-03-10, Cash 100000.0 Value 100000.0\n", + "2017-03-10, Close, 194.00\n", + "rsi: 36.348744515817366\n", + "2017-03-13, Cash 100000.0 Value 100000.0\n", + "2017-03-13, Close, 196.80\n", + "rsi: 42.50975628133897\n", + "2017-03-14, Cash 100000.0 Value 100000.0\n", + "2017-03-14, Close, 197.00\n", + "rsi: 42.93464406261318\n", + "2017-03-15, Cash 100000.0 Value 100000.0\n", + "2017-03-15, Close, 196.00\n", + "rsi: 41.291427960092314\n", + "2017-03-16, Cash 100000.0 Value 100000.0\n", + "2017-03-16, Close, 196.00\n", + "rsi: 41.29142796009232\n", + "2017-03-17, Cash 100000.0 Value 100000.0\n", + "2017-03-17, Close, 193.20\n", + "rsi: 36.72687556225484\n", + "2017-03-20, Cash 100000.0 Value 100000.0\n", + "2017-03-20, Close, 192.80\n", + "rsi: 36.11271061521475\n", + "2017-03-21, Cash 100000.0 Value 100000.0\n", + "2017-03-21, Close, 194.00\n", + "rsi: 39.38739844066971\n", + "2017-03-22, Cash 100000.0 Value 100000.0\n", + "2017-03-22, Close, 191.00\n", + "rsi: 34.6110605520616\n", + "2017-03-23, Cash 100000.0 Value 100000.0\n", + "2017-03-23, Close, 190.20\n", + "rsi: 33.44629329076908\n", + "2017-03-24, Cash 100000.0 Value 100000.0\n", + "2017-03-24, Close, 188.00\n", + "rsi: 30.414990556714756\n", + "2017-03-27, Cash 100000.0 Value 100000.0\n", + "2017-03-27, Close, 182.10\n", + "rsi: 24.105302169457104\n", + "2017-03-27, BUY CREATE, 182.10\n", + "2017-03-28, BUY EXECUTED, Price: 184.00, Cost: 9936.00, Comm 59.62\n", + "2017-03-28, Cash 90004.384 Value 99859.384\n", + "2017-03-28, Close, 182.50\n", + "rsi: 25.237691045051733\n", + "2017-03-28, BUY CREATE, 182.50\n", + "2017-03-29, BUY EXECUTED, Price: 183.10, Cost: 9887.40, Comm 59.32\n", + "2017-03-29, Cash 80057.65960000001 Value 100361.65960000001\n", + "2017-03-29, Close, 188.00\n", + "rsi: 38.76652702669176\n", + "2017-03-30, Cash 80057.65960000001 Value 101063.65960000001\n", + "2017-03-30, Close, 194.50\n", + "rsi: 50.22923852301827\n", + "2017-03-31, Cash 80057.65960000001 Value 101387.65960000001\n", + "2017-03-31, Close, 197.50\n", + "rsi: 54.46593609636357\n", + "2017-04-03, Cash 80057.65960000001 Value 101333.65960000001\n", + "2017-04-03, Close, 197.00\n", + "rsi: 53.646290130569014\n", + "2017-04-04, Cash 80057.65960000001 Value 101441.65960000001\n", + "2017-04-04, Close, 198.00\n", + "rsi: 55.10157209538342\n", + "2017-04-05, Cash 80057.65960000001 Value 101463.25960000002\n", + "2017-04-05, Close, 198.20\n", + "rsi: 55.40313758006725\n", + "2017-04-06, Cash 80057.65960000001 Value 101657.65960000001\n", + "2017-04-06, Close, 200.00\n", + "rsi: 58.12892393820978\n", + "2017-04-07, Cash 80057.65960000001 Value 102780.85960000001\n", + "2017-04-07, Close, 210.40\n", + "rsi: 69.66536399831395\n", + "2017-04-10, Cash 80057.65960000001 Value 102586.45960000002\n", + "2017-04-10, Close, 208.60\n", + "rsi: 66.2624644793492\n", + "2017-04-11, Cash 80057.65960000001 Value 102478.45960000002\n", + "2017-04-11, Close, 207.60\n", + "rsi: 64.38097437587349\n", + "2017-04-12, Cash 80057.65960000001 Value 102608.05960000001\n", + "2017-04-12, Close, 208.80\n", + "rsi: 65.64173184064202\n", + "2017-04-17, Cash 80057.65960000001 Value 102629.65960000001\n", + "2017-04-17, Close, 209.00\n", + "rsi: 65.85863398210353\n", + "2017-04-18, Cash 80057.65960000001 Value 102413.65960000001\n", + "2017-04-18, Close, 207.00\n", + "rsi: 61.66621615423943\n", + "2017-04-19, Cash 80057.65960000001 Value 102024.85960000001\n", + "2017-04-19, Close, 203.40\n", + "rsi: 54.89256878500411\n", + "2017-04-20, Cash 80057.65960000001 Value 102197.65960000001\n", + "2017-04-20, Close, 205.00\n", + "rsi: 57.145627888771685\n", + "2017-04-21, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-04-21, Close, 208.00\n", + "rsi: 61.07184462089354\n", + "2017-04-24, Cash 80057.65960000001 Value 102780.85960000001\n", + "2017-04-24, Close, 210.40\n", + "rsi: 63.91973654238581\n", + "2017-04-25, Cash 80057.65960000001 Value 103169.65960000001\n", + "2017-04-25, Close, 214.00\n", + "rsi: 67.73297957189672\n", + "2017-04-26, Cash 80057.65960000001 Value 103169.65960000001\n", + "2017-04-26, Close, 214.00\n", + "rsi: 67.73297957189672\n", + "2017-04-27, Cash 80057.65960000001 Value 102737.65960000001\n", + "2017-04-27, Close, 210.00\n", + "rsi: 59.61402539096893\n", + "2017-05-02, Cash 80057.65960000001 Value 103364.05960000001\n", + "2017-05-02, Close, 215.80\n", + "rsi: 65.98150659102396\n", + "2017-05-03, Cash 80057.65960000001 Value 103083.25960000002\n", + "2017-05-03, Close, 213.20\n", + "rsi: 61.31458070557425\n", + "2017-05-04, Cash 80057.65960000001 Value 103104.85960000001\n", + "2017-05-04, Close, 213.40\n", + "rsi: 61.53993199897091\n", + "2017-05-05, Cash 80057.65960000001 Value 103385.65960000001\n", + "2017-05-05, Close, 216.00\n", + "rsi: 64.43996513657225\n", + "2017-05-08, Cash 80057.65960000001 Value 103666.45960000002\n", + "2017-05-08, Close, 218.60\n", + "rsi: 67.11070825080859\n", + "2017-05-09, Cash 80057.65960000001 Value 103709.65960000001\n", + "2017-05-09, Close, 219.00\n", + "rsi: 67.51493496054147\n", + "2017-05-10, Cash 80057.65960000001 Value 102845.65960000001\n", + "2017-05-10, Close, 211.00\n", + "rsi: 53.383347058478726\n", + "2017-05-11, Cash 80057.65960000001 Value 103061.65960000001\n", + "2017-05-11, Close, 213.00\n", + "rsi: 55.8701873025069\n", + "2017-05-12, Cash 80057.65960000001 Value 102953.65960000001\n", + "2017-05-12, Close, 212.00\n", + "rsi: 54.3101237912617\n", + "2017-05-15, Cash 80057.65960000001 Value 102305.65960000001\n", + "2017-05-15, Close, 206.00\n", + "rsi: 46.008935403912126\n", + "2017-05-16, Cash 80057.65960000001 Value 102197.65960000001\n", + "2017-05-16, Close, 205.00\n", + "rsi: 44.78041871591914\n", + "2017-05-17, Cash 80057.65960000001 Value 102197.65960000001\n", + "2017-05-17, Close, 205.00\n", + "rsi: 44.78041871591914\n", + "2017-05-18, Cash 80057.65960000001 Value 101657.65960000001\n", + "2017-05-18, Close, 200.00\n", + "rsi: 38.776355749596824\n", + "2017-05-19, Cash 80057.65960000001 Value 101981.65960000001\n", + "2017-05-19, Close, 203.00\n", + "rsi: 43.65757750015675\n", + "2017-05-22, Cash 80057.65960000001 Value 101895.25960000002\n", + "2017-05-22, Close, 202.20\n", + "rsi: 42.68036084728746\n", + "2017-05-23, Cash 80057.65960000001 Value 101765.65960000001\n", + "2017-05-23, Close, 201.00\n", + "rsi: 41.19096832332321\n", + "2017-05-24, Cash 80057.65960000001 Value 102327.25960000002\n", + "2017-05-24, Close, 206.20\n", + "rsi: 49.426813703752444\n", + "2017-05-25, Cash 80057.65960000001 Value 102413.65960000001\n", + "2017-05-25, Close, 207.00\n", + "rsi: 50.573630885311864\n", + "2017-05-26, Cash 80057.65960000001 Value 101808.85960000001\n", + "2017-05-26, Close, 201.40\n", + "rsi: 43.19043812373672\n", + "2017-05-29, Cash 80057.65960000001 Value 101981.65960000001\n", + "2017-05-29, Close, 203.00\n", + "rsi: 45.63260445971936\n", + "2017-05-30, Cash 80057.65960000001 Value 102068.05960000001\n", + "2017-05-30, Close, 203.80\n", + "rsi: 46.862614538324735\n", + "2017-05-31, Cash 80057.65960000001 Value 102154.45960000002\n", + "2017-05-31, Close, 204.60\n", + "rsi: 48.12647914189962\n", + "2017-06-01, Cash 80057.65960000001 Value 103385.65960000001\n", + "2017-06-01, Close, 216.00\n", + "rsi: 61.997585632379646\n", + "2017-06-02, Cash 80057.65960000001 Value 103169.65960000001\n", + "2017-06-02, Close, 214.00\n", + "rsi: 59.01601509100391\n", + "2017-06-05, Cash 80057.65960000001 Value 103385.65960000001\n", + "2017-06-05, Close, 216.00\n", + "rsi: 61.03410120129326\n", + "2017-06-06, Cash 80057.65960000001 Value 103256.05960000001\n", + "2017-06-06, Close, 214.80\n", + "rsi: 59.15205079711999\n", + "2017-06-07, Cash 80057.65960000001 Value 103450.45960000002\n", + "2017-06-07, Close, 216.60\n", + "rsi: 61.090227337777165\n", + "2017-06-08, Cash 80057.65960000001 Value 103364.05960000001\n", + "2017-06-08, Close, 215.80\n", + "rsi: 59.733650807089056\n", + "2017-06-09, Cash 80057.65960000001 Value 103364.05960000001\n", + "2017-06-09, Close, 215.80\n", + "rsi: 59.733650807089056\n", + "2017-06-13, Cash 80057.65960000001 Value 103191.25960000002\n", + "2017-06-13, Close, 214.20\n", + "rsi: 56.80762243064597\n", + "2017-06-14, Cash 80057.65960000001 Value 103320.85960000001\n", + "2017-06-14, Close, 215.40\n", + "rsi: 58.451468327358725\n", + "2017-06-15, Cash 80057.65960000001 Value 103299.25960000002\n", + "2017-06-15, Close, 215.20\n", + "rsi: 58.05489249068077\n", + "2017-06-16, Cash 80057.65960000001 Value 103493.65960000001\n", + "2017-06-16, Close, 217.00\n", + "rsi: 60.642987086679206\n", + "2017-06-19, Cash 80057.65960000001 Value 103385.65960000001\n", + "2017-06-19, Close, 216.00\n", + "rsi: 58.4840094157586\n", + "2017-06-20, Cash 80057.65960000001 Value 103277.65960000001\n", + "2017-06-20, Close, 215.00\n", + "rsi: 56.324526376523245\n", + "2017-06-21, Cash 80057.65960000001 Value 103320.85960000001\n", + "2017-06-21, Close, 215.40\n", + "rsi: 57.008345888550615\n", + "2017-06-22, Cash 80057.65960000001 Value 103040.05960000001\n", + "2017-06-22, Close, 212.80\n", + "rsi: 51.37748560174935\n", + "2017-06-23, Cash 80057.65960000001 Value 102845.65960000001\n", + "2017-06-23, Close, 211.00\n", + "rsi: 47.85350200705799\n", + "2017-06-27, Cash 80057.65960000001 Value 102737.65960000001\n", + "2017-06-27, Close, 210.00\n", + "rsi: 45.967158137948374\n", + "2017-06-28, Cash 80057.65960000001 Value 102586.45960000002\n", + "2017-06-28, Close, 208.60\n", + "rsi: 43.388495939760276\n", + "2017-06-29, Cash 80057.65960000001 Value 102240.85960000001\n", + "2017-06-29, Close, 205.40\n", + "rsi: 38.12405228914134\n", + "2017-06-30, Cash 80057.65960000001 Value 102089.65960000001\n", + "2017-06-30, Close, 204.00\n", + "rsi: 36.06249055980047\n", + "2017-07-03, Cash 80057.65960000001 Value 102327.25960000002\n", + "2017-07-03, Close, 206.20\n", + "rsi: 41.42297371873391\n", + "2017-07-04, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-07-04, Close, 208.00\n", + "rsi: 45.45253098944995\n", + "2017-07-05, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-07-05, Close, 208.00\n", + "rsi: 45.45253098944994\n", + "2017-07-06, Cash 80057.65960000001 Value 102435.25960000002\n", + "2017-07-06, Close, 207.20\n", + "rsi: 43.89605525430096\n", + "2017-07-07, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-07-07, Close, 208.00\n", + "rsi: 45.89147675527785\n", + "2017-07-10, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-07-10, Close, 208.00\n", + "rsi: 45.89147675527785\n", + "2017-07-11, Cash 80057.65960000001 Value 102521.65960000001\n", + "2017-07-11, Close, 208.00\n", + "rsi: 45.89147675527785\n", + "2017-07-12, Cash 80057.65960000001 Value 102953.65960000001\n", + "2017-07-12, Close, 212.00\n", + "rsi: 55.72527281947281\n", + "2017-07-13, Cash 80057.65960000001 Value 103234.45960000002\n", + "2017-07-13, Close, 214.60\n", + "rsi: 60.722176423788056\n", + "2017-07-14, Cash 80057.65960000001 Value 103277.65960000001\n", + "2017-07-14, Close, 215.00\n", + "rsi: 61.443147722288614\n", + "2017-07-17, Cash 80057.65960000001 Value 103299.25960000002\n", + "2017-07-17, Close, 215.20\n", + "rsi: 61.82050732144875\n", + "2017-07-18, Cash 80057.65960000001 Value 103493.65960000001\n", + "2017-07-18, Close, 217.00\n", + "rsi: 65.12841034302386\n", + "2017-07-19, Cash 80057.65960000001 Value 103860.85960000001\n", + "2017-07-19, Close, 220.40\n", + "rsi: 70.35343241885704\n", + "2017-07-19, SELL CREATE, 220.40\n", + "2017-07-20, SELL EXECUTED, Price: 220.40, Cost: 8259.75, Comm 59.51\n", + "2017-07-20, Cash 89916.15160000001 Value 103776.15160000001\n", + "2017-07-20, Close, 220.00\n", + "rsi: 69.04274185823633\n", + "2017-07-21, Cash 89916.15160000001 Value 103889.5516\n", + "2017-07-21, Close, 221.80\n", + "rsi: 71.60625071017758\n", + "2017-07-21, SELL CREATE, 221.80\n", + "2017-07-24, SELL EXECUTED, Price: 221.80, Cost: 8259.75, Comm 59.89\n", + "2017-07-24, Cash 99837.26560000001 Value 103782.86560000002\n", + "2017-07-24, Close, 219.20\n", + "rsi: 63.43502887674214\n", + "2017-07-25, Cash 99837.26560000001 Value 103757.66560000001\n", + "2017-07-25, Close, 217.80\n", + "rsi: 59.49792173667657\n", + "2017-07-26, Cash 99837.26560000001 Value 103739.66560000001\n", + "2017-07-26, Close, 216.80\n", + "rsi: 56.78678143123152\n", + "2017-07-27, Cash 99837.26560000001 Value 103779.26560000001\n", + "2017-07-27, Close, 219.00\n", + "rsi: 60.997445672379264\n", + "2017-07-28, Cash 99837.26560000001 Value 103833.26560000001\n", + "2017-07-28, Close, 222.00\n", + "rsi: 65.87979536759606\n", + "2017-07-31, Cash 99837.26560000001 Value 103887.26560000001\n", + "2017-07-31, Close, 225.00\n", + "rsi: 69.93309936912465\n", + "2017-08-01, Cash 99837.26560000001 Value 103851.26560000001\n", + "2017-08-01, Close, 223.00\n", + "rsi: 64.4373298566407\n", + "2017-08-02, Cash 99837.26560000001 Value 103761.26560000001\n", + "2017-08-02, Close, 218.00\n", + "rsi: 53.184633559888745\n", + "2017-08-03, Cash 99837.26560000001 Value 103725.26560000001\n", + "2017-08-03, Close, 216.00\n", + "rsi: 49.46371258564475\n", + "2017-08-04, Cash 99837.26560000001 Value 103710.86560000002\n", + "2017-08-04, Close, 215.20\n", + "rsi: 48.01660635875893\n", + "2017-08-07, Cash 99837.26560000001 Value 103779.26560000001\n", + "2017-08-07, Close, 219.00\n", + "rsi: 54.783494407788545\n", + "2017-08-08, Cash 99837.26560000001 Value 103779.26560000001\n", + "2017-08-08, Close, 219.00\n", + "rsi: 54.783494407788545\n", + "2017-08-09, Cash 99837.26560000001 Value 103743.26560000001\n", + "2017-08-09, Close, 217.00\n", + "rsi: 50.75090572935674\n", + "2017-08-10, Cash 99837.26560000001 Value 103743.26560000001\n", + "2017-08-10, Close, 217.00\n", + "rsi: 50.75090572935675\n", + "2017-08-11, Cash 99837.26560000001 Value 103732.46560000001\n", + "2017-08-11, Close, 216.40\n", + "rsi: 49.48358660837363\n", + "2017-08-14, Cash 99837.26560000001 Value 103833.26560000001\n", + "2017-08-14, Close, 222.00\n", + "rsi: 59.61898606232501\n", + "2017-08-15, Cash 99837.26560000001 Value 103887.26560000001\n", + "2017-08-15, Close, 225.00\n", + "rsi: 63.80823385274172\n", + "2017-08-16, Cash 99837.26560000001 Value 104139.26560000001\n", + "2017-08-16, Close, 239.00\n", + "rsi: 76.21114876792821\n", + "2017-08-16, SELL CREATE, 239.00\n", + "2017-08-17, SELL EXECUTED, Price: 238.00, Cost: -2170.10, Comm 58.55\n", + "2017-08-17, OPERATION PROFIT, GROSS 4359.60, NET 4095.56\n", + "2017-08-17, Cash 109536.71760000002 Value 104058.11760000001\n", + "2017-08-17, Close, 238.20\n", + "rsi: 74.63710995642552\n", + "2017-08-18, Cash 109536.71760000002 Value 104127.11760000001\n", + "2017-08-18, Close, 235.20\n", + "rsi: 68.89098245905757\n", + "2017-08-22, Cash 109536.71760000002 Value 104016.71760000002\n", + "2017-08-22, Close, 240.00\n", + "rsi: 72.53443892581973\n", + "2017-08-23, Cash 109536.71760000002 Value 104035.11760000001\n", + "2017-08-23, Close, 239.20\n", + "rsi: 71.04105954027011\n", + "2017-08-24, Cash 109536.71760000002 Value 104016.71760000002\n", + "2017-08-24, Close, 240.00\n", + "rsi: 71.6692178991394\n", + "2017-08-25, Cash 109536.71760000002 Value 104039.71760000002\n", + "2017-08-25, Close, 239.00\n", + "rsi: 69.63585869010035\n", + "2017-08-29, Cash 109536.71760000002 Value 104044.31760000002\n", + "2017-08-29, Close, 238.80\n", + "rsi: 69.21291431152072\n", + "2017-08-30, Cash 109536.71760000002 Value 104044.31760000002\n", + "2017-08-30, Close, 238.80\n", + "rsi: 69.21291431152072\n", + "2017-08-31, Cash 109536.71760000002 Value 104058.11760000001\n", + "2017-08-31, Close, 238.20\n", + "rsi: 67.78057409447446\n", + "2017-09-04, Cash 109536.71760000002 Value 104062.71760000002\n", + "2017-09-04, Close, 238.00\n", + "rsi: 67.28075443848905\n", + "2017-09-05, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-09-05, Close, 244.00\n", + "rsi: 73.57599896503143\n", + "2017-09-06, Cash 109536.71760000002 Value 103993.71760000002\n", + "2017-09-06, Close, 241.00\n", + "rsi: 66.66902074192276\n", + "2017-09-07, Cash 109536.71760000002 Value 103887.91760000002\n", + "2017-09-07, Close, 245.60\n", + "rsi: 71.14237921487897\n", + "2017-09-08, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-09-08, Close, 244.00\n", + "rsi: 67.73705270730707\n", + "2017-09-11, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-09-11, Close, 244.00\n", + "rsi: 67.73705270730707\n", + "2017-09-13, Cash 109536.71760000002 Value 103970.71760000002\n", + "2017-09-13, Close, 242.00\n", + "rsi: 63.34164569919797\n", + "2017-09-14, Cash 109536.71760000002 Value 103901.71760000002\n", + "2017-09-14, Close, 245.00\n", + "rsi: 66.81964703257506\n", + "2017-09-15, Cash 109536.71760000002 Value 103947.71760000002\n", + "2017-09-15, Close, 243.00\n", + "rsi: 62.5584080381011\n", + "2017-09-18, Cash 109536.71760000002 Value 103901.71760000002\n", + "2017-09-18, Close, 245.00\n", + "rsi: 64.96456478418617\n", + "2017-09-19, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-09-19, Close, 244.00\n", + "rsi: 62.791729803223575\n", + "2017-09-20, Cash 109536.71760000002 Value 103970.71760000002\n", + "2017-09-20, Close, 242.00\n", + "rsi: 58.5722691670441\n", + "2017-09-21, Cash 109536.71760000002 Value 103878.71760000002\n", + "2017-09-21, Close, 246.00\n", + "rsi: 63.81015359153102\n", + "2017-09-22, Cash 109536.71760000002 Value 103906.31760000002\n", + "2017-09-22, Close, 244.80\n", + "rsi: 61.30592952362505\n", + "2017-09-25, Cash 109536.71760000002 Value 103901.71760000002\n", + "2017-09-25, Close, 245.00\n", + "rsi: 61.57658250655025\n", + "2017-09-26, Cash 109536.71760000002 Value 103791.31760000002\n", + "2017-09-26, Close, 249.80\n", + "rsi: 67.45945169063533\n", + "2017-09-27, Cash 109536.71760000002 Value 103814.31760000002\n", + "2017-09-27, Close, 248.80\n", + "rsi: 65.21912369132791\n", + "2017-09-28, Cash 109536.71760000002 Value 103970.71760000002\n", + "2017-09-28, Close, 242.00\n", + "rsi: 52.46071284063039\n", + "2017-09-29, Cash 109536.71760000002 Value 103929.31760000002\n", + "2017-09-29, Close, 243.80\n", + "rsi: 54.971760016322854\n", + "2017-10-02, Cash 109536.71760000002 Value 103956.91760000002\n", + "2017-10-02, Close, 242.60\n", + "rsi: 52.9632666818234\n", + "2017-10-03, Cash 109536.71760000002 Value 103970.71760000002\n", + "2017-10-03, Close, 242.00\n", + "rsi: 51.941388802177194\n", + "2017-10-04, Cash 109536.71760000002 Value 103961.51760000002\n", + "2017-10-04, Close, 242.40\n", + "rsi: 52.598009006838964\n", + "2017-10-05, Cash 109536.71760000002 Value 103975.31760000002\n", + "2017-10-05, Close, 241.80\n", + "rsi: 51.46219486131442\n", + "2017-10-06, Cash 109536.71760000002 Value 103966.11760000001\n", + "2017-10-06, Close, 242.20\n", + "rsi: 52.20321511192611\n", + "2017-10-09, Cash 109536.71760000002 Value 103883.31760000002\n", + "2017-10-09, Close, 245.80\n", + "rsi: 58.36412468976486\n", + "2017-10-10, Cash 109536.71760000002 Value 103901.71760000002\n", + "2017-10-10, Close, 245.00\n", + "rsi: 56.617619324049436\n", + "2017-10-11, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-10-11, Close, 244.00\n", + "rsi: 54.4252239901779\n", + "2017-10-12, Cash 109536.71760000002 Value 103910.91760000002\n", + "2017-10-12, Close, 244.60\n", + "rsi: 55.53771116852619\n", + "2017-10-13, Cash 109536.71760000002 Value 103855.71760000002\n", + "2017-10-13, Close, 247.00\n", + "rsi: 59.768147617258734\n", + "2017-10-17, Cash 109536.71760000002 Value 103901.71760000002\n", + "2017-10-17, Close, 245.00\n", + "rsi: 55.06615891974155\n", + "2017-10-18, Cash 109536.71760000002 Value 103878.71760000002\n", + "2017-10-18, Close, 246.00\n", + "rsi: 56.89224755119221\n", + "2017-10-19, Cash 109536.71760000002 Value 103855.71760000002\n", + "2017-10-19, Close, 247.00\n", + "rsi: 58.69977702418459\n", + "2017-10-20, Cash 109536.71760000002 Value 103878.71760000002\n", + "2017-10-20, Close, 246.00\n", + "rsi: 56.16365551399846\n", + "2017-10-23, Cash 109536.71760000002 Value 103809.71760000002\n", + "2017-10-23, Close, 249.00\n", + "rsi: 61.53307153095165\n", + "2017-10-24, Cash 109536.71760000002 Value 103832.71760000002\n", + "2017-10-24, Close, 248.00\n", + "rsi: 58.94141920332376\n", + "2017-10-25, Cash 109536.71760000002 Value 103786.71760000002\n", + "2017-10-25, Close, 250.00\n", + "rsi: 62.35629697420406\n", + "2017-10-26, Cash 109536.71760000002 Value 103786.71760000002\n", + "2017-10-26, Close, 250.00\n", + "rsi: 62.35629697420406\n", + "2017-10-27, Cash 109536.71760000002 Value 103791.31760000002\n", + "2017-10-27, Close, 249.80\n", + "rsi: 61.76056371384747\n", + "2017-10-30, Cash 109536.71760000002 Value 103809.71760000002\n", + "2017-10-30, Close, 249.00\n", + "rsi: 59.31931334990957\n", + "2017-11-02, Cash 109536.71760000002 Value 103754.51760000002\n", + "2017-11-02, Close, 251.40\n", + "rsi: 63.92611886164371\n", + "2017-11-03, Cash 109536.71760000002 Value 103828.11760000001\n", + "2017-11-03, Close, 248.20\n", + "rsi: 54.98522340364124\n", + "2017-11-06, Cash 109536.71760000002 Value 103763.71760000002\n", + "2017-11-06, Close, 251.00\n", + "rsi: 60.22705607338392\n", + "2017-11-07, Cash 109536.71760000002 Value 103708.51760000002\n", + "2017-11-07, Close, 253.40\n", + "rsi: 64.08729403773462\n", + "2017-11-08, Cash 109536.71760000002 Value 103740.71760000002\n", + "2017-11-08, Close, 252.00\n", + "rsi: 60.404342706357795\n", + "2017-11-09, Cash 109536.71760000002 Value 103717.71760000002\n", + "2017-11-09, Close, 253.00\n", + "rsi: 62.080605430524926\n", + "2017-11-10, Cash 109536.71760000002 Value 103759.11760000001\n", + "2017-11-10, Close, 251.20\n", + "rsi: 57.3724066824616\n", + "2017-11-13, Cash 109536.71760000002 Value 103625.71760000002\n", + "2017-11-13, Close, 257.00\n", + "rsi: 66.25352135600667\n", + "2017-11-14, Cash 109536.71760000002 Value 103565.91760000002\n", + "2017-11-14, Close, 259.60\n", + "rsi: 69.33751871750701\n", + "2017-11-15, Cash 109536.71760000002 Value 103653.31760000002\n", + "2017-11-15, Close, 255.80\n", + "rsi: 60.61818330221522\n", + "2017-11-16, Cash 109536.71760000002 Value 103584.31760000002\n", + "2017-11-16, Close, 258.80\n", + "rsi: 64.42199509423892\n", + "2017-11-17, Cash 109536.71760000002 Value 103561.31760000002\n", + "2017-11-17, Close, 259.80\n", + "rsi: 65.61423961485895\n", + "2017-11-20, Cash 109536.71760000002 Value 103625.71760000002\n", + "2017-11-20, Close, 257.00\n", + "rsi: 59.592549213027745\n", + "2017-11-21, Cash 109536.71760000002 Value 103694.71760000002\n", + "2017-11-21, Close, 254.00\n", + "rsi: 53.886349197642396\n", + "2017-11-22, Cash 109536.71760000002 Value 103671.71760000002\n", + "2017-11-22, Close, 255.00\n", + "rsi: 55.418744290002664\n", + "2017-11-23, Cash 109536.71760000002 Value 103694.71760000002\n", + "2017-11-23, Close, 254.00\n", + "rsi: 53.50399405093613\n", + "2017-11-24, Cash 109536.71760000002 Value 103593.51760000002\n", + "2017-11-24, Close, 258.40\n", + "rsi: 60.04525111421275\n", + "2017-11-27, Cash 109536.71760000002 Value 103694.71760000002\n", + "2017-11-27, Close, 254.00\n", + "rsi: 52.14496796464175\n", + "2017-11-28, Cash 109536.71760000002 Value 103740.71760000002\n", + "2017-11-28, Close, 252.00\n", + "rsi: 48.9897373642993\n", + "2017-11-29, Cash 109536.71760000002 Value 103933.91760000002\n", + "2017-11-29, Close, 243.60\n", + "rsi: 38.46296115513916\n", + "2017-12-01, Cash 109536.71760000002 Value 103892.51760000002\n", + "2017-12-01, Close, 245.40\n", + "rsi: 41.37023751130815\n", + "2017-12-04, Cash 109536.71760000002 Value 103984.51760000002\n", + "2017-12-04, Close, 241.40\n", + "rsi: 37.16790881655399\n", + "2017-12-05, Cash 109536.71760000002 Value 103929.31760000002\n", + "2017-12-05, Close, 243.80\n", + "rsi: 41.03790757306808\n", + "2017-12-06, Cash 109536.71760000002 Value 103947.71760000002\n", + "2017-12-06, Close, 243.00\n", + "rsi: 40.150178945726125\n", + "2017-12-07, Cash 109536.71760000002 Value 103860.31760000002\n", + "2017-12-07, Close, 246.80\n", + "rsi: 46.113068474738384\n", + "2017-12-08, Cash 109536.71760000002 Value 103814.31760000002\n", + "2017-12-08, Close, 248.80\n", + "rsi: 48.993455791481104\n", + "2017-12-11, Cash 109536.71760000002 Value 103809.71760000002\n", + "2017-12-11, Close, 249.00\n", + "rsi: 49.28539014764926\n", + "2017-12-12, Cash 109536.71760000002 Value 103800.51760000002\n", + "2017-12-12, Close, 249.40\n", + "rsi: 49.902959951774484\n", + "2017-12-13, Cash 109536.71760000002 Value 103855.71760000002\n", + "2017-12-13, Close, 247.00\n", + "rsi: 46.26279731810389\n", + "2017-12-14, Cash 109536.71760000002 Value 103924.71760000002\n", + "2017-12-14, Close, 244.00\n", + "rsi: 42.12621546653837\n", + "2017-12-15, Cash 109536.71760000002 Value 103878.71760000002\n", + "2017-12-15, Close, 246.00\n", + "rsi: 45.617326876353715\n", + "2017-12-18, Cash 109536.71760000002 Value 103800.51760000002\n", + "2017-12-18, Close, 249.40\n", + "rsi: 51.0258908941554\n", + "2017-12-19, Cash 109536.71760000002 Value 103910.91760000002\n", + "2017-12-19, Close, 244.60\n", + "rsi: 44.32386568130932\n", + "2017-12-20, Cash 109536.71760000002 Value 103929.31760000002\n", + "2017-12-20, Close, 243.80\n", + "rsi: 43.30300396159515\n", + "2017-12-21, Cash 109536.71760000002 Value 103837.31760000002\n", + "2017-12-21, Close, 247.80\n", + "rsi: 49.55863091556102\n", + "2017-12-22, Cash 109536.71760000002 Value 103855.71760000002\n", + "2017-12-22, Close, 247.00\n", + "rsi: 48.40824175560919\n", + "2017-12-27, Cash 109536.71760000002 Value 103814.31760000002\n", + "2017-12-27, Close, 248.80\n", + "rsi: 51.155553091823805\n", + "2017-12-28, Cash 109536.71760000002 Value 103694.71760000002\n", + "2017-12-28, Close, 254.00\n", + "rsi: 58.09752355979591\n", + "2017-12-29, Cash 109536.71760000002 Value 103717.71760000002\n", + "2017-12-29, Close, 253.00\n", + "rsi: 56.436376702285465\n", + "2018-01-03, Cash 109536.71760000002 Value 103662.51760000002\n", + "2018-01-03, Close, 255.40\n", + "rsi: 59.43420223700169\n", + "2018-01-04, Cash 109536.71760000002 Value 103671.71760000002\n", + "2018-01-04, Close, 255.00\n", + "rsi: 58.7090637631206\n", + "2018-01-05, Cash 109536.71760000002 Value 103671.71760000002\n", + "2018-01-05, Close, 255.00\n", + "rsi: 58.7090637631206\n", + "2018-01-08, Cash 109536.71760000002 Value 103648.71760000002\n", + "2018-01-08, Close, 256.00\n", + "rsi: 60.119816915414454\n", + "2018-01-09, Cash 109536.71760000002 Value 103653.31760000002\n", + "2018-01-09, Close, 255.80\n", + "rsi: 59.680635035091285\n", + "2018-01-10, Cash 109536.71760000002 Value 103662.51760000002\n", + "2018-01-10, Close, 255.40\n", + "rsi: 58.756160711541895\n", + "2018-01-11, Cash 109536.71760000002 Value 103671.71760000002\n", + "2018-01-11, Close, 255.00\n", + "rsi: 57.79207774498611\n", + "2018-01-12, Cash 109536.71760000002 Value 103671.71760000002\n", + "2018-01-12, Close, 255.00\n", + "rsi: 57.79207774498611\n", + "2018-01-15, Cash 109536.71760000002 Value 103469.31760000002\n", + "2018-01-15, Close, 263.80\n", + "rsi: 70.24786502842278\n", + "2018-01-16, Cash 109536.71760000002 Value 103151.91760000002\n", + "2018-01-16, Close, 277.60\n", + "rsi: 80.14376369053414\n", + "2018-01-17, Cash 109536.71760000002 Value 103151.91760000002\n", + "2018-01-17, Close, 277.60\n", + "rsi: 80.14376369053414\n", + "2018-01-18, Cash 109536.71760000002 Value 103119.71760000002\n", + "2018-01-18, Close, 279.00\n", + "rsi: 80.89155558452251\n", + "2018-01-19, Cash 109536.71760000002 Value 103096.71760000002\n", + "2018-01-19, Close, 280.00\n", + "rsi: 81.42953209611639\n", + "2018-01-22, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-01-22, Close, 283.00\n", + "rsi: 82.97784410702943\n", + "2018-01-23, Cash 109536.71760000002 Value 103046.11760000001\n", + "2018-01-23, Close, 282.20\n", + "rsi: 81.0375160104461\n", + "2018-01-24, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-01-24, Close, 282.00\n", + "rsi: 80.53052733288567\n", + "2018-01-25, Cash 109536.71760000002 Value 102797.71760000002\n", + "2018-01-25, Close, 293.00\n", + "rsi: 85.79452132930899\n", + "2018-01-26, Cash 109536.71760000002 Value 102816.11760000001\n", + "2018-01-26, Close, 292.20\n", + "rsi: 84.01541398115566\n", + "2018-01-29, Cash 109536.71760000002 Value 102972.51760000002\n", + "2018-01-29, Close, 285.40\n", + "rsi: 70.61175907850557\n", + "2018-01-30, Cash 109536.71760000002 Value 103000.11760000001\n", + "2018-01-30, Close, 284.20\n", + "rsi: 68.53385059478407\n", + "2018-01-31, Cash 109536.71760000002 Value 102986.31760000002\n", + "2018-01-31, Close, 284.80\n", + "rsi: 69.02466809785527\n", + "2018-02-01, Cash 109536.71760000002 Value 102931.11760000001\n", + "2018-02-01, Close, 287.20\n", + "rsi: 70.97493612169116\n", + "2018-02-02, Cash 109536.71760000002 Value 102774.71760000002\n", + "2018-02-02, Close, 294.00\n", + "rsi: 75.65245783905812\n", + "2018-02-05, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-02-05, Close, 282.00\n", + "rsi: 57.915020961314376\n", + "2018-02-06, Cash 109536.71760000002 Value 102889.71760000002\n", + "2018-02-06, Close, 289.00\n", + "rsi: 63.317880959310216\n", + "2018-02-07, Cash 109536.71760000002 Value 102793.11760000001\n", + "2018-02-07, Close, 293.20\n", + "rsi: 66.1276932403373\n", + "2018-02-08, Cash 109536.71760000002 Value 102802.31760000002\n", + "2018-02-08, Close, 292.80\n", + "rsi: 65.61222367144528\n", + "2018-02-09, Cash 109536.71760000002 Value 102820.71760000002\n", + "2018-02-09, Close, 292.00\n", + "rsi: 64.52882550123041\n", + "2018-02-12, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-02-12, Close, 283.00\n", + "rsi: 53.771739663191724\n", + "2018-02-13, Cash 109536.71760000002 Value 103165.71760000002\n", + "2018-02-13, Close, 277.00\n", + "rsi: 48.02405272593965\n", + "2018-02-14, Cash 109536.71760000002 Value 103142.71760000002\n", + "2018-02-14, Close, 278.00\n", + "rsi: 49.00246443246204\n", + "2018-02-15, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-02-15, Close, 285.00\n", + "rsi: 55.34000331677107\n", + "2018-02-19, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-02-19, Close, 285.00\n", + "rsi: 55.34000331677107\n", + "2018-02-20, Cash 109536.71760000002 Value 102958.71760000002\n", + "2018-02-20, Close, 286.00\n", + "rsi: 56.24097351483955\n", + "2018-02-21, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-02-21, Close, 282.00\n", + "rsi: 51.74422785026382\n", + "2018-02-22, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-02-22, Close, 282.00\n", + "rsi: 51.74422785026382\n", + "2018-02-23, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-02-23, Close, 282.00\n", + "rsi: 51.74422785026382\n", + "2018-02-26, Cash 109536.71760000002 Value 102820.71760000002\n", + "2018-02-26, Close, 292.00\n", + "rsi: 61.384711771252896\n", + "2018-02-27, Cash 109536.71760000002 Value 102751.71760000002\n", + "2018-02-27, Close, 295.00\n", + "rsi: 63.725980100489785\n", + "2018-02-28, Cash 109536.71760000002 Value 102673.51760000002\n", + "2018-02-28, Close, 298.40\n", + "rsi: 66.22532094259105\n", + "2018-03-01, Cash 109536.71760000002 Value 102691.91760000002\n", + "2018-03-01, Close, 297.60\n", + "rsi: 65.08891734404287\n", + "2018-03-02, Cash 109536.71760000002 Value 102682.71760000002\n", + "2018-03-02, Close, 298.00\n", + "rsi: 65.40853602793301\n", + "2018-03-05, Cash 109536.71760000002 Value 102645.91760000002\n", + "2018-03-05, Close, 299.60\n", + "rsi: 66.72098951418428\n", + "2018-03-06, Cash 109536.71760000002 Value 102668.91760000002\n", + "2018-03-06, Close, 298.60\n", + "rsi: 65.05952687561214\n", + "2018-03-07, Cash 109536.71760000002 Value 102544.71760000002\n", + "2018-03-07, Close, 304.00\n", + "rsi: 69.47930940240653\n", + "2018-03-08, Cash 109536.71760000002 Value 102751.71760000002\n", + "2018-03-08, Close, 295.00\n", + "rsi: 56.623431545859276\n", + "2018-03-09, Cash 109536.71760000002 Value 102820.71760000002\n", + "2018-03-09, Close, 292.00\n", + "rsi: 53.09666344257336\n", + "2018-03-12, Cash 109536.71760000002 Value 102742.51760000002\n", + "2018-03-12, Close, 295.40\n", + "rsi: 56.41031469103243\n", + "2018-03-13, Cash 109536.71760000002 Value 102797.71760000002\n", + "2018-03-13, Close, 293.00\n", + "rsi: 53.535172833788785\n", + "2018-03-14, Cash 109536.71760000002 Value 102903.51760000002\n", + "2018-03-14, Close, 288.40\n", + "rsi: 48.439179977138906\n", + "2018-03-15, Cash 109536.71760000002 Value 103004.71760000002\n", + "2018-03-15, Close, 284.00\n", + "rsi: 44.11362463305306\n", + "2018-03-16, Cash 109536.71760000002 Value 102512.51760000002\n", + "2018-03-16, Close, 305.40\n", + "rsi: 61.92313710773574\n", + "2018-03-19, Cash 109536.71760000002 Value 102682.71760000002\n", + "2018-03-19, Close, 298.00\n", + "rsi: 55.354143318548466\n", + "2018-03-20, Cash 109536.71760000002 Value 102958.71760000002\n", + "2018-03-20, Close, 286.00\n", + "rsi: 46.7021363890527\n", + "2018-03-21, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-03-21, Close, 285.00\n", + "rsi: 46.05609950055438\n", + "2018-03-22, Cash 109536.71760000002 Value 102940.31760000002\n", + "2018-03-22, Close, 286.80\n", + "rsi: 47.46482994333422\n", + "2018-03-23, Cash 109536.71760000002 Value 102912.71760000002\n", + "2018-03-23, Close, 288.00\n", + "rsi: 48.431686194566105\n", + "2018-03-26, Cash 109536.71760000002 Value 102751.71760000002\n", + "2018-03-26, Close, 295.00\n", + "rsi: 53.77587665888385\n", + "2018-03-27, Cash 109536.71760000002 Value 102765.51760000002\n", + "2018-03-27, Close, 294.40\n", + "rsi: 53.26632336677145\n", + "2018-03-28, Cash 109536.71760000002 Value 102659.71760000002\n", + "2018-03-28, Close, 299.00\n", + "rsi: 56.65718806461459\n", + "2018-04-02, Cash 109536.71760000002 Value 102636.71760000002\n", + "2018-04-02, Close, 300.00\n", + "rsi: 57.38113911266331\n", + "2018-04-03, Cash 109536.71760000002 Value 102719.51760000002\n", + "2018-04-03, Close, 296.40\n", + "rsi: 53.89135617769286\n", + "2018-04-04, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-04-04, Close, 285.00\n", + "rsi: 44.63408617716165\n", + "2018-04-05, Cash 109536.71760000002 Value 103096.71760000002\n", + "2018-04-05, Close, 280.00\n", + "rsi: 41.28443202891203\n", + "2018-04-06, Cash 109536.71760000002 Value 103142.71760000002\n", + "2018-04-06, Close, 278.00\n", + "rsi: 39.99158652591464\n", + "2018-04-10, Cash 109536.71760000002 Value 103004.71760000002\n", + "2018-04-10, Close, 284.00\n", + "rsi: 45.50502705456337\n", + "2018-04-11, Cash 109536.71760000002 Value 102875.91760000002\n", + "2018-04-11, Close, 289.60\n", + "rsi: 50.112120819369615\n", + "2018-04-12, Cash 109536.71760000002 Value 102636.71760000002\n", + "2018-04-12, Close, 300.00\n", + "rsi: 57.327351263428014\n", + "2018-04-13, Cash 109536.71760000002 Value 102816.11760000001\n", + "2018-04-13, Close, 292.20\n", + "rsi: 51.3310770112194\n", + "2018-04-16, Cash 109536.71760000002 Value 102829.91760000002\n", + "2018-04-16, Close, 291.60\n", + "rsi: 50.89012184662092\n", + "2018-04-17, Cash 109536.71760000002 Value 102898.91760000002\n", + "2018-04-17, Close, 288.60\n", + "rsi: 48.640216518475484\n", + "2018-04-18, Cash 109536.71760000002 Value 102770.11760000001\n", + "2018-04-18, Close, 294.20\n", + "rsi: 52.83227328266032\n", + "2018-04-19, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-04-19, Close, 285.00\n", + "rsi: 46.16562995716203\n", + "2018-04-20, Cash 109536.71760000002 Value 102843.71760000002\n", + "2018-04-20, Close, 291.00\n", + "rsi: 50.54828590459059\n", + "2018-04-23, Cash 109536.71760000002 Value 102774.71760000002\n", + "2018-04-23, Close, 294.00\n", + "rsi: 52.62502264459953\n", + "2018-04-24, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-04-24, Close, 285.00\n", + "rsi: 46.33802173121848\n", + "2018-04-25, Cash 109536.71760000002 Value 103059.91760000002\n", + "2018-04-25, Close, 281.60\n", + "rsi: 44.19019974688824\n", + "2018-04-26, Cash 109536.71760000002 Value 103096.71760000002\n", + "2018-04-26, Close, 280.00\n", + "rsi: 43.17598756321758\n", + "2018-04-27, Cash 109536.71760000002 Value 103050.71760000002\n", + "2018-04-27, Close, 282.00\n", + "rsi: 44.87898791717722\n", + "2018-04-30, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-04-30, Close, 285.00\n", + "rsi: 47.42431569973589\n", + "2018-05-02, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-05-02, Close, 283.00\n", + "rsi: 45.90251954186336\n", + "2018-05-03, Cash 109536.71760000002 Value 103211.71760000002\n", + "2018-05-03, Close, 275.00\n", + "rsi: 40.32800758788531\n", + "2018-05-04, Cash 109536.71760000002 Value 103202.51760000002\n", + "2018-05-04, Close, 275.40\n", + "rsi: 40.71567996540034\n", + "2018-05-07, Cash 109536.71760000002 Value 103119.71760000002\n", + "2018-05-07, Close, 279.00\n", + "rsi: 44.227571293158356\n", + "2018-05-08, Cash 109536.71760000002 Value 103142.71760000002\n", + "2018-05-08, Close, 278.00\n", + "rsi: 43.45747000955855\n", + "2018-05-09, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-05-09, Close, 283.00\n", + "rsi: 48.30436201411184\n", + "2018-05-10, Cash 109536.71760000002 Value 103101.31760000002\n", + "2018-05-10, Close, 279.80\n", + "rsi: 45.609666730058194\n", + "2018-05-11, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-05-11, Close, 285.00\n", + "rsi: 50.4472567803535\n", + "2018-05-15, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-05-15, Close, 283.00\n", + "rsi: 48.6548172091227\n", + "2018-05-16, Cash 109536.71760000002 Value 102944.91760000002\n", + "2018-05-16, Close, 286.60\n", + "rsi: 51.963360163174876\n", + "2018-05-17, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-05-17, Close, 285.00\n", + "rsi: 50.408667823915955\n", + "2018-05-18, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-05-18, Close, 285.00\n", + "rsi: 50.408667823915955\n", + "2018-05-21, Cash 109536.71760000002 Value 103096.71760000002\n", + "2018-05-21, Close, 280.00\n", + "rsi: 45.47736253074894\n", + "2018-05-22, Cash 109536.71760000002 Value 103004.71760000002\n", + "2018-05-22, Close, 284.00\n", + "rsi: 49.71541393195231\n", + "2018-05-23, Cash 109536.71760000002 Value 102935.71760000002\n", + "2018-05-23, Close, 287.00\n", + "rsi: 52.68588953525804\n", + "2018-05-24, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-05-24, Close, 285.00\n", + "rsi: 50.54230990687597\n", + "2018-05-25, Cash 109536.71760000002 Value 103069.11760000001\n", + "2018-05-25, Close, 281.20\n", + "rsi: 46.65803439106125\n", + "2018-05-28, Cash 109536.71760000002 Value 103087.51760000002\n", + "2018-05-28, Close, 280.40\n", + "rsi: 45.858990736040276\n", + "2018-05-29, Cash 109536.71760000002 Value 103027.71760000002\n", + "2018-05-29, Close, 283.00\n", + "rsi: 48.9206541166733\n", + "2018-05-30, Cash 109536.71760000002 Value 103096.71760000002\n", + "2018-05-30, Close, 280.00\n", + "rsi: 45.70874685381946\n", + "2018-05-31, Cash 109536.71760000002 Value 103234.71760000002\n", + "2018-05-31, Close, 274.00\n", + "rsi: 40.045801035743644\n", + "2018-06-01, Cash 109536.71760000002 Value 103009.31760000002\n", + "2018-06-01, Close, 283.80\n", + "rsi: 50.7733982016934\n", + "2018-06-04, Cash 109536.71760000002 Value 103087.51760000002\n", + "2018-06-04, Close, 280.40\n", + "rsi: 47.59175072941715\n", + "2018-06-05, Cash 109536.71760000002 Value 103092.11760000001\n", + "2018-06-05, Close, 280.20\n", + "rsi: 47.403575398592835\n", + "2018-06-06, Cash 109536.71760000002 Value 103078.31760000002\n", + "2018-06-06, Close, 280.80\n", + "rsi: 48.066983082860986\n", + "2018-06-07, Cash 109536.71760000002 Value 103036.91760000002\n", + "2018-06-07, Close, 282.60\n", + "rsi: 50.1004038013279\n", + "2018-06-08, Cash 109536.71760000002 Value 103004.71760000002\n", + "2018-06-08, Close, 284.00\n", + "rsi: 51.684955062537036\n", + "2018-06-11, Cash 109536.71760000002 Value 102981.71760000002\n", + "2018-06-11, Close, 285.00\n", + "rsi: 52.83699459469386\n", + "2018-06-13, Cash 109536.71760000002 Value 103119.71760000002\n", + "2018-06-13, Close, 279.00\n", + "rsi: 45.78313999831389\n", + "2018-06-14, Cash 109536.71760000002 Value 103115.11760000001\n", + "2018-06-14, Close, 279.20\n", + "rsi: 46.041728881855356\n", + "2018-06-18, Cash 109536.71760000002 Value 103161.11760000001\n", + "2018-06-18, Close, 277.20\n", + "rsi: 43.79237063891983\n", + "2018-06-19, Cash 109536.71760000002 Value 103004.71760000002\n", + "2018-06-19, Close, 284.00\n", + "rsi: 52.32130822771678\n", + "2018-06-20, Cash 109536.71760000002 Value 103119.71760000002\n", + "2018-06-20, Close, 279.00\n", + "rsi: 46.70894810997121\n", + "2018-06-21, Cash 109536.71760000002 Value 103326.71760000002\n", + "2018-06-21, Close, 270.00\n", + "rsi: 38.66848167045609\n", + "2018-06-22, Cash 109536.71760000002 Value 103395.71760000002\n", + "2018-06-22, Close, 267.00\n", + "rsi: 36.418072244288744\n", + "2018-06-25, Cash 109536.71760000002 Value 103363.51760000002\n", + "2018-06-25, Close, 268.40\n", + "rsi: 38.22487003420585\n", + "2018-06-26, Cash 109536.71760000002 Value 103312.91760000002\n", + "2018-06-26, Close, 270.60\n", + "rsi: 41.05932955720323\n", + "2018-06-27, Cash 109536.71760000002 Value 103303.71760000002\n", + "2018-06-27, Close, 271.00\n", + "rsi: 41.58414825463603\n", + "2018-06-28, Cash 109536.71760000002 Value 103565.91760000002\n", + "2018-06-28, Close, 259.60\n", + "rsi: 32.65881899223045\n", + "2018-06-29, Cash 109536.71760000002 Value 103487.71760000002\n", + "2018-06-29, Close, 263.00\n", + "rsi: 37.00175692747658\n", + "2018-07-02, Cash 109536.71760000002 Value 103556.71760000002\n", + "2018-07-02, Close, 260.00\n", + "rsi: 34.86516473582313\n", + "2018-07-03, Cash 109536.71760000002 Value 103556.71760000002\n", + "2018-07-03, Close, 260.00\n", + "rsi: 34.86516473582313\n", + "2018-07-04, Cash 109536.71760000002 Value 103561.31760000002\n", + "2018-07-04, Close, 259.80\n", + "rsi: 34.710199419339716\n", + "2018-07-05, Cash 109536.71760000002 Value 103694.71760000002\n", + "2018-07-05, Close, 254.00\n", + "rsi: 30.479319206268116\n", + "2018-07-06, Cash 109536.71760000002 Value 103763.71760000002\n", + "2018-07-06, Close, 251.00\n", + "rsi: 28.541436894122967\n", + "2018-07-06, BUY CREATE, 251.00\n", + "2018-07-09, BUY EXECUTED, Price: 251.80, Cost: -1445.20, Comm 58.92\n", + "2018-07-09, OPERATION PROFIT, GROSS -317.40, NET -384.99\n", + "2018-07-09, Cash 99657.59640000002 Value 103577.59640000002\n", + "2018-07-09, Close, 245.00\n", + "rsi: 25.103686655203006\n", + "2018-07-09, BUY CREATE, 245.00\n", + "2018-07-10, BUY EXECUTED, Price: 245.20, Cost: 9808.00, Comm 58.85\n", + "2018-07-10, Cash 89790.74840000003 Value 103566.74840000003\n", + "2018-07-10, Close, 246.00\n", + "rsi: 26.68859253921734\n", + "2018-07-10, BUY CREATE, 246.00\n", + "2018-07-11, BUY EXECUTED, Price: 246.00, Cost: 9840.00, Comm 59.04\n", + "2018-07-11, Cash 79891.70840000003 Value 103622.90840000003\n", + "2018-07-11, Close, 247.20\n", + "rsi: 28.640069309536642\n", + "2018-07-11, BUY CREATE, 247.20\n", + "2018-07-12, BUY EXECUTED, Price: 249.00, Cost: 9960.00, Comm 59.76\n", + "2018-07-12, Cash 69871.94840000004 Value 103844.74840000004\n", + "2018-07-12, Close, 249.80\n", + "rsi: 32.813114822492636\n", + "2018-07-13, Cash 69871.94840000004 Value 104116.74840000004\n", + "2018-07-13, Close, 251.80\n", + "rsi: 35.91752643893038\n", + "2018-07-16, Cash 69871.94840000004 Value 103708.74840000004\n", + "2018-07-16, Close, 248.80\n", + "rsi: 33.42285005674621\n", + "2018-07-17, Cash 69871.94840000004 Value 104225.54840000003\n", + "2018-07-17, Close, 252.60\n", + "rsi: 39.18476944652042\n", + "2018-07-18, Cash 69871.94840000004 Value 104443.14840000003\n", + "2018-07-18, Close, 254.20\n", + "rsi: 41.48122616867642\n", + "2018-07-19, Cash 69871.94840000004 Value 104279.94840000004\n", + "2018-07-19, Close, 253.00\n", + "rsi: 40.25351648815034\n", + "2018-07-20, Cash 69871.94840000004 Value 103871.94840000004\n", + "2018-07-20, Close, 250.00\n", + "rsi: 37.28269798831053\n", + "2018-07-23, Cash 69871.94840000004 Value 103871.94840000004\n", + "2018-07-23, Close, 250.00\n", + "rsi: 37.28269798831053\n", + "2018-07-24, Cash 69871.94840000004 Value 104007.94840000004\n", + "2018-07-24, Close, 251.00\n", + "rsi: 39.022461799952026\n", + "2018-07-25, Cash 69871.94840000004 Value 104035.14840000003\n", + "2018-07-25, Close, 251.20\n", + "rsi: 39.384621752066806\n", + "2018-07-26, Cash 69871.94840000004 Value 104715.14840000003\n", + "2018-07-26, Close, 256.20\n", + "rsi: 47.74097070944802\n", + "2018-07-27, Cash 69871.94840000004 Value 106047.94840000004\n", + "2018-07-27, Close, 266.00\n", + "rsi: 59.52011565251278\n", + "2018-07-30, Cash 69871.94840000004 Value 106047.94840000004\n", + "2018-07-30, Close, 266.00\n", + "rsi: 59.52011565251278\n", + "2018-07-31, Cash 69871.94840000004 Value 106591.94840000004\n", + "2018-07-31, Close, 270.00\n", + "rsi: 63.422822249799715\n", + "2018-08-01, Cash 69871.94840000004 Value 107870.34840000003\n", + "2018-08-01, Close, 279.40\n", + "rsi: 70.59698268877074\n", + "2018-08-01, SELL CREATE, 279.40\n", + "2018-08-02, SELL EXECUTED, Price: 279.00, Cost: 8656.53, Comm 58.59\n", + "2018-08-02, Cash 79578.35840000004 Value 107454.35840000004\n", + "2018-08-02, Close, 276.00\n", + "rsi: 65.58616206101146\n", + "2018-08-03, Cash 79578.35840000004 Value 107555.35840000004\n", + "2018-08-03, Close, 277.00\n", + "rsi: 66.3428312725369\n", + "2018-08-06, Cash 79578.35840000004 Value 107858.35840000004\n", + "2018-08-06, Close, 280.00\n", + "rsi: 68.57513033625455\n", + "2018-08-07, Cash 79578.35840000004 Value 106848.35840000004\n", + "2018-08-07, Close, 270.00\n", + "rsi: 55.38791144444376\n", + "2018-08-08, Cash 79578.35840000004 Value 107535.15840000004\n", + "2018-08-08, Close, 276.80\n", + "rsi: 60.89489328915229\n", + "2018-08-09, Cash 79578.35840000004 Value 106747.35840000004\n", + "2018-08-09, Close, 269.00\n", + "rsi: 52.837835463298674\n", + "2018-08-10, Cash 79578.35840000004 Value 106545.35840000004\n", + "2018-08-10, Close, 267.00\n", + "rsi: 50.97542030173082\n", + "2018-08-13, Cash 79578.35840000004 Value 106848.35840000004\n", + "2018-08-13, Close, 270.00\n", + "rsi: 53.61643919790798\n", + "2018-08-14, Cash 79578.35840000004 Value 107191.75840000004\n", + "2018-08-14, Close, 273.40\n", + "rsi: 56.47803611616794\n", + "2018-08-15, Cash 79578.35840000004 Value 107252.35840000004\n", + "2018-08-15, Close, 274.00\n", + "rsi: 56.982404117469315\n", + "2018-08-16, Cash 79578.35840000004 Value 106525.15840000004\n", + "2018-08-16, Close, 266.80\n", + "rsi: 49.56012378238477\n", + "2018-08-17, Cash 79578.35840000004 Value 106969.55840000004\n", + "2018-08-17, Close, 271.20\n", + "rsi: 53.54262667378367\n", + "2018-08-20, Cash 79578.35840000004 Value 107151.35840000004\n", + "2018-08-20, Close, 273.00\n", + "rsi: 55.104304011861046\n", + "2018-08-22, Cash 79578.35840000004 Value 108464.35840000004\n", + "2018-08-22, Close, 286.00\n", + "rsi: 64.40951277128632\n", + "2018-08-23, Cash 79578.35840000004 Value 109171.35840000004\n", + "2018-08-23, Close, 293.00\n", + "rsi: 68.22810984790678\n", + "2018-08-24, Cash 79578.35840000004 Value 108666.35840000004\n", + "2018-08-24, Close, 288.00\n", + "rsi: 63.026367605713666\n", + "2018-08-28, Cash 79578.35840000004 Value 108888.55840000004\n", + "2018-08-28, Close, 290.20\n", + "rsi: 64.31551415845934\n", + "2018-08-29, Cash 79578.35840000004 Value 108605.75840000004\n", + "2018-08-29, Close, 287.40\n", + "rsi: 61.38210924987061\n", + "2018-08-30, Cash 79578.35840000004 Value 108464.35840000004\n", + "2018-08-30, Close, 286.00\n", + "rsi: 59.91075995730769\n", + "2018-08-31, Cash 79578.35840000004 Value 108666.35840000004\n", + "2018-08-31, Close, 288.00\n", + "rsi: 61.336567880140144\n", + "2018-09-03, Cash 79578.35840000004 Value 108060.35840000004\n", + "2018-09-03, Close, 282.00\n", + "rsi: 55.01505940646998\n", + "2018-09-04, Cash 79578.35840000004 Value 108524.95840000005\n", + "2018-09-04, Close, 286.60\n", + "rsi: 58.54276887460818\n", + "2018-09-05, Cash 79578.35840000004 Value 108363.35840000004\n", + "2018-09-05, Close, 285.00\n", + "rsi: 56.87216959399253\n", + "2018-09-06, Cash 79578.35840000004 Value 107454.35840000004\n", + "2018-09-06, Close, 276.00\n", + "rsi: 48.489967391619\n", + "2018-09-07, Cash 79578.35840000004 Value 107959.35840000004\n", + "2018-09-07, Close, 281.00\n", + "rsi: 52.664055058217215\n", + "2018-09-10, Cash 79578.35840000004 Value 107696.75840000004\n", + "2018-09-10, Close, 278.40\n", + "rsi: 50.37793955248839\n", + "2018-09-11, Cash 79578.35840000004 Value 107454.35840000004\n", + "2018-09-11, Close, 276.00\n", + "rsi: 48.2939332510872\n", + "2018-09-12, Cash 79578.35840000004 Value 106747.35840000004\n", + "2018-09-12, Close, 269.00\n", + "rsi: 42.740407759521716\n", + "2018-09-13, Cash 79578.35840000004 Value 107555.35840000004\n", + "2018-09-13, Close, 277.00\n", + "rsi: 49.83966983684196\n", + "2018-09-14, Cash 79578.35840000004 Value 106747.35840000004\n", + "2018-09-14, Close, 269.00\n", + "rsi: 43.96889776005912\n", + "2018-09-17, Cash 79578.35840000004 Value 107353.35840000004\n", + "2018-09-17, Close, 275.00\n", + "rsi: 48.836614358547756\n", + "2018-09-18, Cash 79578.35840000004 Value 107050.35840000004\n", + "2018-09-18, Close, 272.00\n", + "rsi: 46.654179147727405\n", + "2018-09-19, Cash 79578.35840000004 Value 106242.35840000004\n", + "2018-09-19, Close, 264.00\n", + "rsi: 41.34776365608433\n", + "2018-09-20, Cash 79578.35840000004 Value 106949.35840000004\n", + "2018-09-20, Close, 271.00\n", + "rsi: 47.02544191484164\n", + "2018-09-21, Cash 79578.35840000004 Value 107050.35840000004\n", + "2018-09-21, Close, 272.00\n", + "rsi: 47.8027981177714\n", + "2018-09-24, Cash 79578.35840000004 Value 106949.35840000004\n", + "2018-09-24, Close, 271.00\n", + "rsi: 47.05912639222485\n", + "2018-09-25, Cash 79578.35840000004 Value 106727.15840000004\n", + "2018-09-25, Close, 268.80\n", + "rsi: 45.38626573638468\n", + "2018-09-26, Cash 79578.35840000004 Value 106464.55840000004\n", + "2018-09-26, Close, 266.20\n", + "rsi: 43.42173672476035\n", + "2018-09-27, Cash 79578.35840000004 Value 105737.35840000004\n", + "2018-09-27, Close, 259.00\n", + "rsi: 38.45743528259799\n", + "2018-09-28, Cash 79578.35840000004 Value 105535.35840000004\n", + "2018-09-28, Close, 257.00\n", + "rsi: 37.1856649504255\n", + "2018-10-01, Cash 79578.35840000004 Value 105030.35840000004\n", + "2018-10-01, Close, 252.00\n", + "rsi: 34.145568183474566\n", + "2018-10-02, Cash 79578.35840000004 Value 104828.35840000004\n", + "2018-10-02, Close, 250.00\n", + "rsi: 32.98396087204799\n", + "2018-10-03, Cash 79578.35840000004 Value 105030.35840000004\n", + "2018-10-03, Close, 252.00\n", + "rsi: 35.35239924167253\n", + "2018-10-04, Cash 79578.35840000004 Value 105030.35840000004\n", + "2018-10-04, Close, 252.00\n", + "rsi: 35.35239924167253\n", + "2018-10-05, Cash 79578.35840000004 Value 104525.35840000004\n", + "2018-10-05, Close, 247.00\n", + "rsi: 32.06656845239766\n", + "2018-10-08, Cash 79578.35840000004 Value 104121.35840000004\n", + "2018-10-08, Close, 243.00\n", + "rsi: 29.68918493723318\n", + "2018-10-08, BUY CREATE, 243.00\n", + "2018-10-09, BUY EXECUTED, Price: 243.20, Cost: 9971.20, Comm 59.83\n", + "2018-10-09, Cash 69547.33120000004 Value 105388.13120000005\n", + "2018-10-09, Close, 252.40\n", + "rsi: 40.797309677820465\n", + "2018-10-10, Cash 69547.33120000004 Value 105615.33120000004\n", + "2018-10-10, Close, 254.00\n", + "rsi: 42.46355317132975\n", + "2018-10-11, Cash 69547.33120000004 Value 105615.33120000004\n", + "2018-10-11, Close, 254.00\n", + "rsi: 42.46355317132975\n", + "2018-10-12, Cash 69547.33120000004 Value 106751.33120000004\n", + "2018-10-12, Close, 262.00\n", + "rsi: 50.536326555854245\n", + "2018-10-15, Cash 69547.33120000004 Value 105047.33120000004\n", + "2018-10-15, Close, 250.00\n", + "rsi: 41.19865308381308\n", + "2018-10-16, Cash 69547.33120000004 Value 105643.73120000005\n", + "2018-10-16, Close, 254.20\n", + "rsi: 45.02721339370196\n", + "2018-10-17, Cash 69547.33120000004 Value 106268.53120000006\n", + "2018-10-17, Close, 258.60\n", + "rsi: 48.78904348121469\n", + "2018-10-18, Cash 69547.33120000004 Value 106467.33120000004\n", + "2018-10-18, Close, 260.00\n", + "rsi: 49.962341783749565\n", + "2018-10-19, Cash 69547.33120000004 Value 107177.33120000004\n", + "2018-10-19, Close, 265.00\n", + "rsi: 54.01455767156502\n", + "2018-10-22, Cash 69547.33120000004 Value 108171.33120000004\n", + "2018-10-22, Close, 272.00\n", + "rsi: 59.01833440003518\n", + "2018-10-23, Cash 69547.33120000004 Value 107603.33120000004\n", + "2018-10-23, Close, 268.00\n", + "rsi: 55.314407122277416\n", + "2018-10-24, Cash 69547.33120000004 Value 107063.73120000005\n", + "2018-10-24, Close, 264.20\n", + "rsi: 51.97710245000457\n", + "2018-10-25, Cash 69547.33120000004 Value 106751.33120000004\n", + "2018-10-25, Close, 262.00\n", + "rsi: 50.09277467176448\n", + "2018-10-26, Cash 69547.33120000004 Value 107887.33120000004\n", + "2018-10-26, Close, 270.00\n", + "rsi: 56.2972509819482\n", + "2018-10-29, Cash 69547.33120000004 Value 107887.33120000004\n", + "2018-10-29, Close, 270.00\n", + "rsi: 56.2972509819482\n", + "2018-10-30, Cash 69547.33120000004 Value 107035.33120000004\n", + "2018-10-30, Close, 264.00\n", + "rsi: 50.8035342614948\n", + "2018-10-31, Cash 69547.33120000004 Value 108739.33120000004\n", + "2018-10-31, Close, 276.00\n", + "rsi: 59.347849722443385\n", + "2018-11-05, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-05, Close, 280.00\n", + "rsi: 61.73359701432002\n", + "2018-11-06, Cash 69547.33120000004 Value 109108.53120000006\n", + "2018-11-06, Close, 278.60\n", + "rsi: 60.39757640741702\n", + "2018-11-07, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-07, Close, 280.00\n", + "rsi: 61.29954685364349\n", + "2018-11-08, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-08, Close, 280.00\n", + "rsi: 61.29954685364349\n", + "2018-11-09, Cash 69547.33120000004 Value 109023.33120000004\n", + "2018-11-09, Close, 278.00\n", + "rsi: 59.0705330413327\n", + "2018-11-12, Cash 69547.33120000004 Value 108455.33120000004\n", + "2018-11-12, Close, 274.00\n", + "rsi: 54.780174512413865\n", + "2018-11-13, Cash 69547.33120000004 Value 108284.93120000005\n", + "2018-11-13, Close, 272.80\n", + "rsi: 53.52420567178318\n", + "2018-11-14, Cash 69547.33120000004 Value 109165.33120000004\n", + "2018-11-14, Close, 279.00\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rsi: 58.782364011659794\n", + "2018-11-15, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-15, Close, 280.00\n", + "rsi: 59.57674907601524\n", + "2018-11-16, Cash 69547.33120000004 Value 109591.33120000004\n", + "2018-11-16, Close, 282.00\n", + "rsi: 61.18787715632502\n", + "2018-11-19, Cash 69547.33120000004 Value 109591.33120000004\n", + "2018-11-19, Close, 282.00\n", + "rsi: 61.18787715632502\n", + "2018-11-20, Cash 69547.33120000004 Value 109165.33120000004\n", + "2018-11-20, Close, 279.00\n", + "rsi: 57.22043494208389\n", + "2018-11-21, Cash 69547.33120000004 Value 109591.33120000004\n", + "2018-11-21, Close, 282.00\n", + "rsi: 60.01267203384573\n", + "2018-11-22, Cash 69547.33120000004 Value 110017.33120000004\n", + "2018-11-22, Close, 285.00\n", + "rsi: 62.63883131541318\n", + "2018-11-23, Cash 69547.33120000004 Value 109733.33120000004\n", + "2018-11-23, Close, 283.00\n", + "rsi: 59.81832949968181\n", + "2018-11-26, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-26, Close, 280.00\n", + "rsi: 55.76231520596205\n", + "2018-11-27, Cash 69547.33120000004 Value 109733.33120000004\n", + "2018-11-27, Close, 283.00\n", + "rsi: 58.77278243951265\n", + "2018-11-28, Cash 69547.33120000004 Value 109307.33120000004\n", + "2018-11-28, Close, 280.00\n", + "rsi: 54.75962099005832\n", + "2018-11-29, Cash 69547.33120000004 Value 109080.13120000003\n", + "2018-11-29, Close, 278.40\n", + "rsi: 52.693064652065445\n", + "2018-12-03, Cash 69547.33120000004 Value 110272.93120000005\n", + "2018-12-03, Close, 286.80\n", + "rsi: 61.01190545267988\n", + "2018-12-04, Cash 69547.33120000004 Value 110670.53120000006\n", + "2018-12-04, Close, 289.60\n", + "rsi: 63.32689537586097\n", + "2018-12-05, Cash 69547.33120000004 Value 111295.33120000004\n", + "2018-12-05, Close, 294.00\n", + "rsi: 66.67547332141706\n", + "2018-12-06, Cash 69547.33120000004 Value 111579.33120000004\n", + "2018-12-06, Close, 296.00\n", + "rsi: 68.10124024529411\n", + "2018-12-07, Cash 69547.33120000004 Value 111437.33120000004\n", + "2018-12-07, Close, 295.00\n", + "rsi: 66.56767374230641\n", + "2018-12-10, Cash 69547.33120000004 Value 110869.33120000004\n", + "2018-12-10, Close, 291.00\n", + "rsi: 60.68130852049086\n", + "2018-12-11, Cash 69547.33120000004 Value 111721.33120000004\n", + "2018-12-11, Close, 297.00\n", + "rsi: 65.59572716152519\n", + "2018-12-12, Cash 69547.33120000004 Value 111295.33120000004\n", + "2018-12-12, Close, 294.00\n", + "rsi: 61.45938915321556\n", + "2018-12-13, Cash 69547.33120000004 Value 111380.53120000006\n", + "2018-12-13, Close, 294.60\n", + "rsi: 61.97582332132428\n", + "2018-12-14, Cash 69547.33120000004 Value 111863.33120000004\n", + "2018-12-14, Close, 298.00\n", + "rsi: 64.85012598433293\n", + "2018-12-17, Cash 69547.33120000004 Value 112147.33120000004\n", + "2018-12-17, Close, 300.00\n", + "rsi: 66.45639462322177\n", + "2018-12-18, Cash 69547.33120000004 Value 112317.73120000005\n", + "2018-12-18, Close, 301.20\n", + "rsi: 67.41845432741094\n", + "2018-12-19, Cash 69547.33120000004 Value 112857.33120000004\n", + "2018-12-19, Close, 305.00\n", + "rsi: 70.32130148998732\n", + "2018-12-19, SELL CREATE, 305.00\n", + "2018-12-20, SELL EXECUTED, Price: 305.60, Cost: 7876.39, Comm 58.68\n", + "2018-12-20, Cash 79267.85600000004 Value 112597.85600000004\n", + "2018-12-20, Close, 303.00\n", + "rsi: 66.94084937808321\n", + "2018-12-21, Cash 79267.85600000004 Value 112531.85600000004\n", + "2018-12-21, Close, 302.40\n", + "rsi: 65.91710402106918\n", + "2018-12-26, Cash 79267.85600000004 Value 111387.85600000004\n", + "2018-12-26, Close, 292.00\n", + "rsi: 51.27841744570335\n", + "2018-12-27, Cash 79267.85600000004 Value 111717.85600000004\n", + "2018-12-27, Close, 295.00\n", + "rsi: 54.4227245179349\n", + "2018-12-28, Cash 79267.85600000004 Value 111365.85600000004\n", + "2018-12-28, Close, 291.80\n", + "rsi: 50.66661003356886\n", + "Final Portfolio Value: 111365.86\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from __future__ import (absolute_import, division, print_function,\n", + " unicode_literals)\n", + "from pkg_resources import resource_filename\n", + "import datetime\n", + "import os.path\n", + "import sys\n", + "import backtrader as bt\n", + "import backtrader.feeds as btfeed\n", + "\n", + "INIT_CASH = 100000\n", + "BAND_PERIOD = 30\n", + "COMMISSION_PER_TRANSACTION = 0.006\n", + "DATA_FILE = resource_filename(__name__,'../data/JFC_2010-01-01_2019-01-01_OHLCV.csv')\n", + "\n", + "class MinMaxSupportResistance(bt.Strategy):\n", + " def log(self, txt, dt=None):\n", + " dt = dt or self.datas[0].datetime.date(0)\n", + " print('%s, %s' % (dt.isoformat(), txt))\n", + "\n", + " def __init__(self):\n", + " self.dataclose = self.datas[0].close\n", + " self.order = None\n", + " self.buyprice = None\n", + " self.buycomm = None\n", + "\n", + " self.minn = bt.indicators.MinN(self.datas[0], period=BAND_PERIOD)\n", + " self.maxn = bt.indicators.MaxN(self.datas[0], period=BAND_PERIOD)\n", + "\n", + " def notify_order(self, order):\n", + " if order.status in [order.Submitted, order.Accepted]:\n", + " return\n", + "\n", + " if order.status in [order.Completed]:\n", + " if order.isbuy():\n", + " self.log(\n", + " 'BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %\n", + " (order.executed.price,\n", + " order.executed.value,\n", + " order.executed.comm))\n", + "\n", + " self.buyprice = order.executed.price\n", + " self.buycomm = order.executed.comm\n", + " else: # Sell\n", + " self.log('SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %\n", + " (order.executed.price,\n", + " order.executed.value,\n", + " order.executed.comm))\n", + "\n", + " self.bar_executed = len(self)\n", + "\n", + " elif order.status in [order.Canceled, order.Margin, order.Rejected]:\n", + " self.log('Order Canceled/Margin/Rejected')\n", + "\n", + " # Write down: no pending order\n", + " self.order = None\n", + " \n", + " def notify_cashvalue(self, cash, value):\n", + " # Update cash and value every period\n", + " self.log('Cash %s Value %s' % (cash, value))\n", + " self.cash = cash\n", + " self.value = value\n", + "\n", + " def notify_trade(self, trade):\n", + " if not trade.isclosed:\n", + " return\n", + "\n", + " self.log('OPERATION PROFIT, GROSS %.2f, NET %.2f' %\n", + " (trade.pnl, trade.pnlcomm))\n", + "\n", + " def next(self):\n", + " self.log('Close, %.2f' % self.dataclose[0])\n", + " print('Max price:', self.maxn[0])\n", + " print('Min price:', self.minn[0])\n", + " if self.order:\n", + " return\n", + "\n", + " # Only buy if there is enough cash for at least one stock\n", + " if self.cash >= self.dataclose[0]:\n", + " # Sell if the current closing is the lowest in the last N days\n", + " if (self.dataclose[0] == self.maxn):\n", + " self.log('BUY CREATE, %.2f' % self.dataclose[0])\n", + " # Take a 10% long position every time it's a buy signal (or whatever is afforder by the current cash position)\n", + " # \"size\" refers to the number of stocks to purchase\n", + " self.order = self.buy(size=int(min((INIT_CASH / self.dataclose[0]) * 0.1, self.cash / self.dataclose[0])))\n", + "\n", + " # Only sell if you hold least one unit of the stock (and sell only that stock, so no short selling)\n", + " if (self.value - self.cash) > 0:\n", + " # Buy if the current closing is the highest in the last N days\n", + " if (self.dataclose[0] == self.minn):\n", + " self.log('SELL CREATE, %.2f' % self.dataclose[0])\n", + " # Sell a 5% sell position (or whatever is afforded by the current stock holding)\n", + " # \"size\" refers to the number of stocks to purchase\n", + " self.order = self.sell(size=int(min((INIT_CASH / self.dataclose[0]) * 0.05, (self.value - self.cash) / self.dataclose[0])))\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " cerebro = bt.Cerebro()\n", + " cerebro.addstrategy(MinMaxSupportResistance)\n", + " cerebro.broker.setcommission(commission=COMMISSION_PER_TRANSACTION)\n", + "\n", + " data = btfeed.GenericCSVData(\n", + " dataname=DATA_FILE,\n", + "\n", + " fromdate=datetime.datetime(2017, 1, 1),\n", + " todate=datetime.datetime(2019, 1, 1),\n", + "\n", + " nullvalue=0.0,\n", + "\n", + " dtformat=('%Y-%m-%d'),\n", + "\n", + " datetime=0,\n", + " open=1,\n", + " high=2,\n", + " low=3,\n", + " close=4,\n", + " volume=5,\n", + " openinterest=-1\n", + " )\n", + " cerebro.adddata(data)\n", + " cerebro.broker.setcash(INIT_CASH)\n", + " print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())\n", + " cerebro.run()\n", + " print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())\n", + " cerebro.plot(figsize=(30, 15))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/dependencies/fastquant/examples/jfc_support_resistance.py b/dependencies/fastquant/examples/jfc_support_resistance.py new file mode 100644 index 0000000..f308098 --- /dev/null +++ b/dependencies/fastquant/examples/jfc_support_resistance.py @@ -0,0 +1,148 @@ +# Import standard library +from __future__ import ( + absolute_import, + division, + print_function, + unicode_literals, +) +import datetime +import os.path +import sys +from pkg_resources import resource_filename + +# Import modules +import backtrader as bt +import backtrader.feeds as btfeed + +INIT_CASH = 100000 +BAND_PERIOD = 30 +COMMISSION_PER_TRANSACTION = 0.006 +DATA_FILE = resource_filename(__name__, "../data/JFC_2010-01-01_2019-01-01_OHLCV.csv") + + +class MinMaxSupportResistance(bt.Strategy): + def log(self, txt, dt=None): + dt = dt or self.datas[0].datetime.date(0) + print("%s, %s" % (dt.isoformat(), txt)) + + def __init__(self): + self.dataclose = self.datas[0].close + self.order = None + self.buyprice = None + self.buycomm = None + + self.minn = bt.indicators.MinN(self.datas[0], period=BAND_PERIOD) + self.maxn = bt.indicators.MaxN(self.datas[0], period=BAND_PERIOD) + + def notify_order(self, order): + if order.status in [order.Submitted, order.Accepted]: + return + + if order.status in [order.Completed]: + if order.isbuy(): + self.log( + "BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f" + % ( + order.executed.price, + order.executed.value, + order.executed.comm, + ) + ) + + self.buyprice = order.executed.price + self.buycomm = order.executed.comm + else: # Sell + self.log( + "SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f" + % ( + order.executed.price, + order.executed.value, + order.executed.comm, + ) + ) + + self.bar_executed = len(self) + + elif order.status in [order.Canceled, order.Margin, order.Rejected]: + self.log("Order Canceled/Margin/Rejected") + + # Write down: no pending order + self.order = None + + def notify_cashvalue(self, cash, value): + # Update cash and value every period + self.log("Cash %s Value %s" % (cash, value)) + self.cash = cash + self.value = value + + def notify_trade(self, trade): + if not trade.isclosed: + return + + self.log("OPERATION PROFIT, GROSS %.2f, NET %.2f" % (trade.pnl, trade.pnlcomm)) + + def next(self): + self.log("Close, %.2f" % self.dataclose[0]) + print("Max price:", self.maxn[0]) + print("Min price:", self.minn[0]) + if self.order: + return + + # Only buy if there is enough cash for at least one stock + if self.cash >= self.dataclose[0]: + # Sell if the current closing is the lowest in the last N days + if self.dataclose[0] == self.maxn: + self.log("BUY CREATE, %.2f" % self.dataclose[0]) + # Take a 10% long position every time it's a buy signal (or whatever is afforder by the current cash position) + # "size" refers to the number of stocks to purchase + self.order = self.buy( + size=int( + min( + (INIT_CASH / self.dataclose[0]) * 0.1, + self.cash / self.dataclose[0], + ) + ) + ) + + # Only sell if you hold least one unit of the stock (and sell only that stock, so no short selling) + if (self.value - self.cash) > 0: + # Buy if the current closing is the highest in the last N days + if self.dataclose[0] == self.minn: + self.log("SELL CREATE, %.2f" % self.dataclose[0]) + # Sell a 5% sell position (or whatever is afforded by the current stock holding) + # "size" refers to the number of stocks to purchase + self.order = self.sell( + size=int( + min( + (INIT_CASH / self.dataclose[0]) * 0.05, + (self.value - self.cash) / self.dataclose[0], + ) + ) + ) + + +if __name__ == "__main__": + cerebro = bt.Cerebro() + cerebro.addstrategy(MinMaxSupportResistance) + cerebro.broker.setcommission(commission=COMMISSION_PER_TRANSACTION) + + data = btfeed.GenericCSVData( + dataname=DATA_FILE, + fromdate=datetime.datetime(2017, 1, 1), + todate=datetime.datetime(2019, 1, 1), + nullvalue=0.0, + dtformat=("%Y-%m-%d"), + datetime=0, + open=1, + high=2, + low=3, + close=4, + volume=5, + openinterest=-1, + ) + cerebro.adddata(data) + cerebro.broker.setcash(INIT_CASH) + print("Starting Portfolio Value: %.2f" % cerebro.broker.getvalue()) + cerebro.run() + print("Final Portfolio Value: %.2f" % cerebro.broker.getvalue()) + cerebro.plot(figsize=(30, 15)) diff --git a/dependencies/fastquant/examples/notif_bot/notif_bot_POC.ipynb b/dependencies/fastquant/examples/notif_bot/notif_bot_POC.ipynb new file mode 100644 index 0000000..de4ae58 --- /dev/null +++ b/dependencies/fastquant/examples/notif_bot/notif_bot_POC.ipynb @@ -0,0 +1,404 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "This notebook demonstrates the proof of concept for the proposed daily notification scheme.\n", + "\n", + "Assumptions:\n", + "- The strategy has been thoroughly backtested and ready for actual trading.\n", + "- Today is Nov 5, 2018, which is trading Day 0." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Initialize data (Day 0)\n", + "- Save the data to disk. This is so the script will only fetch the latest stock data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "from fastquant import backtest, get_stock_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Setup our variables\n", + "FILE_DIR = \"jfc.csv\"\n", + "SYMBOL = \"JFC\"\n", + "today = \"2018-11-06\" # Fake today date for demo purposes\n", + "\n", + "df = get_stock_data(SYMBOL, \"2018-01-01\", \"2018-11-05\")\n", + "df.to_csv(FILE_DIR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Daily script calls (Day 1-2)\n", + "1. Fetch today's data\n", + "2. Load data from disk and append today's data\n", + "3. Run backtest with args `live=True` and `today=today`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Demo Day 1: Nov 6, 2018 (buy)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def daily_fetch(file_dir, symbol, today):\n", + " today_df = get_stock_data(symbol, today, today)\n", + "\n", + " # Retrieve saved historical data on disk and append new data\n", + " # TODO: add checks if daily updates were broken\n", + " df = pd.read_csv(file_dir, parse_dates=[\"dt\"]).set_index(\"dt\")\n", + " # df = df.append(today_df)\n", + " df = pd.concat([df, today_df], ignore_index=True)\n", + " df.to_csv(file_dir)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===Global level arguments===\n", + "init_cash : 100000\n", + "buy_prop : 1\n", + "sell_prop : 1\n", + "commission : 0.0075\n", + "===Strategy level arguments===\n", + "fast_period : 15\n", + "slow_period : 40\n", + ">>> Notif bot: BUY! <<<\n", + "Final Portfolio Value: 97652.8975\n", + "Final PnL: -2347.1\n", + "Time used (seconds): 0.05349397659301758\n", + "Optimal parameters: {'init_cash': 100000, 'buy_prop': 1, 'sell_prop': 1, 'commission': 0.0075, 'execution_type': 'close', 'live': True, 'today': '2018-11-06', 'notif_script_dir': False, 'symbol': '', 'fast_period': 15, 'slow_period': 40}\n", + "Optimal metrics: {'rtot': -0.023750856806590226, 'ravg': -0.00011418681157014532, 'rnorm': -0.028365016583377686, 'rnorm100': -2.8365016583377685, 'sharperatio': None, 'pnl': -2347.1, 'final_value': 97652.8975}\n" + ] + }, + { + "data": { + "application/javascript": "/* Put everything inside the global mpl namespace */\nwindow.mpl = {};\n\n\nmpl.get_websocket_type = function() {\n if (typeof(WebSocket) !== 'undefined') {\n return WebSocket;\n } else if (typeof(MozWebSocket) !== 'undefined') {\n return MozWebSocket;\n } else {\n alert('Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.');\n };\n}\n\nmpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = (this.ws.binaryType != undefined);\n\n if (!this.supports_binary) {\n var warnings = document.getElementById(\"mpl-warnings\");\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent = (\n \"This browser does not support binary websocket messages. \" +\n \"Performance may be slow.\");\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = $('
');\n this._root_extra_style(this.root)\n this.root.attr('style', 'display: inline-block');\n\n $(parent_element).append(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n fig.send_message(\"send_image_mode\", {});\n if (mpl.ratio != 1) {\n fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n }\n fig.send_message(\"refresh\", {});\n }\n\n this.imageObj.onload = function() {\n if (fig.image_mode == 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function() {\n fig.ws.close();\n }\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n}\n\nmpl.figure.prototype._init_header = function() {\n var titlebar = $(\n '
');\n var titletext = $(\n '
');\n titlebar.append(titletext)\n this.root.append(titlebar);\n this.header = titletext[0];\n}\n\n\n\nmpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n\n}\n\n\nmpl.figure.prototype._root_extra_style = function(canvas_div) {\n\n}\n\nmpl.figure.prototype._init_canvas = function() {\n var fig = this;\n\n var canvas_div = $('
');\n\n canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n\n function canvas_keyboard_event(event) {\n return fig.key_event(event, event['data']);\n }\n\n canvas_div.keydown('key_press', canvas_keyboard_event);\n canvas_div.keyup('key_release', canvas_keyboard_event);\n this.canvas_div = canvas_div\n this._canvas_extra_style(canvas_div)\n this.root.append(canvas_div);\n\n var canvas = $('');\n canvas.addClass('mpl-canvas');\n canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n\n this.canvas = canvas[0];\n this.context = canvas[0].getContext(\"2d\");\n\n var backingStore = this.context.backingStorePixelRatio ||\n\tthis.context.webkitBackingStorePixelRatio ||\n\tthis.context.mozBackingStorePixelRatio ||\n\tthis.context.msBackingStorePixelRatio ||\n\tthis.context.oBackingStorePixelRatio ||\n\tthis.context.backingStorePixelRatio || 1;\n\n mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband = $('');\n rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n\n var pass_mouse_events = true;\n\n canvas_div.resizable({\n start: function(event, ui) {\n pass_mouse_events = false;\n },\n resize: function(event, ui) {\n fig.request_resize(ui.size.width, ui.size.height);\n },\n stop: function(event, ui) {\n pass_mouse_events = true;\n fig.request_resize(ui.size.width, ui.size.height);\n },\n });\n\n function mouse_event_fn(event) {\n if (pass_mouse_events)\n return fig.mouse_event(event, event['data']);\n }\n\n rubberband.mousedown('button_press', mouse_event_fn);\n rubberband.mouseup('button_release', mouse_event_fn);\n // Throttle sequential mouse events to 1 every 20ms.\n rubberband.mousemove('motion_notify', mouse_event_fn);\n\n rubberband.mouseenter('figure_enter', mouse_event_fn);\n rubberband.mouseleave('figure_leave', mouse_event_fn);\n\n canvas_div.on(\"wheel\", function (event) {\n event = event.originalEvent;\n event['data'] = 'scroll'\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n mouse_event_fn(event);\n });\n\n canvas_div.append(canvas);\n canvas_div.append(rubberband);\n\n this.rubberband = rubberband;\n this.rubberband_canvas = rubberband[0];\n this.rubberband_context = rubberband[0].getContext(\"2d\");\n this.rubberband_context.strokeStyle = \"#000000\";\n\n this._resize_canvas = function(width, height) {\n // Keep the size of the canvas, canvas container, and rubber band\n // canvas in synch.\n canvas_div.css('width', width)\n canvas_div.css('height', height)\n\n canvas.attr('width', width * mpl.ratio);\n canvas.attr('height', height * mpl.ratio);\n canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n\n rubberband.attr('width', width);\n rubberband.attr('height', height);\n }\n\n // Set the figure to an initial 600x600px, this will subsequently be updated\n // upon first draw.\n this._resize_canvas(600, 600);\n\n // Disable right mouse context menu.\n $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n return false;\n });\n\n function set_focus () {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n}\n\nmpl.figure.prototype._init_toolbar = function() {\n var fig = this;\n\n var nav_element = $('
');\n nav_element.attr('style', 'width: 100%');\n this.root.append(nav_element);\n\n // Define a callback function for later on.\n function toolbar_event(event) {\n return fig.toolbar_button_onclick(event['data']);\n }\n function toolbar_mouse_event(event) {\n return fig.toolbar_button_onmouseover(event['data']);\n }\n\n for(var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n // put a spacer in here.\n continue;\n }\n var button = $('