stable/freqtrade/optimize/backtesting.py

170 lines
6.3 KiB
Python
Raw Normal View History

# pragma pylint: disable=missing-docstring,W0212
2017-11-14 21:15:24 +00:00
2017-11-17 16:54:31 +00:00
import logging
2017-11-14 21:15:24 +00:00
from typing import Tuple, Dict
2017-09-28 21:26:28 +00:00
import arrow
from pandas import DataFrame
from tabulate import tabulate
2017-09-28 21:26:28 +00:00
from freqtrade import exchange
from freqtrade.analyze import populate_buy_trend, populate_sell_trend
from freqtrade.exchange import Bittrex
2017-11-16 05:49:06 +00:00
from freqtrade.main import min_roi_reached
2017-11-17 16:54:31 +00:00
from freqtrade.misc import load_config
from freqtrade.optimize import load_data, preprocess
2017-09-28 21:26:28 +00:00
from freqtrade.persistence import Trade
logger = logging.getLogger(__name__)
2017-11-17 16:54:31 +00:00
def get_timeframe(data: Dict[str, Dict]) -> Tuple[arrow.Arrow, arrow.Arrow]:
"""
Get the maximum timeframe for the given backtest data
:param data: dictionary with backtesting data
:return: tuple containing min_date, max_date
"""
2017-11-14 21:15:24 +00:00
min_date, max_date = None, None
for values in data.values():
sorted_values = sorted(values, key=lambda d: arrow.get(d['T']))
if not min_date or sorted_values[0]['T'] < min_date:
min_date = sorted_values[0]['T']
if not max_date or sorted_values[-1]['T'] > max_date:
max_date = sorted_values[-1]['T']
2017-11-14 21:15:24 +00:00
return arrow.get(min_date), arrow.get(max_date)
2017-12-16 02:39:47 +00:00
def generate_text_table(
data: Dict[str, Dict], results: DataFrame, stake_currency, ticker_interval) -> str:
"""
Generates and returns a text table for the given backtest data and the results dataframe
:return: pretty printed table with tabulate as str
"""
tabular_data = []
headers = ['pair', 'buy count', 'avg profit', 'total profit', 'avg duration']
for pair in data:
result = results[results.currency == pair]
tabular_data.append([
pair,
len(result.index),
'{:.2f}%'.format(result.profit.mean() * 100.0),
2017-11-14 22:46:48 +00:00
'{:.08f} {}'.format(result.profit.sum(), stake_currency),
'{:.2f}'.format(result.duration.mean() * ticker_interval),
])
# Append Total
tabular_data.append([
'TOTAL',
len(results.index),
'{:.2f}%'.format(results.profit.mean() * 100.0),
2017-11-14 22:46:48 +00:00
'{:.08f} {}'.format(results.profit.sum(), stake_currency),
'{:.2f}'.format(results.duration.mean() * ticker_interval),
])
return tabulate(tabular_data, headers=headers)
def backtest(config: Dict, processed: Dict[str, DataFrame],
max_open_trades: int = 0, realistic: bool = True) -> DataFrame:
2017-11-22 23:25:06 +00:00
"""
Implements backtesting functionality
:param config: config to use
:param processed: a processed dictionary with format {pair, data}
:param max_open_trades: maximum number of concurrent trades (default: 0, disabled)
:param realistic: do we try to simulate realistic trades? (default: True)
2017-11-22 23:25:06 +00:00
:return: DataFrame
"""
trades = []
trade_count_lock = {}
exchange._API = Bittrex({'key': '', 'secret': ''})
for pair, pair_data in processed.items():
pair_data['buy'], pair_data['sell'] = 0, 0
ticker = populate_sell_trend(populate_buy_trend(pair_data))
# for each buy point
lock_pair_until = None
for row in ticker[ticker.buy == 1].itertuples(index=True):
if realistic:
if lock_pair_until is not None and row.Index <= lock_pair_until:
continue
2017-11-22 23:25:06 +00:00
if max_open_trades > 0:
# Check if max_open_trades has already been reached for the given date
if not trade_count_lock.get(row.date, 0) < max_open_trades:
continue
if max_open_trades > 0:
# Increase lock
trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
trade = Trade(
open_rate=row.close,
open_date=row.date,
2017-11-22 23:25:06 +00:00
amount=config['stake_amount'],
fee=exchange.get_fee() * 2
)
# calculate win/lose forwards from buy point
for row2 in ticker[row.Index + 1:].itertuples(index=True):
2017-11-22 23:25:06 +00:00
if max_open_trades > 0:
# Increase trade_count_lock for every iteration
trade_count_lock[row2.date] = trade_count_lock.get(row2.date, 0) + 1
2017-11-16 05:49:06 +00:00
if min_roi_reached(trade, row2.close, row2.date) or row2.sell == 1:
current_profit = trade.calc_profit(row2.close)
lock_pair_until = row2.Index
trades.append((pair, current_profit, row2.Index - row.Index))
break
labels = ['currency', 'profit', 'duration']
2017-11-17 06:02:06 +00:00
return DataFrame.from_records(trades, columns=labels)
2017-10-30 23:36:35 +00:00
def start(args):
# Initialize logger
logging.basicConfig(
level=args.loglevel,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
)
2017-11-17 16:54:31 +00:00
exchange._API = Bittrex({'key': '', 'secret': ''})
2017-11-14 21:15:24 +00:00
logger.info('Using config: %s ...', args.config)
config = load_config(args.config)
2017-11-14 21:15:24 +00:00
logger.info('Using ticker_interval: %s ...', args.ticker_interval)
2017-11-14 21:37:30 +00:00
data = {}
pairs = config['exchange']['pair_whitelist']
if args.live:
logger.info('Downloading data for all pairs in whitelist ...')
for pair in pairs:
data[pair] = exchange.get_ticker_history(pair, args.ticker_interval)
else:
logger.info('Using local backtesting data (using whitelist in given config) ...')
data = load_data(pairs=pairs, ticker_interval=args.ticker_interval,
refresh_pairs=args.refresh_pairs)
2017-11-14 21:15:24 +00:00
logger.info('Using stake_currency: %s ...', config['stake_currency'])
logger.info('Using stake_amount: %s ...', config['stake_amount'])
2017-11-14 22:46:48 +00:00
2017-11-17 16:54:31 +00:00
# Print timeframe
2017-11-14 21:15:24 +00:00
min_date, max_date = get_timeframe(data)
logger.info('Measuring data from %s up to %s ...', min_date.isoformat(), max_date.isoformat())
max_open_trades = 0
if args.realistic_simulation:
logger.info('Using max_open_trades: %s ...', config['max_open_trades'])
max_open_trades = config['max_open_trades']
2017-11-25 00:12:44 +00:00
# Monkey patch config
from freqtrade import main
main._CONF = config
2017-11-17 16:54:31 +00:00
# Execute backtest and print results
results = backtest(
config, preprocess(data), max_open_trades, args.realistic_simulation
)
logger.info(
'\n====================== BACKTESTING REPORT ======================================\n%s',
generate_text_table(data, results, config['stake_currency'], args.ticker_interval)
)