From 2cffc3228a0e12ec1667c0f17c8ede0bd286a541 Mon Sep 17 00:00:00 2001 From: Jonathan Raviotta Date: Sun, 11 Aug 2019 12:52:37 -0400 Subject: [PATCH 1/3] split example notebooks --- .gitignore | 9 +- docs/data-analysis.md | 161 +++++++--- .../notebooks/jupyter_snippets_example.ipynb | 289 ++++++++++++++++++ ....ipynb => strategy_analysis_example.ipynb} | 215 ++++++------- 4 files changed, 514 insertions(+), 160 deletions(-) create mode 100644 user_data/notebooks/jupyter_snippets_example.ipynb rename user_data/notebooks/{analysis_example.ipynb => strategy_analysis_example.ipynb} (51%) diff --git a/.gitignore b/.gitignore index 3a9df9852..1664ad7eb 100644 --- a/.gitignore +++ b/.gitignore @@ -6,7 +6,10 @@ config*.json .hyperopt logfile.txt hyperopt_trials.pickle -user_data/ +user_data/* +!user_data/notebooks +user_data/notebooks/* +!user_data/notebooks/*example.ipynb freqtrade-plot.html freqtrade-profit-plot.html @@ -80,7 +83,7 @@ docs/_build/ target/ # Jupyter Notebook -.ipynb_checkpoints +*.ipynb_checkpoints # pyenv .python-version @@ -94,4 +97,4 @@ target/ .mypy_cache/ #exceptions -!user_data/noteboks/*example.ipynb +!*.gitkeep diff --git a/docs/data-analysis.md b/docs/data-analysis.md index c89353cc8..8d4cc63c0 100644 --- a/docs/data-analysis.md +++ b/docs/data-analysis.md @@ -1,30 +1,96 @@ -# Analyzing bot data +# Analyzing bot data with Jupyter notebooks -You can analyze the results of backtests and trading history easily using Jupyter notebooks. A sample notebook is located at `user_data/notebooks/analysis_example.ipynb`. For usage instructions, see [jupyter.org](https://jupyter.org/documentation). +You can analyze the results of backtests and trading history easily using Jupyter notebooks. Sample notebooks are located at `user_data/notebooks/`. -*Pro tip - Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)* +## Pro tips -## Example snippets +* See [jupyter.org](https://jupyter.org/documentation) for usage instructions. +* Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)* +* Copy the example notebook so your changes don't get clobbered with the next freqtrade update. + +## Fine print + +Some tasks don't work especially well in notebooks. For example, anything using asyncronous exectution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required parameters to functions. + +## Recommended workflow + +| Task | Tool | + --- | --- +Bot operations | CLI +Repetative tasks | shell scripts +Data analysis & visualization | Notebook + +1. Use the CLI to + * download historical data + * run a backtest + * run with real-time data + * export results + +1. Collect these actions in shell scripts + * save complicated commands with arguments + * execute mult-step operations + * automate testing strategies and prepareing data for analysis + +1. Use a notebook to + * import data + * munge and plot to generate insights + +## Example utility snippets for Jupyter notebooks + +### Change directory to root + +Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistant. + +```python +# Change directory +# Modify this cell to insure that the output shows the correct path. +# Define all paths relative to the project root shown in the cell output +import os +from pathlib import Path + +project_root = "somedir/freqtrade" +i=0 +try: + os.chdirdir(project_root) + assert Path('LICENSE').is_file() +except: + while i<4 and (not Path('LICENSE').is_file()): + os.chdir(Path(Path.cwd(), '../')) + i+=1 + project_root = Path.cwd() +print(Path.cwd()) +``` + +### Watch project for changes to code + +This scans the project for changes to code before Jupyter runs cells. + +```python +# Reloads local code changes +%load_ext autoreload +%autoreload 2 +``` + +## Load existing objects into a Jupyter notebook + +These examples assume that you have already generated data using the cli. These examples will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload. ### Load backtest results into a pandas dataframe ```python -from freqtrade.data.btanalysis import load_backtest_data # Load backtest results +from freqtrade.data.btanalysis import load_backtest_data df = load_backtest_data("user_data/backtest_data/backtest-result.json") # Show value-counts per pair df.groupby("pair")["sell_reason"].value_counts() ``` -This will allow you to drill deeper into your backtest results, and perform analysis which otherwise would make the regular backtest-output very difficult to digest due to information overload. - ### Load live trading results into a pandas dataframe ``` python -from freqtrade.data.btanalysis import load_trades_from_db - # Fetch trades from database +from freqtrade.data.btanalysis import load_trades_from_db df = load_trades_from_db("sqlite:///tradesv3.sqlite") # Display results @@ -33,42 +99,61 @@ df.groupby("pair")["sell_reason"].value_counts() ### Load multiple configuration files -This option can be usefull to inspect the results of passing in multiple configs in case of problems +This option can be useful to inspect the results of passing in multiple configs ``` python +# Load config from multiple files from freqtrade.configuration import Configuration config = Configuration.from_files(["config1.json", "config2.json"]) -print(config) + +# Show the config in memory +import json +print(json.dumps(config, indent=1)) ``` -## Strategy debugging example +### Load exchange data to a pandas dataframe + +This loads candle data to a dataframe + +```python +# Load data using values passed to function +from pathlib import Path +from freqtrade.data.history import load_pair_history + +ticker_interval = "5m" +data_location = Path('user_data', 'data', 'bitrex') +pair = "BTC_USDT" +candles = load_pair_history(datadir=data_location, + ticker_interval=ticker_interval, + pair=pair) + +# Confirm success +print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}") +display(candles.head()) +``` + +## Strategy debugging example Debugging a strategy can be time-consuming. FreqTrade offers helper functions to visualize raw data. -### Import requirements and define variables used in analyses +### Define variables used in analyses + +You can override strategy settings as demonstrated below. ```python -# Imports -from pathlib import Path -import os -from freqtrade.data.history import load_pair_history -from freqtrade.resolvers import StrategyResolver - -# You can override strategy settings as demonstrated below. # Customize these according to your needs. # Define some constants ticker_interval = "5m" # Name of the strategy class -strategy_name = 'AwesomeStrategy' +strategy_name = 'TestStrategy' # Path to user data user_data_dir = 'user_data' # Location of the strategy strategy_location = Path(user_data_dir, 'strategies') # Location of the data data_location = Path(user_data_dir, 'data', 'binance') -# Pair to analyze -# Only use one pair here +# Pair to analyze - Only use one pair here pair = "BTC_USDT" ``` @@ -76,12 +161,16 @@ pair = "BTC_USDT" ```python # Load data using values set above -bt_data = load_pair_history(datadir=Path(data_location), +from pathlib import Path +from freqtrade.data.history import load_pair_history + +candles = load_pair_history(datadir=data_location, ticker_interval=ticker_interval, pair=pair) # Confirm success -print(f"Loaded {len(bt_data)} rows of data for {pair} from {data_location}") +print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}") +display(candles.head()) ``` ### Load and run strategy @@ -90,31 +179,27 @@ print(f"Loaded {len(bt_data)} rows of data for {pair} from {data_location}") ```python # Load strategy using values set above +from freqtrade.resolvers import StrategyResolver strategy = StrategyResolver({'strategy': strategy_name, 'user_data_dir': user_data_dir, 'strategy_path': strategy_location}).strategy # Generate buy/sell signals using strategy -df = strategy.analyze_ticker(bt_data, {'pair': pair}) +df = strategy.analyze_ticker(candles, {'pair': pair}) ``` ### Display the trade details * Note that using `data.head()` would also work, however most indicators have some "startup" data at the top of the dataframe. - -#### Some possible problems - -* Columns with NaN values at the end of the dataframe -* Columns used in `crossed*()` functions with completely different units - -#### Comparison with full backtest - -having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting. - -Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple "buy" signals for each pair in sequence (until rsi returns > 29). -The bot will only buy on the first of these signals (and also only if a trade-slot ("max_open_trades") is still available), or on one of the middle signals, as soon as a "slot" becomes available. +* Some possible problems + * Columns with NaN values at the end of the dataframe + * Columns used in `crossed*()` functions with completely different units +* Comparison with full backtest + * having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting. + * Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple "buy" signals for each pair in sequence (until rsi returns > 29). The bot will only buy on the first of these signals (and also only if a trade-slot ("max_open_trades") is still available), or on one of the middle signals, as soon as a "slot" becomes available. ```python + # Report results print(f"Generated {df['buy'].sum()} buy signals") data = df.set_index('date', drop=True) diff --git a/user_data/notebooks/jupyter_snippets_example.ipynb b/user_data/notebooks/jupyter_snippets_example.ipynb new file mode 100644 index 000000000..9d4ae467a --- /dev/null +++ b/user_data/notebooks/jupyter_snippets_example.ipynb @@ -0,0 +1,289 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing bot data with Jupyter notebooks \n", + "\n", + "You can analyze the results of backtests and trading history easily using Jupyter notebooks. A sample notebook is located at `user_data/notebooks/analysis_example.ipynb`. \n", + "\n", + "## Pro tips \n", + "\n", + "* See [jupyter.org](https://jupyter.org/documentation) for usage instructions.\n", + "* Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)*\n", + "* Copy the example notebook so your changes don't get clobbered with the next freqtrade update.\n", + "\n", + "## Fine print \n", + "\n", + "Some tasks don't work especially well in notebooks. For example, anything using asyncronous exectution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required parameters to functions.\n", + "\n", + "## Recommended workflow \n", + "\n", + "| Task | Tool | \n", + " --- | --- \n", + "Bot operations | CLI \n", + "Repetative tasks | shell scripts\n", + "Data analysis & visualization | Notebook \n", + "\n", + "1. Use the CLI to\n", + " * download historical data\n", + " * run a backtest\n", + " * run with real-time data\n", + " * export results \n", + "\n", + "1. Collect these actions in shell scripts\n", + " * save complicated commands with arguments\n", + " * execute mult-step operations \n", + " * automate testing strategies and prepareing data for analysis\n", + "\n", + "1. Use a notebook to\n", + " * import data\n", + " * munge and plot to generate insights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example utility snippets for Jupyter notebooks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Change directory to root \n", + "\n", + "Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Change directory\n", + "# Modify this cell to insure that the output shows the correct path.\n", + "# Define all paths relative to the project root shown in the cell output\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "project_root = \"somedir/freqtrade\"\n", + "i=0\n", + "try:\n", + " os.chdirdir(project_root)\n", + " assert Path('LICENSE').is_file()\n", + "except:\n", + " while i<4 and (not Path('LICENSE').is_file()):\n", + " os.chdir(Path(Path.cwd(), '../'))\n", + " i+=1\n", + " project_root = Path.cwd()\n", + "print(Path.cwd())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Watch project for changes to code\n", + "This scans the project for changes to code before Jupyter runs cells." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Reloads local code changes\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load existing objects into a Jupyter notebook\n", + "\n", + "These examples assume that you have already generated data using the cli. These examples will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load backtest results into a pandas dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load backtest results\n", + "from freqtrade.data.btanalysis import load_backtest_data\n", + "df = load_backtest_data(\"user_data/backtest_data/backtest-result.json\")\n", + "\n", + "# Show value-counts per pair\n", + "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load live trading results into a pandas dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Fetch trades from database\n", + "from freqtrade.data.btanalysis import load_trades_from_db\n", + "df = load_trades_from_db(\"sqlite:///tradesv3.sqlite\")\n", + "\n", + "# Display results\n", + "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load multiple configuration files\n", + "This option can be useful to inspect the results of passing in multiple configs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load config from multiple files\n", + "from freqtrade.configuration import Configuration\n", + "config = Configuration.from_files([\"config1.json\", \"config2.json\"])\n", + "\n", + "# Show the config in memory\n", + "import json\n", + "print(json.dumps(config, indent=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load exchange data to a pandas dataframe\n", + "\n", + "This loads candle data to a dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Load data using values passed to function\n", + "from pathlib import Path\n", + "from freqtrade.data.history import load_pair_history\n", + "\n", + "ticker_interval = \"5m\"\n", + "data_location = Path('user_data', 'data', 'bitrex')\n", + "pair = \"BTC_USDT\"\n", + "candles = load_pair_history(datadir=data_location,\n", + " ticker_interval=ticker_interval,\n", + " pair=pair)\n", + "\n", + "# Confirm success\n", + "print(\"Loaded \" + str(len(candles)) + f\" rows of data for {pair} from {data_location}\")\n", + "display(candles.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data." + ] + } + ], + "metadata": { + "file_extension": ".py", + "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.3" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "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 + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/user_data/notebooks/analysis_example.ipynb b/user_data/notebooks/strategy_analysis_example.ipynb similarity index 51% rename from user_data/notebooks/analysis_example.ipynb rename to user_data/notebooks/strategy_analysis_example.ipynb index f5e2c12d7..2b8b74fe6 100644 --- a/user_data/notebooks/analysis_example.ipynb +++ b/user_data/notebooks/strategy_analysis_example.ipynb @@ -1,96 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Analyzing bot data\n", - "\n", - "You can analyze the results of backtests and trading history easily using Jupyter notebooks. \n", - "**Copy this file so your changes don't get clobbered with the next freqtrade update!** \n", - "For usage instructions, see [jupyter.org](https://jupyter.org/documentation). \n", - "*Pro tip - Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)*\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Imports\n", - "from pathlib import Path\n", - "import os\n", - "from freqtrade.data.history import load_pair_history\n", - "from freqtrade.resolvers import StrategyResolver\n", - "from freqtrade.data.btanalysis import load_backtest_data\n", - "from freqtrade.data.btanalysis import load_trades_from_db" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Change directory\n", - "# Define all paths relative to the project root shown in the cell output\n", - "try:\n", - " os.chdir(Path(Path.cwd(), '../..'))\n", - " print(Path.cwd())\n", - "except:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example snippets" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load backtest results into a pandas dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Load backtest results\n", - "df = load_backtest_data(\"user_data/backtest_data/backtest-result.json\")\n", - "\n", - "# Show value-counts per pair\n", - "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load live trading results into a pandas dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Fetch trades from database\n", - "df = load_trades_from_db(\"sqlite:///tradesv3.sqlite\")\n", - "\n", - "# Display results\n", - "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -104,7 +13,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Import requirements and define variables used in analyses" + "## Setup" ] }, { @@ -113,28 +22,51 @@ "metadata": {}, "outputs": [], "source": [ + "# Change directory\n", + "# Modify this cell to insure that the output shows the correct path.\n", + "# Define all paths relative to the project root shown in the cell output\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "project_root = \"somedir/freqtrade\"\n", + "i=0\n", + "try:\n", + " os.chdirdir(project_root)\n", + " assert Path('LICENSE').is_file()\n", + "except:\n", + " while i<4 and (not Path('LICENSE').is_file()):\n", + " os.chdir(Path(Path.cwd(), '../'))\n", + " i+=1\n", + " project_root = Path.cwd()\n", + "print(Path.cwd())\n", + "\n", + "# Reloads local code changes\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Customize these according to your needs.\n", + "\n", "# Define some constants\n", "ticker_interval = \"5m\"\n", "# Name of the strategy class\n", - "strategy_name = 'AwesomeStrategy'\n", + "strategy_name = 'TestStrategy'\n", "# Path to user data\n", "user_data_dir = 'user_data'\n", "# Location of the strategy\n", "strategy_location = Path(user_data_dir, 'strategies')\n", "# Location of the data\n", "data_location = Path(user_data_dir, 'data', 'binance')\n", - "# Pair to analyze \n", - "# Only use one pair here\n", + "# Pair to analyze - Only use one pair here\n", "pair = \"BTC_USDT\"" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load exchange data" - ] - }, { "cell_type": "code", "execution_count": null, @@ -142,35 +74,43 @@ "outputs": [], "source": [ "# Load data using values set above\n", - "bt_data = load_pair_history(datadir=Path(data_location),\n", + "from pathlib import Path\n", + "from freqtrade.data.history import load_pair_history\n", + "\n", + "candles = load_pair_history(datadir=data_location,\n", " ticker_interval=ticker_interval,\n", " pair=pair)\n", "\n", "# Confirm success\n", - "print(\"Loaded \" + str(len(bt_data)) + f\" rows of data for {pair} from {data_location}\")" + "print(\"Loaded \" + str(len(candles)) + f\" rows of data for {pair} from {data_location}\")\n", + "display(candles.head())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Load and run strategy\n", + "## Load and run strategy\n", "* Rerun each time the strategy file is changed" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ "# Load strategy using values set above\n", + "from freqtrade.resolvers import StrategyResolver\n", "strategy = StrategyResolver({'strategy': strategy_name,\n", " 'user_data_dir': user_data_dir,\n", " 'strategy_path': strategy_location}).strategy\n", "\n", "# Generate buy/sell signals using strategy\n", - "df = strategy.analyze_ticker(bt_data, {'pair': pair})" + "df = strategy.analyze_ticker(candles, {'pair': pair})\n", + "df.tail()" ] }, { @@ -178,19 +118,14 @@ "metadata": {}, "source": [ "### Display the trade details\n", + "\n", "* Note that using `data.head()` would also work, however most indicators have some \"startup\" data at the top of the dataframe.\n", - "\n", - "#### Some possible problems\n", - "\n", - "* Columns with NaN values at the end of the dataframe\n", - "* Columns used in `crossed*()` functions with completely different units\n", - "\n", - "#### Comparison with full backtest\n", - "\n", - "having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting.\n", - "\n", - "Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple \"buy\" signals for each pair in sequence (until rsi returns > 29).\n", - "The bot will only buy on the first of these signals (and also only if a trade-slot (\"max_open_trades\") is still available), or on one of the middle signals, as soon as a \"slot\" becomes available.\n" + "* Some possible problems\n", + " * Columns with NaN values at the end of the dataframe\n", + " * Columns used in `crossed*()` functions with completely different units\n", + "* Comparison with full backtest\n", + " * having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting.\n", + " * Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple \"buy\" signals for each pair in sequence (until rsi returns > 29). The bot will only buy on the first of these signals (and also only if a trade-slot (\"max_open_trades\") is still available), or on one of the middle signals, as soon as a \"slot\" becomes available. \n" ] }, { @@ -236,6 +171,48 @@ "name": "python", "npconvert_exporter": "python", "pygments_lexer": "ipython3", + "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 + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, "version": 3 }, "nbformat": 4, From 8cc477f3533aeebe1ded157298a415d2fbbcc719 Mon Sep 17 00:00:00 2001 From: Jonathan Raviotta Date: Tue, 20 Aug 2019 00:47:10 -0400 Subject: [PATCH 2/3] edits --- docs/data-analysis.md | 65 ++-- .../notebooks/jupyter_snippets_example.ipynb | 289 ------------------ .../notebooks/strategy_analysis_example.ipynb | 42 ++- 3 files changed, 60 insertions(+), 336 deletions(-) delete mode 100644 user_data/notebooks/jupyter_snippets_example.ipynb diff --git a/docs/data-analysis.md b/docs/data-analysis.md index 8d4cc63c0..4387dd892 100644 --- a/docs/data-analysis.md +++ b/docs/data-analysis.md @@ -5,19 +5,19 @@ You can analyze the results of backtests and trading history easily using Jupyte ## Pro tips * See [jupyter.org](https://jupyter.org/documentation) for usage instructions. -* Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)* -* Copy the example notebook so your changes don't get clobbered with the next freqtrade update. +* Don't forget to start a Jupyter notebook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)* +* Copy the example notebook before use so your changes don't get clobbered with the next freqtrade update. ## Fine print -Some tasks don't work especially well in notebooks. For example, anything using asyncronous exectution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required parameters to functions. +Some tasks don't work especially well in notebooks. For example, anything using asynchronous execution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required objects and parameters to helper functions. You may need to set those values or create expected objects manually. ## Recommended workflow | Task | Tool | --- | --- Bot operations | CLI -Repetative tasks | shell scripts +Repetitive tasks | Shell scripts Data analysis & visualization | Notebook 1. Use the CLI to @@ -28,26 +28,26 @@ Data analysis & visualization | Notebook 1. Collect these actions in shell scripts * save complicated commands with arguments - * execute mult-step operations - * automate testing strategies and prepareing data for analysis + * execute multi-step operations + * automate testing strategies and preparing data for analysis 1. Use a notebook to - * import data + * visualize data * munge and plot to generate insights -## Example utility snippets for Jupyter notebooks +## Example utility snippets ### Change directory to root -Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistant. +Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistent. ```python -# Change directory -# Modify this cell to insure that the output shows the correct path. -# Define all paths relative to the project root shown in the cell output import os from pathlib import Path +# Change directory +# Modify this cell to insure that the output shows the correct path. +# Define all paths relative to the project root shown in the cell output project_root = "somedir/freqtrade" i=0 try: @@ -61,25 +61,16 @@ except: print(Path.cwd()) ``` -### Watch project for changes to code - -This scans the project for changes to code before Jupyter runs cells. - -```python -# Reloads local code changes -%load_ext autoreload -%autoreload 2 -``` - ## Load existing objects into a Jupyter notebook -These examples assume that you have already generated data using the cli. These examples will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload. +These examples assume that you have already generated data using the cli. They will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload. ### Load backtest results into a pandas dataframe ```python -# Load backtest results from freqtrade.data.btanalysis import load_backtest_data + +# Load backtest results df = load_backtest_data("user_data/backtest_data/backtest-result.json") # Show value-counts per pair @@ -89,8 +80,9 @@ df.groupby("pair")["sell_reason"].value_counts() ### Load live trading results into a pandas dataframe ``` python -# Fetch trades from database from freqtrade.data.btanalysis import load_trades_from_db + +# Fetch trades from database df = load_trades_from_db("sqlite:///tradesv3.sqlite") # Display results @@ -102,12 +94,13 @@ df.groupby("pair")["sell_reason"].value_counts() This option can be useful to inspect the results of passing in multiple configs ``` python -# Load config from multiple files +import json from freqtrade.configuration import Configuration + +# Load config from multiple files config = Configuration.from_files(["config1.json", "config2.json"]) # Show the config in memory -import json print(json.dumps(config, indent=1)) ``` @@ -116,10 +109,10 @@ print(json.dumps(config, indent=1)) This loads candle data to a dataframe ```python -# Load data using values passed to function from pathlib import Path from freqtrade.data.history import load_pair_history +# Load data using values passed to function ticker_interval = "5m" data_location = Path('user_data', 'data', 'bitrex') pair = "BTC_USDT" @@ -128,8 +121,8 @@ candles = load_pair_history(datadir=data_location, pair=pair) # Confirm success -print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}") -display(candles.head()) +print(f"Loaded len(candles) rows of data for {pair} from {data_location}") +candles.head() ``` ## Strategy debugging example @@ -160,17 +153,17 @@ pair = "BTC_USDT" ### Load exchange data ```python -# Load data using values set above from pathlib import Path from freqtrade.data.history import load_pair_history +# Load data using values set above candles = load_pair_history(datadir=data_location, ticker_interval=ticker_interval, pair=pair) # Confirm success -print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}") -display(candles.head()) +print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}") +candles.head() ``` ### Load and run strategy @@ -178,8 +171,9 @@ display(candles.head()) * Rerun each time the strategy file is changed ```python -# Load strategy using values set above from freqtrade.resolvers import StrategyResolver + +# Load strategy using values set above strategy = StrategyResolver({'strategy': strategy_name, 'user_data_dir': user_data_dir, 'strategy_path': strategy_location}).strategy @@ -190,7 +184,7 @@ df = strategy.analyze_ticker(candles, {'pair': pair}) ### Display the trade details -* Note that using `data.head()` would also work, however most indicators have some "startup" data at the top of the dataframe. +* Note that using `data.tail()` is preferable to `data.head()` as most indicators have some "startup" data at the top of the dataframe. * Some possible problems * Columns with NaN values at the end of the dataframe * Columns used in `crossed*()` functions with completely different units @@ -199,7 +193,6 @@ df = strategy.analyze_ticker(candles, {'pair': pair}) * Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple "buy" signals for each pair in sequence (until rsi returns > 29). The bot will only buy on the first of these signals (and also only if a trade-slot ("max_open_trades") is still available), or on one of the middle signals, as soon as a "slot" becomes available. ```python - # Report results print(f"Generated {df['buy'].sum()} buy signals") data = df.set_index('date', drop=True) diff --git a/user_data/notebooks/jupyter_snippets_example.ipynb b/user_data/notebooks/jupyter_snippets_example.ipynb deleted file mode 100644 index 9d4ae467a..000000000 --- a/user_data/notebooks/jupyter_snippets_example.ipynb +++ /dev/null @@ -1,289 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Analyzing bot data with Jupyter notebooks \n", - "\n", - "You can analyze the results of backtests and trading history easily using Jupyter notebooks. A sample notebook is located at `user_data/notebooks/analysis_example.ipynb`. \n", - "\n", - "## Pro tips \n", - "\n", - "* See [jupyter.org](https://jupyter.org/documentation) for usage instructions.\n", - "* Don't forget to start a jupyter notbook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)*\n", - "* Copy the example notebook so your changes don't get clobbered with the next freqtrade update.\n", - "\n", - "## Fine print \n", - "\n", - "Some tasks don't work especially well in notebooks. For example, anything using asyncronous exectution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required parameters to functions.\n", - "\n", - "## Recommended workflow \n", - "\n", - "| Task | Tool | \n", - " --- | --- \n", - "Bot operations | CLI \n", - "Repetative tasks | shell scripts\n", - "Data analysis & visualization | Notebook \n", - "\n", - "1. Use the CLI to\n", - " * download historical data\n", - " * run a backtest\n", - " * run with real-time data\n", - " * export results \n", - "\n", - "1. Collect these actions in shell scripts\n", - " * save complicated commands with arguments\n", - " * execute mult-step operations \n", - " * automate testing strategies and prepareing data for analysis\n", - "\n", - "1. Use a notebook to\n", - " * import data\n", - " * munge and plot to generate insights" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example utility snippets for Jupyter notebooks" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Change directory to root \n", - "\n", - "Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistant." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Change directory\n", - "# Modify this cell to insure that the output shows the correct path.\n", - "# Define all paths relative to the project root shown in the cell output\n", - "import os\n", - "from pathlib import Path\n", - "\n", - "project_root = \"somedir/freqtrade\"\n", - "i=0\n", - "try:\n", - " os.chdirdir(project_root)\n", - " assert Path('LICENSE').is_file()\n", - "except:\n", - " while i<4 and (not Path('LICENSE').is_file()):\n", - " os.chdir(Path(Path.cwd(), '../'))\n", - " i+=1\n", - " project_root = Path.cwd()\n", - "print(Path.cwd())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Watch project for changes to code\n", - "This scans the project for changes to code before Jupyter runs cells." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Reloads local code changes\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load existing objects into a Jupyter notebook\n", - "\n", - "These examples assume that you have already generated data using the cli. These examples will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load backtest results into a pandas dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Load backtest results\n", - "from freqtrade.data.btanalysis import load_backtest_data\n", - "df = load_backtest_data(\"user_data/backtest_data/backtest-result.json\")\n", - "\n", - "# Show value-counts per pair\n", - "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load live trading results into a pandas dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Fetch trades from database\n", - "from freqtrade.data.btanalysis import load_trades_from_db\n", - "df = load_trades_from_db(\"sqlite:///tradesv3.sqlite\")\n", - "\n", - "# Display results\n", - "df.groupby(\"pair\")[\"sell_reason\"].value_counts()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load multiple configuration files\n", - "This option can be useful to inspect the results of passing in multiple configs" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Load config from multiple files\n", - "from freqtrade.configuration import Configuration\n", - "config = Configuration.from_files([\"config1.json\", \"config2.json\"])\n", - "\n", - "# Show the config in memory\n", - "import json\n", - "print(json.dumps(config, indent=1))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load exchange data to a pandas dataframe\n", - "\n", - "This loads candle data to a dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# Load data using values passed to function\n", - "from pathlib import Path\n", - "from freqtrade.data.history import load_pair_history\n", - "\n", - "ticker_interval = \"5m\"\n", - "data_location = Path('user_data', 'data', 'bitrex')\n", - "pair = \"BTC_USDT\"\n", - "candles = load_pair_history(datadir=data_location,\n", - " ticker_interval=ticker_interval,\n", - " pair=pair)\n", - "\n", - "# Confirm success\n", - "print(\"Loaded \" + str(len(candles)) + f\" rows of data for {pair} from {data_location}\")\n", - "display(candles.head())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data." - ] - } - ], - "metadata": { - "file_extension": ".py", - "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.3" - }, - "mimetype": "text/x-python", - "name": "python", - "npconvert_exporter": "python", - "pygments_lexer": "ipython3", - "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 - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - }, - "version": 3 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/user_data/notebooks/strategy_analysis_example.ipynb b/user_data/notebooks/strategy_analysis_example.ipynb index 2b8b74fe6..bb35d3e91 100644 --- a/user_data/notebooks/strategy_analysis_example.ipynb +++ b/user_data/notebooks/strategy_analysis_example.ipynb @@ -24,10 +24,10 @@ "source": [ "# Change directory\n", "# Modify this cell to insure that the output shows the correct path.\n", - "# Define all paths relative to the project root shown in the cell output\n", "import os\n", "from pathlib import Path\n", "\n", + "# Define all paths relative to the project root shown in the cell output\n", "project_root = \"somedir/freqtrade\"\n", "i=0\n", "try:\n", @@ -38,11 +38,7 @@ " os.chdir(Path(Path.cwd(), '../'))\n", " i+=1\n", " project_root = Path.cwd()\n", - "print(Path.cwd())\n", - "\n", - "# Reloads local code changes\n", - "%load_ext autoreload\n", - "%autoreload 2" + "print(Path.cwd())" ] }, { @@ -69,9 +65,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'freqtrade'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Load data using values set above\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpathlib\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mPath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfreqtrade\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistory\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mload_pair_history\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m candles = load_pair_history(datadir=data_location,\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'freqtrade'" + ] + } + ], "source": [ "# Load data using values set above\n", "from pathlib import Path\n", @@ -83,7 +91,7 @@ "\n", "# Confirm success\n", "print(\"Loaded \" + str(len(candles)) + f\" rows of data for {pair} from {data_location}\")\n", - "display(candles.head())" + "candles.head()" ] }, { @@ -96,11 +104,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'freqtrade'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Load strategy using values set above\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfreqtrade\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresolvers\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStrategyResolver\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m strategy = StrategyResolver({'strategy': strategy_name,\n\u001b[1;32m 4\u001b[0m \u001b[0;34m'user_data_dir'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0muser_data_dir\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m 'strategy_path': strategy_location}).strategy\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'freqtrade'" + ] + } + ], "source": [ "# Load strategy using values set above\n", "from freqtrade.resolvers import StrategyResolver\n", From 0e81d7204c763ecea58378b727aa678f916902bc Mon Sep 17 00:00:00 2001 From: Matthias Date: Thu, 22 Aug 2019 15:43:39 +0200 Subject: [PATCH 3/3] Clense jupyter notebook --- .../notebooks/strategy_analysis_example.ipynb | 32 +++---------------- 1 file changed, 4 insertions(+), 28 deletions(-) diff --git a/user_data/notebooks/strategy_analysis_example.ipynb b/user_data/notebooks/strategy_analysis_example.ipynb index bb35d3e91..014f4ca90 100644 --- a/user_data/notebooks/strategy_analysis_example.ipynb +++ b/user_data/notebooks/strategy_analysis_example.ipynb @@ -65,21 +65,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'freqtrade'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Load data using values set above\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpathlib\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mPath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfreqtrade\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistory\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mload_pair_history\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m candles = load_pair_history(datadir=data_location,\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'freqtrade'" - ] - } - ], + "outputs": [], "source": [ "# Load data using values set above\n", "from pathlib import Path\n", @@ -104,23 +92,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'freqtrade'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Load strategy using values set above\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfreqtrade\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresolvers\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStrategyResolver\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m strategy = StrategyResolver({'strategy': strategy_name,\n\u001b[1;32m 4\u001b[0m \u001b[0;34m'user_data_dir'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0muser_data_dir\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m 'strategy_path': strategy_location}).strategy\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'freqtrade'" - ] - } - ], + "outputs": [], "source": [ "# Load strategy using values set above\n", "from freqtrade.resolvers import StrategyResolver\n",