freqtrade_origin/docs/strategy_analysis_example.md

282 lines
8.1 KiB
Markdown
Raw Permalink Normal View History

2019-09-21 08:41:58 +00:00
# Strategy analysis example
2020-02-13 05:30:59 +00:00
Debugging a strategy can be time-consuming. Freqtrade offers helper functions to visualize raw data.
2020-02-14 19:12:26 +00:00
The following assumes you work with SampleStrategy, data for 5m timeframe from Binance and have downloaded them into the data directory in the default location.
2022-12-05 17:14:16 +00:00
Please follow the [documentation](https://www.freqtrade.io/en/stable/data-download/) for more details.
## Setup
2022-12-05 17:14:16 +00:00
### Change Working directory to repository root
```python
2022-12-05 17:14:16 +00:00
import os
2019-09-21 08:41:58 +00:00
from pathlib import Path
2022-12-05 17:14:16 +00:00
2024-08-19 16:23:36 +00:00
2022-12-05 17:14:16 +00:00
# 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"
2024-08-19 17:59:15 +00:00
i = 0
2022-12-05 17:14:16 +00:00
try:
os.chdir(project_root)
2024-08-19 17:59:15 +00:00
if not Path("LICENSE").is_file():
2024-08-19 16:23:36 +00:00
i = 0
2024-08-19 17:59:15 +00:00
while i < 4 and (not Path("LICENSE").is_file()):
os.chdir(Path(Path.cwd(), "../"))
2024-08-19 16:23:36 +00:00
i += 1
project_root = Path.cwd()
except FileNotFoundError:
print("Please define the project root relative to the current directory")
2022-12-05 17:14:16 +00:00
print(Path.cwd())
```
### Configure Freqtrade environment
```python
from freqtrade.configuration import Configuration
2024-08-19 16:23:36 +00:00
# Customize these according to your needs.
# Initialize empty configuration object
config = Configuration.from_files([])
# Optionally (recommended), use existing configuration file
2022-12-05 17:14:16 +00:00
# config = Configuration.from_files(["user_data/config.json"])
# Define some constants
config["timeframe"] = "5m"
# Name of the strategy class
config["strategy"] = "SampleStrategy"
2020-02-12 20:43:43 +00:00
# Location of the data
2022-12-05 17:14:16 +00:00
data_location = config["datadir"]
# Pair to analyze - Only use one pair here
pair = "BTC/USDT"
```
```python
# Load data using values set above
from freqtrade.data.history import load_pair_history
from freqtrade.enums import CandleType
2024-08-19 16:23:36 +00:00
2024-08-19 17:59:15 +00:00
candles = load_pair_history(
datadir=data_location,
timeframe=config["timeframe"],
pair=pair,
data_format="json", # Make sure to update this to your data
candle_type=CandleType.SPOT,
)
# Confirm success
2022-12-05 17:14:16 +00:00
print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}")
candles.head()
```
## Load and run strategy
* Rerun each time the strategy file is changed
```python
# Load strategy using values set above
from freqtrade.data.dataprovider import DataProvider
2024-08-19 16:23:36 +00:00
from freqtrade.resolvers import StrategyResolver
strategy = StrategyResolver.load_strategy(config)
strategy.dp = DataProvider(config, None, None)
strategy.ft_bot_start()
# Generate buy/sell signals using strategy
2024-08-19 17:59:15 +00:00
df = strategy.analyze_ticker(candles, {"pair": pair})
df.tail()
```
### 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.
```python
# Report results
2022-03-05 14:05:03 +00:00
print(f"Generated {df['enter_long'].sum()} entry signals")
2024-08-19 17:59:15 +00:00
data = df.set_index("date", drop=False)
data.tail()
```
## Load existing objects into a Jupyter notebook
The following cells 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 to pandas dataframe
Analyze a trades dataframe (also used below for plotting)
```python
from freqtrade.data.btanalysis import load_backtest_data, load_backtest_stats
2024-08-19 16:23:36 +00:00
# if backtest_dir points to a directory, it'll automatically load the last backtest file.
backtest_dir = config["user_data_dir"] / "backtest_results"
2024-08-19 16:23:36 +00:00
# backtest_dir can also point to a specific file
# backtest_dir = (
# config["user_data_dir"] / "backtest_results/backtest-result-2020-07-01_20-04-22.json"
# )
```
```python
# You can get the full backtest statistics by using the following command.
# This contains all information used to generate the backtest result.
stats = load_backtest_stats(backtest_dir)
2024-08-19 17:59:15 +00:00
strategy = "SampleStrategy"
2024-08-19 16:23:36 +00:00
# All statistics are available per strategy, so if `--strategy-list` was used during backtest,
# this will be reflected here as well.
# Example usages:
2024-08-19 17:59:15 +00:00
print(stats["strategy"][strategy]["results_per_pair"])
# Get pairlist used for this backtest
2024-08-19 17:59:15 +00:00
print(stats["strategy"][strategy]["pairlist"])
# Get market change (average change of all pairs from start to end of the backtest period)
2024-08-19 17:59:15 +00:00
print(stats["strategy"][strategy]["market_change"])
# Maximum drawdown ()
2024-08-19 17:59:15 +00:00
print(stats["strategy"][strategy]["max_drawdown"])
# Maximum drawdown start and end
2024-08-19 17:59:15 +00:00
print(stats["strategy"][strategy]["drawdown_start"])
print(stats["strategy"][strategy]["drawdown_end"])
# Get strategy comparison (only relevant if multiple strategies were compared)
2024-08-19 17:59:15 +00:00
print(stats["strategy_comparison"])
```
```python
# Load backtested trades as dataframe
trades = load_backtest_data(backtest_dir)
# Show value-counts per pair
trades.groupby("pair")["exit_reason"].value_counts()
```
## Plotting daily profit / equity line
```python
# Plotting equity line (starting with 0 on day 1 and adding daily profit for each backtested day)
2024-08-19 16:23:36 +00:00
import pandas as pd
import plotly.express as px
from freqtrade.configuration import Configuration
from freqtrade.data.btanalysis import load_backtest_stats
2024-08-19 16:23:36 +00:00
# strategy = 'SampleStrategy'
# config = Configuration.from_files(["user_data/config.json"])
# backtest_dir = config["user_data_dir"] / "backtest_results"
stats = load_backtest_stats(backtest_dir)
2024-08-19 17:59:15 +00:00
strategy_stats = stats["strategy"][strategy]
2024-08-19 17:59:15 +00:00
df = pd.DataFrame(columns=["dates", "equity"], data=strategy_stats["daily_profit"])
df["equity_daily"] = df["equity"].cumsum()
fig = px.line(df, x="dates", y="equity_daily")
fig.show()
```
### Load live trading results into a pandas dataframe
In case you did already some trading and want to analyze your performance
```python
from freqtrade.data.btanalysis import load_trades_from_db
2024-08-19 16:23:36 +00:00
# Fetch trades from database
trades = load_trades_from_db("sqlite:///tradesv3.sqlite")
# Display results
2022-04-03 08:41:35 +00:00
trades.groupby("pair")["exit_reason"].value_counts()
```
## Analyze the loaded trades for trade parallelism
This can be useful to find the best `max_open_trades` parameter, when used with backtesting in conjunction with `--disable-max-market-positions`.
2019-10-30 18:30:35 +00:00
`analyze_trade_parallelism()` returns a timeseries dataframe with an "open_trades" column, specifying the number of open trades for each candle.
```python
2019-10-30 18:30:35 +00:00
from freqtrade.data.btanalysis import analyze_trade_parallelism
2024-08-19 16:23:36 +00:00
# Analyze the above
2024-08-19 17:59:15 +00:00
parallel_trades = analyze_trade_parallelism(trades, "5m")
parallel_trades.plot()
```
## Plot results
Freqtrade offers interactive plotting capabilities based on plotly.
```python
2024-08-19 16:23:36 +00:00
from freqtrade.plot.plotting import generate_candlestick_graph
# Limit graph period to keep plotly quick and reactive
# Filter trades to one pair
2024-08-19 17:59:15 +00:00
trades_red = trades.loc[trades["pair"] == pair]
2024-08-19 17:59:15 +00:00
data_red = data["2019-06-01":"2019-06-10"]
# Generate candlestick graph
2024-08-19 17:59:15 +00:00
graph = generate_candlestick_graph(
pair=pair,
data=data_red,
trades=trades_red,
indicators1=["sma20", "ema50", "ema55"],
indicators2=["rsi", "macd", "macdsignal", "macdhist"],
)
```
```python
# Show graph inline
# graph.show()
# Render graph in a separate window
graph.show(renderer="browser")
```
## Plot average profit per trade as distribution graph
```python
import plotly.figure_factory as ff
2024-08-19 16:23:36 +00:00
hist_data = [trades.profit_ratio]
2024-08-19 17:59:15 +00:00
group_labels = ["profit_ratio"] # name of the dataset
2022-03-05 14:05:03 +00:00
fig = ff.create_distplot(hist_data, group_labels, bin_size=0.01)
fig.show()
```
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.