adelorenzo/stable
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2155 from jraviotta/analysis

Browse Source 
split example notebooks
This commit is contained in:
Matthias 2019-08-22 15:54:08 +02:00 committed by GitHub
commit ad6de07d2b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 212 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.gitignore vendored
View File

@ -6,7 +6,10 @@ config*.json
.hyperopt .hyperopt
logfile.txt logfile.txt
hyperopt_trials.pickle hyperopt_trials.pickle
user_data/ user_data/*
!user_data/notebooks
user_data/notebooks/*
!user_data/notebooks/*example.ipynb
freqtrade-plot.html freqtrade-plot.html
freqtrade-profit-plot.html freqtrade-profit-plot.html
@ -80,7 +83,7 @@ docs/_build/
target/ target/
# Jupyter Notebook # Jupyter Notebook
.ipynb_checkpoints *.ipynb_checkpoints
# pyenv # pyenv
.python-version .python-version
@ -94,4 +97,4 @@ target/
.mypy_cache/ .mypy_cache/
#exceptions #exceptions
!user_data/noteboks/*example.ipynb !*.gitkeep

148
docs/data-analysis.md
View File

@ -1,15 +1,75 @@
# 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 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 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
Repetitive 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 multi-step operations
* automate testing strategies and preparing data for analysis
1. Use a notebook to
* visualize data
* munge and plot to generate insights
## 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 consistent.
```python
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:
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())
```
## Load existing objects into a Jupyter notebook
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 ### Load backtest results into a pandas dataframe
```python ```python
from freqtrade.data.btanalysis import load_backtest_data from freqtrade.data.btanalysis import load_backtest_data
# Load backtest results # Load backtest results
df = load_backtest_data("user_data/backtest_results/backtest-result.json") df = load_backtest_data("user_data/backtest_results/backtest-result.json")
@ -17,8 +77,6 @@ df = load_backtest_data("user_data/backtest_results/backtest-result.json")
df.groupby("pair")["sell_reason"].value_counts() 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 ### Load live trading results into a pandas dataframe
``` python ``` python
@ -33,55 +91,79 @@ df.groupby("pair")["sell_reason"].value_counts()
### Load multiple configuration files ### 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 ``` python
import json
from freqtrade.configuration import Configuration from freqtrade.configuration import Configuration
# Load config from multiple files
config = Configuration.from_files(["config1.json", "config2.json"]) config = Configuration.from_files(["config1.json", "config2.json"])
print(config)
# Show the config in memory
print(json.dumps(config, indent=1))
```
### Load exchange data to a pandas dataframe
This loads candle data to a dataframe
```python
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"
candles = load_pair_history(datadir=data_location,
ticker_interval=ticker_interval,
pair=pair)
# Confirm success
print(f"Loaded len(candles) rows of data for {pair} from {data_location}")
candles.head()
``` ```
## Strategy debugging example ## Strategy debugging example
Debugging a strategy can be time-consuming. FreqTrade offers helper functions to visualize raw data. 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 ```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. # Customize these according to your needs.
# Define some constants # Define some constants
ticker_interval = "5m" ticker_interval = "5m"
# Name of the strategy class # Name of the strategy class
strategy_name = 'AwesomeStrategy' strategy_name = 'TestStrategy'
# Path to user data # Path to user data
user_data_dir = 'user_data' user_data_dir = 'user_data'
# Location of the strategy # Location of the strategy
strategy_location = Path(user_data_dir, 'strategies') strategy_location = Path(user_data_dir, 'strategies')
# Location of the data # Location of the data
data_location = Path(user_data_dir, 'data', 'binance') data_location = Path(user_data_dir, 'data', 'binance')
# Pair to analyze # Pair to analyze - Only use one pair here
# Only use one pair here
pair = "BTC_USDT" pair = "BTC_USDT"
``` ```
### Load exchange data ### Load exchange data
```python ```python
from pathlib import Path
from freqtrade.data.history import load_pair_history
# Load data using values set above # Load data using values set above
bt_data = load_pair_history(datadir=Path(data_location), candles = load_pair_history(datadir=data_location,
ticker_interval=ticker_interval, ticker_interval=ticker_interval,
pair=pair) pair=pair)
# Confirm success # Confirm success
print(f"Loaded {len(bt_data)} rows of data for {pair} from {data_location}") print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}")
candles.head()
``` ```
### Load and run strategy ### Load and run strategy
@ -89,30 +171,26 @@ print(f"Loaded {len(bt_data)} rows of data for {pair} from {data_location}")
* Rerun each time the strategy file is changed * Rerun each time the strategy file is changed
```python ```python
from freqtrade.resolvers import StrategyResolver
# Load strategy using values set above # Load strategy using values set above
strategy = StrategyResolver({'strategy': strategy_name, strategy = StrategyResolver({'strategy': strategy_name,
'user_data_dir': user_data_dir, 'user_data_dir': user_data_dir,
'strategy_path': strategy_location}).strategy 'strategy_path': strategy_location}).strategy
# Generate buy/sell signals using 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 ### 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
#### Some possible problems * Columns with NaN values at the end of the dataframe
* Columns used in `crossed*()` functions with completely different units
* Columns with NaN values at the end of the dataframe * Comparison with full backtest
* Columns used in `crossed*()` functions with completely different units * 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.
#### 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 ```python
# Report results # Report results

211
user_data/notebooks/analysis_example.ipynb → user_data/notebooks/strategy_analysis_example.ipynb
View File

@ -1,96 +1,5 @@
{ {
"cells": [ "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", "cell_type": "markdown",
"metadata": {}, "metadata": {},
@ -104,7 +13,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"### Import requirements and define variables used in analyses" "## Setup"
] ]
}, },
{ {
@ -113,28 +22,47 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"# Change directory\n",
"# Modify this cell to insure that the output shows the correct path.\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",
" 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": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Customize these according to your needs.\n",
"\n",
"# Define some constants\n", "# Define some constants\n",
"ticker_interval = \"5m\"\n", "ticker_interval = \"5m\"\n",
"# Name of the strategy class\n", "# Name of the strategy class\n",
"strategy_name = 'AwesomeStrategy'\n", "strategy_name = 'TestStrategy'\n",
"# Path to user data\n", "# Path to user data\n",
"user_data_dir = 'user_data'\n", "user_data_dir = 'user_data'\n",
"# Location of the strategy\n", "# Location of the strategy\n",
"strategy_location = Path(user_data_dir, 'strategies')\n", "strategy_location = Path(user_data_dir, 'strategies')\n",
"# Location of the data\n", "# Location of the data\n",
"data_location = Path(user_data_dir, 'data', 'binance')\n", "data_location = Path(user_data_dir, 'data', 'binance')\n",
"# Pair to analyze \n", "# Pair to analyze - Only use one pair here\n",
"# Only use one pair here\n",
"pair = \"BTC_USDT\"" "pair = \"BTC_USDT\""
] ]
}, },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Load exchange data"
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
@ -142,35 +70,43 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"# Load data using values set above\n", "# 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", " ticker_interval=ticker_interval,\n",
" pair=pair)\n", " pair=pair)\n",
"\n", "\n",
"# Confirm success\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",
"candles.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"### Load and run strategy\n", "## Load and run strategy\n",
"* Rerun each time the strategy file is changed" "* Rerun each time the strategy file is changed"
] ]
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": {}, "metadata": {
"scrolled": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# Load strategy using values set above\n", "# Load strategy using values set above\n",
"from freqtrade.resolvers import StrategyResolver\n",
"strategy = StrategyResolver({'strategy': strategy_name,\n", "strategy = StrategyResolver({'strategy': strategy_name,\n",
" 'user_data_dir': user_data_dir,\n", " 'user_data_dir': user_data_dir,\n",
" 'strategy_path': strategy_location}).strategy\n", " 'strategy_path': strategy_location}).strategy\n",
"\n", "\n",
"# Generate buy/sell signals using strategy\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 +114,14 @@
"metadata": {}, "metadata": {},
"source": [ "source": [
"### Display the trade details\n", "### 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", "* 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",
"#### Some possible problems\n", " * Columns with NaN values at the end of the dataframe\n",
"\n", " * Columns used in `crossed*()` functions with completely different units\n",
"* Columns with NaN values at the end of the dataframe\n", "* Comparison with full backtest\n",
"* Columns used in `crossed*()` functions with completely different units\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). 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"
"#### 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"
] ]
}, },
{ {
@ -236,6 +167,48 @@
"name": "python", "name": "python",
"npconvert_exporter": "python", "npconvert_exporter": "python",
"pygments_lexer": "ipython3", "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 "version": 3
}, },
"nbformat": 4, "nbformat": 4,