Merge pull request #7806 from freqtrade/new_release

New release 2022.11

.devcontainer/devcontainer.json

@@ -11,12 +11,14 @@
     "mounts": [
         "source=freqtrade-bashhistory,target=/home/ftuser/commandhistory,type=volume"
     ],
+    "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/freqtrade,type=bind,consistency=cached",
     // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
     "remoteUser": "ftuser",
 
+    "onCreateCommand": "pip install --user -e .",
     "postCreateCommand": "freqtrade create-userdir --userdir user_data/",
 
-    "workspaceFolder": "/freqtrade/",
+    "workspaceFolder": "/workspaces/freqtrade",
 
     "settings": {
         "terminal.integrated.shell.linux": "/bin/bash",

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-18.04, ubuntu-20.04, ubuntu-22.04 ]
-        python-version: ["3.8", "3.9", "3.10.6"]
+        python-version: ["3.8", "3.9", "3.10"]
 
     steps:
     - uses: actions/checkout@v3
@@ -74,7 +74,7 @@ jobs:
       if: matrix.python-version == '3.9' && matrix.os == 'ubuntu-22.04'
 
     - name: Coveralls
-      if: (runner.os == 'Linux' && matrix.python-version == '3.9')
+      if: (runner.os == 'Linux' && matrix.python-version == '3.10' && matrix.os == 'ubuntu-22.04')
       env:
         # Coveralls token. Not used as secret due to github not providing secrets to forked repositories
         COVERALLS_REPO_TOKEN: 6D1m0xupS3FgutfuGao8keFf9Hc0FpIXu
@@ -121,7 +121,7 @@ jobs:
     strategy:
       matrix:
         os: [ macos-latest ]
-        python-version: ["3.8", "3.9", "3.10.6"]
+        python-version: ["3.8", "3.9", "3.10"]
 
     steps:
     - uses: actions/checkout@v3
@@ -205,7 +205,7 @@ jobs:
     strategy:
       matrix:
         os: [ windows-latest ]
-        python-version: ["3.8", "3.9", "3.10.6"]
+        python-version: ["3.8", "3.9", "3.10"]
 
     steps:
     - uses: actions/checkout@v3
@@ -258,7 +258,7 @@ jobs:
           webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   mypy_version_check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v3
 
@@ -283,7 +283,7 @@ jobs:
     - uses: pre-commit/action@v3.0.0
 
   docs_check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v3
 
@@ -313,7 +313,7 @@ jobs:
   # Notify only once - when CI completes (and after deploy) in case it's successfull
   notify-complete:
     needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check, pre-commit ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     # Discord notification can't handle schedule events
     if: (github.event_name != 'schedule')
     permissions:
@@ -338,7 +338,7 @@ jobs:
 
   deploy:
     needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check, pre-commit ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
 
     if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'
 
@@ -441,4 +441,4 @@ jobs:
       with:
           severity: info
           details: Deploy Succeeded!
-          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}

.github/workflows/draft-pdf.yml

@@ -1,23 +0,0 @@
-on: [push]
-
-jobs:
-  paper:
-    runs-on: ubuntu-latest
-    name: Paper Draft
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Build draft PDF
-        uses: openjournals/openjournals-draft-action@master
-        with:
-          journal: joss
-          # This should be the path to the paper within your repo.
-          paper-path: docs/JOSS_paper/paper.md
-      - name: Upload
-        uses: actions/upload-artifact@v1
-        with:
-          name: paper
-          # This is the output path where Pandoc will write the compiled
-          # PDF. Note, this should be the same directory as the input
-          # paper.md
-          path: docs/JOSS_paper/paper.pdf

.gitignore

@@ -109,8 +109,6 @@ target/
 !*.gitkeep
 !config_examples/config_binance.example.json
 !config_examples/config_bittrex.example.json
-!config_examples/config_ftx.example.json
 !config_examples/config_full.example.json
 !config_examples/config_kraken.example.json
 !config_examples/config_freqai.example.json
-!config_examples/config_freqai-rl.example.json

.pre-commit-config.yaml

@@ -15,9 +15,9 @@ repos:
         additional_dependencies:
           - types-cachetools==5.2.1
           - types-filelock==3.2.7
-          - types-requests==2.28.11
-          - types-tabulate==0.8.11
-          - types-python-dateutil==2.8.19
+          - types-requests==2.28.11.5
+          - types-tabulate==0.9.0.0
+          - types-python-dateutil==2.8.19.4
         # stages: [push]
 
   - repo: https://github.com/pycqa/isort

README.md

@@ -28,7 +28,6 @@ Please read the [exchange specific notes](docs/exchanges.md) to learn about even
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
-- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
 - [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
@@ -39,7 +38,7 @@ Please read the [exchange specific notes](docs/exchanges.md) to learn about even
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
-- [X] [OKX](https://okx.com/).
+- [X] [OKX](https://okx.com/)
 
 Please make sure to read the [exchange specific notes](docs/exchanges.md), as well as the [trading with leverage](docs/leverage.md) documentation before diving in.
 

config_examples/config_binance.example.json

@@ -53,7 +53,7 @@
             "XTZ/BTC"
         ],
         "pair_blacklist": [
-            "BNB/BTC"
+            "BNB/.*"
         ]
     },
     "pairlists": [

config_examples/config_freqai.example.json

@@ -18,13 +18,8 @@
         "name": "binance",
         "key": "",
         "secret": "",
-        "ccxt_config": {
-            "enableRateLimit": true
-        },
-        "ccxt_async_config": {
-            "enableRateLimit": true,
-            "rateLimit": 200
-        },
+        "ccxt_config": {},
+        "ccxt_async_config": {},
         "pair_whitelist": [
             "1INCH/USDT",
             "ALGO/USDT"

config_examples/config_ftx.example.json

@@ -1,96 +0,0 @@
-{
-    "max_open_trades": 3,
-    "stake_currency": "USD",
-    "stake_amount": 50,
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "timeframe": "5m",
-    "dry_run": true,
-    "cancel_open_orders_on_exit": false,
-    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 10,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "ftx",
-        "key": "your_exchange_key",
-        "secret": "your_exchange_secret",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USD",
-            "ETH/USD",
-            "BNB/USD",
-            "USDT/USD",
-            "LTC/USD",
-            "SRM/USD",
-            "SXP/USD",
-            "XRP/USD",
-            "DOGE/USD",
-            "1INCH/USD",
-            "CHZ/USD",
-            "MATIC/USD",
-            "LINK/USD",
-            "OXY/USD",
-            "SUSHI/USD"
-        ],
-        "pair_blacklist": [
-            "FTT/USD"
-        ]
-    },
-    "pairlists": [
-        {"method": "StaticPairList"}
-    ],
-    "edge": {
-        "enabled": false,
-        "process_throttle_secs": 3600,
-        "calculate_since_number_of_days": 7,
-        "allowed_risk": 0.01,
-        "stoploss_range_min": -0.01,
-        "stoploss_range_max": -0.1,
-        "stoploss_range_step": -0.01,
-        "minimum_winrate": 0.60,
-        "minimum_expectancy": 0.20,
-        "min_trade_number": 10,
-        "max_trade_duration_minute": 1440,
-        "remove_pumps": false
-    },
-    "telegram": {
-        "enabled": false,
-        "token": "your_telegram_token",
-        "chat_id": "your_telegram_chat_id"
-    },
-    "api_server": {
-        "enabled": false,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8080,
-        "verbosity": "error",
-        "jwt_secret_key": "somethingrandom",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "SuperSecurePassword"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 5
-    }
-}

config_examples/config_full.example.json

@@ -204,6 +204,7 @@
     "strategy_path": "user_data/strategies/",
     "recursive_strategy_search": false,
     "add_config_files": [],
+    "reduce_df_footprint": false,
     "dataformat_ohlcv": "json",
     "dataformat_trades": "jsongz"
 }

docker/Dockerfile.armhf

@@ -11,7 +11,7 @@ ENV FT_APP_ENV="docker"
 # Prepare environment
 RUN mkdir /freqtrade \
   && apt-get update \
-  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev \
+  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev libutf8proc-dev libsnappy-dev \
   && apt-get clean \
   && useradd -u 1000 -G sudo -U -m ftuser \
   && chown ftuser:ftuser /freqtrade \
@@ -37,6 +37,7 @@ ENV LD_LIBRARY_PATH /usr/local/lib
 COPY --chown=ftuser:ftuser requirements.txt /freqtrade/
 USER ftuser
 RUN  pip install --user --no-cache-dir numpy \
+  && pip install --user /tmp/pyarrow-*.whl \
   && pip install --user --no-cache-dir -r requirements.txt
 
 # Copy dependencies to runtime-image

docs/JOSS_paper/note_to_editors.txt

@@ -1,15 +0,0 @@
-Dear Editors,
-We present a paper for ``FreqAI`` a machine learning sandbox for researchers and citizen scientists alike.
-There are a large number of authors, however all have contributed in a significant way to this paper.
-For clarity the contribution of each author is outlined:
-
-  - Robert Caulk            : Conception and software development
-  - Elin Tornquist          : Theoretical brainstorming, data analysis, tool dev
-  - Matthias Voppichler     : Software architecture and code review
-  - Andrew R. Lawless       : Extensive testing, feature brainstorming
-  - Ryan McMullan           : Extensive testing, feature brainstorming
-  - Wagner Costa Santos     : Major backtesting developments, extensive testing
-  - Pascal Schmidt          : Extensive testing, feature brainstorming
-  - Timothy C. Pogue        : Webhooks forecast sharing
-  - Stefan P. Gehring       : Extensive testing, feature brainstorming
-  - Johan van der Vlugt     : Extensive testing, feature brainstorming

docs/JOSS_paper/paper.bib

@@ -1,207 +0,0 @@
-@article{scikit-learn,
- title={Scikit-learn: Machine Learning in {P}ython},
- author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
-         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
-         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
-         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
- journal={Journal of Machine Learning Research},
- volume={12},
- pages={2825--2830},
- year={2011}
-}
-
-@inproceedings{catboost,
-author = {Prokhorenkova, Liudmila and Gusev, Gleb and Vorobev, Aleksandr and Dorogush, Anna Veronika and Gulin, Andrey},
-title = {CatBoost: Unbiased Boosting with Categorical Features},
-year = {2018},
-publisher = {Curran Associates Inc.},
-address = {Red Hook, NY, USA},
-abstract = {This paper presents the key algorithmic techniques behind CatBoost, a new gradient boosting toolkit. Their combination leads to CatBoost outperforming other publicly available boosting implementations in terms of quality on a variety of datasets. Two critical algorithmic advances introduced in CatBoost are the implementation of ordered boosting, a permutation-driven alternative to the classic algorithm, and an innovative algorithm for processing categorical features. Both techniques were created to fight a prediction shift caused by a special kind of target leakage present in all currently existing implementations of gradient boosting algorithms. In this paper, we provide a detailed analysis of this problem and demonstrate that proposed algorithms solve it effectively, leading to excellent empirical results.},
-booktitle = {Proceedings of the 32nd International Conference on Neural Information Processing Systems},
-pages = {6639–6649},
-numpages = {11},
-location = {Montr\'{e}al, Canada},
-series = {NIPS'18}
-}
-
-
-@article{lightgbm,
-  title={Lightgbm: A highly efficient gradient boosting decision tree},
-  author={Ke, Guolin and Meng, Qi and Finley, Thomas and Wang, Taifeng and Chen, Wei and Ma, Weidong and Ye, Qiwei and Liu, Tie-Yan},
-  journal={Advances in neural information processing systems},
-  volume={30},
-  pages={3146--3154},
-  year={2017}
-} 
-
-@inproceedings{xgboost,
- author = {Chen, Tianqi and Guestrin, Carlos},
- title = {{XGBoost}: A Scalable Tree Boosting System},
- booktitle = {Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining},
- series = {KDD '16},
- year = {2016},
- isbn = {978-1-4503-4232-2},
- location = {San Francisco, California, USA},
- pages = {785--794},
- numpages = {10},
- url = {http://doi.acm.org/10.1145/2939672.2939785},
- doi = {10.1145/2939672.2939785},
- acmid = {2939785},
- publisher = {ACM},
- address = {New York, NY, USA},
- keywords = {large-scale machine learning},
-}
-
-@article{stable-baselines3,
-  author  = {Antonin Raffin and Ashley Hill and Adam Gleave and Anssi Kanervisto and Maximilian Ernestus and Noah Dormann},
-  title   = {Stable-Baselines3: Reliable Reinforcement Learning Implementations},
-  journal = {Journal of Machine Learning Research},
-  year    = {2021},
-  volume  = {22},
-  number  = {268},
-  pages   = {1-8},
-  url     = {http://jmlr.org/papers/v22/20-1364.html}
-}
-
-@misc{openai,
-      title={OpenAI Gym}, 
-      author={Greg Brockman and Vicki Cheung and Ludwig Pettersson and Jonas Schneider and John Schulman and Jie Tang and Wojciech Zaremba},
-      year={2016},
-      eprint={1606.01540},
-      archivePrefix={arXiv},
-      primaryClass={cs.LG}
-}
-
-@misc{tensorflow,
-title={ {TensorFlow}: Large-Scale Machine Learning on Heterogeneous Systems},
-url={https://www.tensorflow.org/},
-note={Software available from tensorflow.org},
-author={
-    Mart\'{i}n~Abadi and
-    Ashish~Agarwal and
-    Paul~Barham and
-    Eugene~Brevdo and
-    Zhifeng~Chen and
-    Craig~Citro and
-    Greg~S.~Corrado and
-    Andy~Davis and
-    Jeffrey~Dean and
-    Matthieu~Devin and
-    Sanjay~Ghemawat and
-    Ian~Goodfellow and
-    Andrew~Harp and
-    Geoffrey~Irving and
-    Michael~Isard and
-    Yangqing Jia and
-    Rafal~Jozefowicz and
-    Lukasz~Kaiser and
-    Manjunath~Kudlur and
-    Josh~Levenberg and
-    Dandelion~Man\'{e} and
-    Rajat~Monga and
-    Sherry~Moore and
-    Derek~Murray and
-    Chris~Olah and
-    Mike~Schuster and
-    Jonathon~Shlens and
-    Benoit~Steiner and
-    Ilya~Sutskever and
-    Kunal~Talwar and
-    Paul~Tucker and
-    Vincent~Vanhoucke and
-    Vijay~Vasudevan and
-    Fernanda~Vi\'{e}gas and
-    Oriol~Vinyals and
-    Pete~Warden and
-    Martin~Wattenberg and
-    Martin~Wicke and
-    Yuan~Yu and
-    Xiaoqiang~Zheng},
-  year={2015},
-}
-
-@incollection{pytorch,
-title = {PyTorch: An Imperative Style, High-Performance Deep Learning Library},
-author = {Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and Desmaison, Alban and Kopf, Andreas and Yang, Edward and DeVito, Zachary and Raison, Martin and Tejani, Alykhan and Chilamkurthy, Sasank and Steiner, Benoit and Fang, Lu and Bai, Junjie and Chintala, Soumith},
-booktitle = {Advances in Neural Information Processing Systems 32},
-editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
-pages = {8024--8035},
-year = {2019},
-publisher = {Curran Associates, Inc.},
-url = {http://papers.neurips.cc/paper/9015-pytorch-an-imperative-style-high-performance-deep-learning-library.pdf}
-}
-
-@ARTICLE{scipy,
-  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
-            Haberland, Matt and Reddy, Tyler and Cournapeau, David and
-            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
-            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
-            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
-            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
-            Kern, Robert and Larson, Eric and Carey, C J and
-            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and
-            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
-            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
-            Harris, Charles R. and Archibald, Anne M. and
-            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and
-            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
-  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
-            Computing in Python}},
-  journal = {Nature Methods},
-  year    = {2020},
-  volume  = {17},
-  pages   = {261--272},
-  adsurl  = {https://rdcu.be/b08Wh},
-  doi     = {10.1038/s41592-019-0686-2},
-}
-
-@Article{numpy,
- title         = {Array programming with {NumPy}},
- author        = {Charles R. Harris and K. Jarrod Millman and St{\'{e}}fan J.
-                 van der Walt and Ralf Gommers and Pauli Virtanen and David
-                 Cournapeau and Eric Wieser and Julian Taylor and Sebastian
-                 Berg and Nathaniel J. Smith and Robert Kern and Matti Picus
-                 and Stephan Hoyer and Marten H. van Kerkwijk and Matthew
-                 Brett and Allan Haldane and Jaime Fern{\'{a}}ndez del
-                 R{\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre
-                 G{\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and
-                 Warren Weckesser and Hameer Abbasi and Christoph Gohlke and
-                 Travis E. Oliphant},
- year          = {2020},
- month         = sep,
- journal       = {Nature},
- volume        = {585},
- number        = {7825},
- pages         = {357--362},
- doi           = {10.1038/s41586-020-2649-2},
- publisher     = {Springer Science and Business Media {LLC}},
- url           = {https://doi.org/10.1038/s41586-020-2649-2}
-}
-
- @inproceedings{pandas,
-  title={Data structures for statistical computing in python},
-  author={McKinney, Wes and others},
-  booktitle={Proceedings of the 9th Python in Science Conference},
-  volume={445},
-  pages={51--56},
-  year={2010},
-  organization={Austin, TX},
-  doi={10.25080/Majora-92bf1922-00a}
-}
-
-
-
-@online{finrl,
-  title = {AI4Finance-Foundation},
-  year = 2022,
-  url = {https://github.com/AI4Finance-Foundation/FinRL},
-  urldate = {2022-09-30}
-}
-
-
-@online{tensortrade,
-  title = {tensortrade},
-  year = 2022,
-  url = {https://tensortradex.readthedocs.io/en/latest/L},
-  urldate = {2022-09-30}
-}

docs/JOSS_paper/paper.jats

@@ -1,941 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.2 20190208//EN"
-                  "JATS-publishing1.dtd">
-<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="1.2" article-type="other">
-<front>
-<journal-meta>
-<journal-id></journal-id>
-<journal-title-group>
-<journal-title>Journal of Open Source Software</journal-title>
-<abbrev-journal-title>JOSS</abbrev-journal-title>
-</journal-title-group>
-<issn publication-format="electronic">2475-9066</issn>
-<publisher>
-<publisher-name>Open Journals</publisher-name>
-</publisher>
-</journal-meta>
-<article-meta>
-<article-id pub-id-type="publisher-id">0</article-id>
-<article-id pub-id-type="doi">N/A</article-id>
-<title-group>
-<article-title><monospace>FreqAI</monospace>: generalizing adaptive
-modeling for chaotic time-series market forecasts</article-title>
-</title-group>
-<contrib-group>
-<contrib contrib-type="author">
-<contrib-id contrib-id-type="orcid">0000-0001-5618-8629</contrib-id>
-<name>
-<surname>Ph.D</surname>
-<given-names>Robert A. Caulk</given-names>
-</name>
-<xref ref-type="aff" rid="aff-1"/>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<contrib-id contrib-id-type="orcid">0000-0003-3289-8604</contrib-id>
-<name>
-<surname>Ph.D</surname>
-<given-names>Elin Törnquist</given-names>
-</name>
-<xref ref-type="aff" rid="aff-1"/>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Voppichler</surname>
-<given-names>Matthias</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Lawless</surname>
-<given-names>Andrew R.</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>McMullan</surname>
-<given-names>Ryan</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Santos</surname>
-<given-names>Wagner Costa</given-names>
-</name>
-<xref ref-type="aff" rid="aff-1"/>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Pogue</surname>
-<given-names>Timothy C.</given-names>
-</name>
-<xref ref-type="aff" rid="aff-1"/>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>van der Vlugt</surname>
-<given-names>Johan</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Gehring</surname>
-<given-names>Stefan P.</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<contrib contrib-type="author">
-<name>
-<surname>Schmidt</surname>
-<given-names>Pascal</given-names>
-</name>
-<xref ref-type="aff" rid="aff-2"/>
-</contrib>
-<aff id="aff-1">
-<institution-wrap>
-<institution>Emergent Methods LLC, Arvada Colorado, 80005,
-USA</institution>
-</institution-wrap>
-</aff>
-<aff id="aff-2">
-<institution-wrap>
-<institution>Freqtrade open source project</institution>
-</institution-wrap>
-</aff>
-</contrib-group>
-<volume>¿VOL?</volume>
-<issue>¿ISSUE?</issue>
-<fpage>¿PAGE?</fpage>
-<permissions>
-<copyright-statement>Authors of papers retain copyright and release the
-work under a Creative Commons Attribution 4.0 International License (CC
-BY 4.0)</copyright-statement>
-<copyright-year>2022</copyright-year>
-<copyright-holder>The article authors</copyright-holder>
-<license license-type="open-access" xlink:href="https://creativecommons.org/licenses/by/4.0/">
-<license-p>Authors of papers retain copyright and release the work under
-a Creative Commons Attribution 4.0 International License (CC BY
-4.0)</license-p>
-</license>
-</permissions>
-<kwd-group kwd-group-type="author">
-<kwd>Python</kwd>
-<kwd>Machine Learning</kwd>
-<kwd>adaptive modeling</kwd>
-<kwd>chaotic systems</kwd>
-<kwd>time-series forecasting</kwd>
-</kwd-group>
-</article-meta>
-</front>
-<body>
-<sec id="statement-of-need">
-  <title>Statement of need</title>
-  <p>Forecasting chaotic time-series based systems, such as
-  equity/cryptocurrency markets, requires a broad set of tools geared
-  toward testing a wide range of hypotheses. Fortunately, a recent
-  maturation of robust machine learning libraries
-  (e.g. <monospace>scikit-learn</monospace>), has opened up a wide range
-  of research possibilities. Scientists from a diverse range of fields
-  can now easily prototype their studies on an abundance of established
-  machine learning algorithms. Similarly, these user-friendly libraries
-  enable “citzen scientists” to use their basic Python skills for
-  data-exploration. However, leveraging these machine learning libraries
-  on historical and live chaotic data sources can be logistically
-  difficult and expensive. Additionally, robust data-collection,
-  storage, and handling presents a disparate challenge.
-  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
-  aims to provide a generalized and extensible open-sourced framework
-  geared toward live deployments of adaptive modeling for market
-  forecasting. The <monospace>FreqAI</monospace> framework is
-  effectively a sandbox for the rich world of open-source machine
-  learning libraries. Inside the <monospace>FreqAI</monospace> sandbox,
-  users find they can combine a wide variety of third-party libraries to
-  test creative hypotheses on a free live 24/7 chaotic data source -
-  cryptocurrency exchange data.</p>
-</sec>
-<sec id="summary">
-  <title>Summary</title>
-  <p><ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
-  evolved from a desire to test and compare a range of adaptive
-  time-series forecasting methods on chaotic data. Cryptocurrency
-  markets provide a unique data source since they are operational 24/7
-  and the data is freely available. Luckily, an existing open-source
-  software,
-  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/stable/"><monospace>Freqtrade</monospace></ext-link>,
-  had already matured under a range of talented developers to support
-  robust data collection/storage, as well as robust live environmental
-  interactions for standard algorithmic trading.
-  <monospace>Freqtrade</monospace> also provides a set of data
-  analysis/visualization tools for the evaluation of historical
-  performance as well as live environmental feedback.
-  <monospace>FreqAI</monospace> builds on top of
-  <monospace>Freqtrade</monospace> to include a user-friendly well
-  tested interface for integrating external machine learning libraries
-  for adaptive time-series forecasting. Beyond enabling the integration
-  of existing libraries, <monospace>FreqAI</monospace> hosts a range of
-  custom algorithms and methodologies aimed at improving computational
-  and predictive performances. Thus, <monospace>FreqAI</monospace>
-  contains a range of unique features which can be easily tested in
-  combination with all the existing Python-accessible machine learning
-  libraries to generate novel research on live and historical data.</p>
-  <p>The high-level overview of the software is depicted in Figure
-  1.</p>
-  <p><named-content content-type="image">freqai-algo</named-content>
-  <italic>Abstracted overview of FreqAI algorithm</italic></p>
-  <sec id="connecting-machine-learning-libraries">
-    <title>Connecting machine learning libraries</title>
-    <p>Although the <monospace>FreqAI</monospace> framework is designed
-    to accommodate any Python library in the “Model training” and
-    “Feature set engineering” portions of the software (Figure 1), it
-    already boasts a wide range of well documented examples based on
-    various combinations of:</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>scikit-learn
-        (<xref alt="Pedregosa et al., 2011" rid="ref-scikit-learn" ref-type="bibr">Pedregosa
-        et al., 2011</xref>), Catboost
-        (<xref alt="Prokhorenkova et al., 2018" rid="ref-catboost" ref-type="bibr">Prokhorenkova
-        et al., 2018</xref>), LightGBM
-        (<xref alt="Ke et al., 2017" rid="ref-lightgbm" ref-type="bibr">Ke
-        et al., 2017</xref>), XGBoost
-        (<xref alt="Chen &amp; Guestrin, 2016" rid="ref-xgboost" ref-type="bibr">Chen
-        &amp; Guestrin, 2016</xref>), stable_baselines3
-        (<xref alt="Raffin et al., 2021" rid="ref-stable-baselines3" ref-type="bibr">Raffin
-        et al., 2021</xref>), openai gym
-        (<xref alt="Brockman et al., 2016" rid="ref-openai" ref-type="bibr">Brockman
-        et al., 2016</xref>), tensorflow
-        (<xref alt="Abadi et al., 2015" rid="ref-tensorflow" ref-type="bibr">Abadi
-        et al., 2015</xref>), pytorch
-        (<xref alt="Paszke et al., 2019" rid="ref-pytorch" ref-type="bibr">Paszke
-        et al., 2019</xref>), Scipy
-        (<xref alt="Virtanen et al., 2020" rid="ref-scipy" ref-type="bibr">Virtanen
-        et al., 2020</xref>), Numpy
-        (<xref alt="Harris et al., 2020" rid="ref-numpy" ref-type="bibr">Harris
-        et al., 2020</xref>), and pandas
-        (<xref alt="McKinney &amp; others, 2010" rid="ref-pandas" ref-type="bibr">McKinney
-        &amp; others, 2010</xref>).</p>
-      </list-item>
-    </list>
-    <p>These mature projects contain a wide range of peer-reviewed and
-    industry standard methods, including:</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>Regression, Classification, Neural Networks, Reinforcement
-        Learning, Support Vector Machines, Principal Component Analysis,
-        point clustering, and much more.</p>
-      </list-item>
-    </list>
-    <p>which are all leveraged in <monospace>FreqAI</monospace> for
-    users to use as templates or extend with their own methods.</p>
-  </sec>
-  <sec id="furnishing-novel-methods-and-features">
-    <title>Furnishing novel methods and features</title>
-    <p>Beyond the industry standard methods available through external
-    libraries - <monospace>FreqAI</monospace> includes novel methods
-    which are not available anywhere else in the open-source (or
-    scientific) world. For example, <monospace>FreqAI</monospace>
-    provides :</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>a custom algorithm/methodology for adaptive modeling</p>
-      </list-item>
-      <list-item>
-        <p>rapid and self-monitored feature engineering tools</p>
-      </list-item>
-      <list-item>
-        <p>unique model features/indicators</p>
-      </list-item>
-      <list-item>
-        <p>optimized data collection algorithms</p>
-      </list-item>
-      <list-item>
-        <p>safely integrated outlier detection methods</p>
-      </list-item>
-      <list-item>
-        <p>websocket communicated forecasts</p>
-      </list-item>
-    </list>
-    <p>Of particular interest for researchers,
-    <monospace>FreqAI</monospace> provides the option of large scale
-    experimentation via an optimized websocket communications
-    interface.</p>
-  </sec>
-  <sec id="optimizing-the-back-end">
-    <title>Optimizing the back-end</title>
-    <p><monospace>FreqAI</monospace> aims to make it simple for users to
-    combine all the above tools to run studies based in two distinct
-    modules:</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>backtesting studies</p>
-      </list-item>
-      <list-item>
-        <p>live-deployments</p>
-      </list-item>
-    </list>
-    <p>Both of these modules and their respective data management
-    systems are built on top of
-    <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/"><monospace>Freqtrade</monospace></ext-link>,
-    a mature and actively developed cryptocurrency trading software.
-    This means that <monospace>FreqAI</monospace> benefits from a wide
-    range of tangential/disparate feature developments such as:</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>FreqUI, a graphical interface for backtesting and live
-        monitoring</p>
-      </list-item>
-      <list-item>
-        <p>telegram control</p>
-      </list-item>
-      <list-item>
-        <p>robust database handling</p>
-      </list-item>
-      <list-item>
-        <p>futures/leverage trading</p>
-      </list-item>
-      <list-item>
-        <p>dollar cost averaging</p>
-      </list-item>
-      <list-item>
-        <p>trading strategy handling</p>
-      </list-item>
-      <list-item>
-        <p>a variety of free data sources via CCXT (FTX, Binance, Kucoin
-        etc.)</p>
-      </list-item>
-    </list>
-    <p>These features derive from a strong external developer community
-    that shares in the benefit and stability of a communal CI
-    (Continuous Integration) system. Beyond the developer community,
-    <monospace>FreqAI</monospace> benefits strongly from the userbase of
-    <monospace>Freqtrade</monospace>, where most
-    <monospace>FreqAI</monospace> beta-testers/developers originated.
-    This symbiotic relationship between <monospace>Freqtrade</monospace>
-    and <monospace>FreqAI</monospace> ignited a thoroughly tested
-    <ext-link ext-link-type="uri" xlink:href="https://github.com/freqtrade/freqtrade/pull/6832"><monospace>beta</monospace></ext-link>,
-    which demanded a four month beta and
-    <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">comprehensive
-    documentation</ext-link> containing:</p>
-    <list list-type="bullet">
-      <list-item>
-        <p>numerous example scripts</p>
-      </list-item>
-      <list-item>
-        <p>a full parameter table</p>
-      </list-item>
-      <list-item>
-        <p>methodological descriptions</p>
-      </list-item>
-      <list-item>
-        <p>high-resolution diagrams/figures</p>
-      </list-item>
-      <list-item>
-        <p>detailed parameter setting recommendations</p>
-      </list-item>
-    </list>
-  </sec>
-  <sec id="providing-a-reproducible-foundation-for-researchers">
-    <title>Providing a reproducible foundation for researchers</title>
-    <p><monospace>FreqAI</monospace> provides an extensible, robust,
-    framework for researchers and citizen data scientists. The
-    <monospace>FreqAI</monospace> sandbox enables rapid conception and
-    testing of exotic hypotheses. From a research perspective,
-    <monospace>FreqAI</monospace> handles the multitude of logistics
-    associated with live deployments, historical backtesting, and
-    feature engineering. With <monospace>FreqAI</monospace>, researchers
-    can focus on their primary interests of feature engineering and
-    hypothesis testing rather than figuring out how to collect and
-    handle data. Further - the well maintained and easily installed
-    open-source framework of <monospace>FreqAI</monospace> enables
-    reproducible scientific studies. This reproducibility component is
-    essential to general scientific advancement in time-series
-    forecasting for chaotic systems.</p>
-  </sec>
-</sec>
-<sec id="technical-details">
-  <title>Technical details</title>
-  <p>Typical users configure <monospace>FreqAI</monospace> via two
-  files:</p>
-  <list list-type="order">
-    <list-item>
-      <p>A <monospace>configuration</monospace> file
-      (<monospace>--config</monospace>) which provides access to the
-      full parameter list available
-      <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">here</ext-link>:</p>
-    </list-item>
-  </list>
-  <list list-type="bullet">
-    <list-item>
-      <p>control high-level feature engineering</p>
-    </list-item>
-    <list-item>
-      <p>customize adaptive modeling techniques</p>
-    </list-item>
-    <list-item>
-      <p>set any model training parameters available in third-party
-      libraries</p>
-    </list-item>
-    <list-item>
-      <p>manage adaptive modeling parameters (retrain frequency,
-      training window size, continual learning, etc.)</p>
-    </list-item>
-  </list>
-  <list list-type="order">
-    <list-item>
-      <label>2.</label>
-      <p>A strategy file (<monospace>--strategy</monospace>) where
-      users:</p>
-    </list-item>
-  </list>
-  <list list-type="bullet">
-    <list-item>
-      <p>list of the base training features</p>
-    </list-item>
-    <list-item>
-      <p>set standard technical-analysis strategies</p>
-    </list-item>
-    <list-item>
-      <p>control trade entry/exit criteria</p>
-    </list-item>
-  </list>
-  <p>With these two files, most users can exploit a wide range of
-  pre-existing integrations in <monospace>Catboost</monospace> and 7
-  other libraries with a simple command:</p>
-  <preformat>freqtrade trade --config config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel CatboostRegressor</preformat>
-  <p>Advanced users will edit one of the existing
-  <monospace>--freqaimodel</monospace> files, which are simply an
-  children of the <monospace>IFreqaiModel</monospace> (details below).
-  Within these files, advanced users can customize training procedures,
-  prediction procedures, outlier detection methods, data preparation,
-  data saving methods, etc. This is all configured in a way where they
-  can customize as little or as much as they want. This flexible
-  customization is owed to the foundational architecture in
-  <monospace>FreqAI</monospace>, which is comprised of three distinct
-  Python objects:</p>
-  <list list-type="bullet">
-    <list-item>
-      <p><monospace>IFreqaiModel</monospace></p>
-      <list list-type="bullet">
-        <list-item>
-          <p>A singular long-lived object containing all the necessary
-          logic to collect data, store data, process data, engineer
-          features, run training, and inference models.</p>
-        </list-item>
-      </list>
-    </list-item>
-    <list-item>
-      <p><monospace>FreqaiDataKitchen</monospace></p>
-      <list list-type="bullet">
-        <list-item>
-          <p>A short-lived object which is uniquely created for each
-          asset/model. Beyond metadata, it also contains a variety of
-          data processing tools.</p>
-        </list-item>
-      </list>
-    </list-item>
-    <list-item>
-      <p><monospace>FreqaiDataDrawer</monospace></p>
-      <list list-type="bullet">
-        <list-item>
-          <p>Singular long-lived object containing all the historical
-          predictions, models, and save/load methods.</p>
-        </list-item>
-      </list>
-    </list-item>
-  </list>
-  <p>These objects interact with one another with one goal in mind - to
-  provide a clean data set to machine learning experts/enthusiasts at
-  the user endpoint. These power-users interact with an inherited
-  <monospace>IFreqaiModel</monospace> that allows them to dig as deep or
-  as shallow as they wish into the inheritence tree. Typical power-users
-  focus their efforts on customizing training procedures and testing
-  exotic functionalities available in third-party libraries. Thus,
-  power-users are freed from the algorithmic weight associated with data
-  management, and can instead focus their energy on testing creative
-  hypotheses. Meanwhile, some users choose to override deeper
-  functionalities within <monospace>IFreqaiModel</monospace> to help
-  them craft unique data structures and training procedures.</p>
-  <p>The class structure and algorithmic details are depicted in the
-  following diagram:</p>
-  <p><named-content content-type="image">image</named-content>
-  <italic>Class diagram summarizing object interactions in
-  FreqAI</italic></p>
-</sec>
-<sec id="online-documentation">
-  <title>Online documentation</title>
-  <p>The documentation for
-  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
-  is available online at
-  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">https://www.freqtrade.io/en/latest/freqai/</ext-link>
-  and covers a wide range of materials:</p>
-  <list list-type="bullet">
-    <list-item>
-      <p>Quick-start with a single command and example files -
-      (beginners)</p>
-    </list-item>
-    <list-item>
-      <p>Introduction to the feature engineering interface and basic
-      configurations - (intermediate users)</p>
-    </list-item>
-    <list-item>
-      <p>Parameter table with indepth descriptions and default parameter
-      setting recommendations - (intermediate users)</p>
-    </list-item>
-    <list-item>
-      <p>Data analysis and post-processing - (advanced users)</p>
-    </list-item>
-    <list-item>
-      <p>Methodological considerations complemented by high resolution
-      figures - (advanced users)</p>
-    </list-item>
-    <list-item>
-      <p>Instructions for integrating third party machine learning
-      libraries into custom prediction models - (advanced users)</p>
-    </list-item>
-    <list-item>
-      <p>Software architectural description with class diagram -
-      (developers)</p>
-    </list-item>
-    <list-item>
-      <p>File structure descriptions - (developers)</p>
-    </list-item>
-  </list>
-  <p>The docs direct users to a variety of pre-made examples which
-  integrate <monospace>Catboost</monospace>,
-  <monospace>LightGBM</monospace>, <monospace>XGBoost</monospace>,
-  <monospace>Sklearn</monospace>,
-  <monospace>stable_baselines3</monospace>,
-  <monospace>torch</monospace>, <monospace>tensorflow</monospace>.
-  Meanwhile, developers will also find thorough docstrings and type
-  hinting throughout the source code to aid in code readability and
-  customization.</p>
-  <p><monospace>FreqAI</monospace> also benefits from a strong support
-  network of users and developers on the
-  <ext-link ext-link-type="uri" xlink:href="https://discord.gg/w6nDM6cM4y"><monospace>Freqtrade</monospace>
-  discord</ext-link> as well as on the
-  <ext-link ext-link-type="uri" xlink:href="https://discord.gg/xE4RMg4QYw"><monospace>FreqAI</monospace>
-  discord</ext-link>. Within the <monospace>FreqAI</monospace> discord,
-  users will find a deep and easily searched knowledge base containing
-  common errors. But more importantly, users in the
-  <monospace>FreqAI</monospace> discord share anectdotal and
-  quantitative observations which compare performance between various
-  third-party libraries and methods.</p>
-</sec>
-<sec id="state-of-the-field">
-  <title>State of the field</title>
-  <p>There are two other open-source tools which are geared toward
-  helping users build models for time-series forecasts on market based
-  data. However, each of these tools suffer from a non-generalized
-  frameworks that do not permit comparison of methods and libraries.
-  Additionally, they do not permit easy live-deployments or
-  adaptive-modeling methods. For example, two open-sourced projects
-  called
-  <ext-link ext-link-type="uri" xlink:href="https://tensortradex.readthedocs.io/en/latest/"><monospace>tensortrade</monospace></ext-link>
-  (<xref alt="Tensortrade, 2022" rid="ref-tensortrade" ref-type="bibr"><italic>Tensortrade</italic>,
-  2022</xref>) and
-  <ext-link ext-link-type="uri" xlink:href="https://github.com/AI4Finance-Foundation/FinRL"><monospace>FinRL</monospace></ext-link>
-  (<xref alt="AI4Finance-Foundation, 2022" rid="ref-finrl" ref-type="bibr"><italic>AI4Finance-Foundation</italic>,
-  2022</xref>) limit users to the exploration of reinforcement learning
-  on historical data. These softwares also do not provide robust live
-  deployments, they do not furnish novel feature engineering algorithms,
-  and they do not provide custom data analysis tools.
-  <monospace>FreqAI</monospace> fills the gap.</p>
-</sec>
-<sec id="on-going-research">
-  <title>On-going research</title>
-  <p>Emergent Methods, based in Arvada CO, is actively using
-  <monospace>FreqAI</monospace> to perform large scale experiments aimed
-  at comparing machine learning libraries in live and historical
-  environments. Past projects include backtesting parametric sweeps,
-  while active projects include a 3 week live deployment comparison
-  between <monospace>CatboosRegressor</monospace>,
-  <monospace>LightGBMRegressor</monospace>, and
-  <monospace>XGBoostRegressor</monospace>. Results from these studies
-  are on track for publication in scientific journals as well as more
-  general data science blogs (e.g. Medium).</p>
-</sec>
-<sec id="installing-and-running-freqai">
-  <title>Installing and running <monospace>FreqAI</monospace></title>
-  <p><monospace>FreqAI</monospace> is automatically installed with
-  <monospace>Freqtrade</monospace> using the following commands on linux
-  systems:</p>
-  <preformat>git clone git@github.com:freqtrade/freqtrade.git
-cd freqtrade
-./setup.sh -i</preformat>
-  <p>However, <monospace>FreqAI</monospace> also benefits from
-  <monospace>Freqtrade</monospace> docker distributions, and can be run
-  with docker by pulling the stable or develop images from
-  <monospace>Freqtrade</monospace> distributions.</p>
-</sec>
-<sec id="funding-sources">
-  <title>Funding sources</title>
-  <p><ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
-  has had no official sponsors, and is entirely grass roots. All
-  donations into the project (e.g. the GitHub sponsor system) are kept
-  inside the project to help support development of open-sourced and
-  communally beneficial features.</p>
-</sec>
-<sec id="acknowledgements">
-  <title>Acknowledgements</title>
-  <p>We would like to acknowledge various beta testers of
-  <monospace>FreqAI</monospace>:</p>
-  <list list-type="bullet">
-    <list-item>
-      <p>Richárd Józsa</p>
-    </list-item>
-    <list-item>
-      <p>Juha Nykänen</p>
-    </list-item>
-    <list-item>
-      <p>Salah Lamkadem</p>
-    </list-item>
-  </list>
-  <p>As well as various <monospace>Freqtrade</monospace>
-  <ext-link ext-link-type="uri" xlink:href="https://github.com/freqtrade/freqtrade/graphs/contributors">developers</ext-link>
-  maintaining tangential, yet essential, modules.</p>
-</sec>
-</body>
-<back>
-<ref-list>
-  <ref id="ref-scikit-learn">
-    <element-citation publication-type="article-journal">
-      <person-group person-group-type="author">
-        <name><surname>Pedregosa</surname><given-names>F.</given-names></name>
-        <name><surname>Varoquaux</surname><given-names>G.</given-names></name>
-        <name><surname>Gramfort</surname><given-names>A.</given-names></name>
-        <name><surname>Michel</surname><given-names>V.</given-names></name>
-        <name><surname>Thirion</surname><given-names>B.</given-names></name>
-        <name><surname>Grisel</surname><given-names>O.</given-names></name>
-        <name><surname>Blondel</surname><given-names>M.</given-names></name>
-        <name><surname>Prettenhofer</surname><given-names>P.</given-names></name>
-        <name><surname>Weiss</surname><given-names>R.</given-names></name>
-        <name><surname>Dubourg</surname><given-names>V.</given-names></name>
-        <name><surname>Vanderplas</surname><given-names>J.</given-names></name>
-        <name><surname>Passos</surname><given-names>A.</given-names></name>
-        <name><surname>Cournapeau</surname><given-names>D.</given-names></name>
-        <name><surname>Brucher</surname><given-names>M.</given-names></name>
-        <name><surname>Perrot</surname><given-names>M.</given-names></name>
-        <name><surname>Duchesnay</surname><given-names>E.</given-names></name>
-      </person-group>
-      <article-title>Scikit-learn: Machine learning in Python</article-title>
-      <source>Journal of Machine Learning Research</source>
-      <year iso-8601-date="2011">2011</year>
-      <volume>12</volume>
-      <fpage>2825</fpage>
-      <lpage>2830</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-catboost">
-    <element-citation publication-type="paper-conference">
-      <person-group person-group-type="author">
-        <name><surname>Prokhorenkova</surname><given-names>Liudmila</given-names></name>
-        <name><surname>Gusev</surname><given-names>Gleb</given-names></name>
-        <name><surname>Vorobev</surname><given-names>Aleksandr</given-names></name>
-        <name><surname>Dorogush</surname><given-names>Anna Veronika</given-names></name>
-        <name><surname>Gulin</surname><given-names>Andrey</given-names></name>
-      </person-group>
-      <article-title>CatBoost: Unbiased boosting with categorical features</article-title>
-      <source>Proceedings of the 32nd international conference on neural information processing systems</source>
-      <publisher-name>Curran Associates Inc.</publisher-name>
-      <publisher-loc>Red Hook, NY, USA</publisher-loc>
-      <year iso-8601-date="2018">2018</year>
-      <fpage>6639</fpage>
-      <lpage>6649</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-lightgbm">
-    <element-citation publication-type="article-journal">
-      <person-group person-group-type="author">
-        <name><surname>Ke</surname><given-names>Guolin</given-names></name>
-        <name><surname>Meng</surname><given-names>Qi</given-names></name>
-        <name><surname>Finley</surname><given-names>Thomas</given-names></name>
-        <name><surname>Wang</surname><given-names>Taifeng</given-names></name>
-        <name><surname>Chen</surname><given-names>Wei</given-names></name>
-        <name><surname>Ma</surname><given-names>Weidong</given-names></name>
-        <name><surname>Ye</surname><given-names>Qiwei</given-names></name>
-        <name><surname>Liu</surname><given-names>Tie-Yan</given-names></name>
-      </person-group>
-      <article-title>Lightgbm: A highly efficient gradient boosting decision tree</article-title>
-      <source>Advances in neural information processing systems</source>
-      <year iso-8601-date="2017">2017</year>
-      <volume>30</volume>
-      <fpage>3146</fpage>
-      <lpage>3154</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-xgboost">
-    <element-citation publication-type="paper-conference">
-      <person-group person-group-type="author">
-        <name><surname>Chen</surname><given-names>Tianqi</given-names></name>
-        <name><surname>Guestrin</surname><given-names>Carlos</given-names></name>
-      </person-group>
-      <article-title>XGBoost: A scalable tree boosting system</article-title>
-      <source>Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining</source>
-      <publisher-name>ACM</publisher-name>
-      <publisher-loc>New York, NY, USA</publisher-loc>
-      <year iso-8601-date="2016">2016</year>
-      <isbn>978-1-4503-4232-2</isbn>
-      <uri>http://doi.acm.org/10.1145/2939672.2939785</uri>
-      <pub-id pub-id-type="doi">10.1145/2939672.2939785</pub-id>
-      <fpage>785</fpage>
-      <lpage>794</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-stable-baselines3">
-    <element-citation publication-type="article-journal">
-      <person-group person-group-type="author">
-        <name><surname>Raffin</surname><given-names>Antonin</given-names></name>
-        <name><surname>Hill</surname><given-names>Ashley</given-names></name>
-        <name><surname>Gleave</surname><given-names>Adam</given-names></name>
-        <name><surname>Kanervisto</surname><given-names>Anssi</given-names></name>
-        <name><surname>Ernestus</surname><given-names>Maximilian</given-names></name>
-        <name><surname>Dormann</surname><given-names>Noah</given-names></name>
-      </person-group>
-      <article-title>Stable-Baselines3: Reliable reinforcement learning implementations</article-title>
-      <source>Journal of Machine Learning Research</source>
-      <year iso-8601-date="2021">2021</year>
-      <volume>22</volume>
-      <issue>268</issue>
-      <uri>http://jmlr.org/papers/v22/20-1364.html</uri>
-      <fpage>1</fpage>
-      <lpage>8</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-openai">
-    <element-citation>
-      <person-group person-group-type="author">
-        <name><surname>Brockman</surname><given-names>Greg</given-names></name>
-        <name><surname>Cheung</surname><given-names>Vicki</given-names></name>
-        <name><surname>Pettersson</surname><given-names>Ludwig</given-names></name>
-        <name><surname>Schneider</surname><given-names>Jonas</given-names></name>
-        <name><surname>Schulman</surname><given-names>John</given-names></name>
-        <name><surname>Tang</surname><given-names>Jie</given-names></name>
-        <name><surname>Zaremba</surname><given-names>Wojciech</given-names></name>
-      </person-group>
-      <article-title>OpenAI gym</article-title>
-      <year iso-8601-date="2016">2016</year>
-      <uri>https://arxiv.org/abs/1606.01540</uri>
-    </element-citation>
-  </ref>
-  <ref id="ref-tensorflow">
-    <element-citation>
-      <person-group person-group-type="author">
-        <name><surname>Abadi</surname><given-names>Martín</given-names></name>
-        <name><surname>Agarwal</surname><given-names>Ashish</given-names></name>
-        <name><surname>Barham</surname><given-names>Paul</given-names></name>
-        <name><surname>Brevdo</surname><given-names>Eugene</given-names></name>
-        <name><surname>Chen</surname><given-names>Zhifeng</given-names></name>
-        <name><surname>Citro</surname><given-names>Craig</given-names></name>
-        <name><surname>Corrado</surname><given-names>Greg S.</given-names></name>
-        <name><surname>Davis</surname><given-names>Andy</given-names></name>
-        <name><surname>Dean</surname><given-names>Jeffrey</given-names></name>
-        <name><surname>Devin</surname><given-names>Matthieu</given-names></name>
-        <name><surname>Ghemawat</surname><given-names>Sanjay</given-names></name>
-        <name><surname>Goodfellow</surname><given-names>Ian</given-names></name>
-        <name><surname>Harp</surname><given-names>Andrew</given-names></name>
-        <name><surname>Irving</surname><given-names>Geoffrey</given-names></name>
-        <name><surname>Isard</surname><given-names>Michael</given-names></name>
-        <name><surname>Jia</surname><given-names>Yangqing</given-names></name>
-        <name><surname>Jozefowicz</surname><given-names>Rafal</given-names></name>
-        <name><surname>Kaiser</surname><given-names>Lukasz</given-names></name>
-        <name><surname>Kudlur</surname><given-names>Manjunath</given-names></name>
-        <name><surname>Levenberg</surname><given-names>Josh</given-names></name>
-        <name><surname>Mané</surname><given-names>Dandelion</given-names></name>
-        <name><surname>Monga</surname><given-names>Rajat</given-names></name>
-        <name><surname>Moore</surname><given-names>Sherry</given-names></name>
-        <name><surname>Murray</surname><given-names>Derek</given-names></name>
-        <name><surname>Olah</surname><given-names>Chris</given-names></name>
-        <name><surname>Schuster</surname><given-names>Mike</given-names></name>
-        <name><surname>Shlens</surname><given-names>Jonathon</given-names></name>
-        <name><surname>Steiner</surname><given-names>Benoit</given-names></name>
-        <name><surname>Sutskever</surname><given-names>Ilya</given-names></name>
-        <name><surname>Talwar</surname><given-names>Kunal</given-names></name>
-        <name><surname>Tucker</surname><given-names>Paul</given-names></name>
-        <name><surname>Vanhoucke</surname><given-names>Vincent</given-names></name>
-        <name><surname>Vasudevan</surname><given-names>Vijay</given-names></name>
-        <name><surname>Viégas</surname><given-names>Fernanda</given-names></name>
-        <name><surname>Vinyals</surname><given-names>Oriol</given-names></name>
-        <name><surname>Warden</surname><given-names>Pete</given-names></name>
-        <name><surname>Wattenberg</surname><given-names>Martin</given-names></name>
-        <name><surname>Wicke</surname><given-names>Martin</given-names></name>
-        <name><surname>Yu</surname><given-names>Yuan</given-names></name>
-        <name><surname>Zheng</surname><given-names>Xiaoqiang</given-names></name>
-      </person-group>
-      <article-title>TensorFlow: Large-scale machine learning on heterogeneous systems</article-title>
-      <year iso-8601-date="2015">2015</year>
-      <uri>https://www.tensorflow.org/</uri>
-    </element-citation>
-  </ref>
-  <ref id="ref-pytorch">
-    <element-citation publication-type="chapter">
-      <person-group person-group-type="author">
-        <name><surname>Paszke</surname><given-names>Adam</given-names></name>
-        <name><surname>Gross</surname><given-names>Sam</given-names></name>
-        <name><surname>Massa</surname><given-names>Francisco</given-names></name>
-        <name><surname>Lerer</surname><given-names>Adam</given-names></name>
-        <name><surname>Bradbury</surname><given-names>James</given-names></name>
-        <name><surname>Chanan</surname><given-names>Gregory</given-names></name>
-        <name><surname>Killeen</surname><given-names>Trevor</given-names></name>
-        <name><surname>Lin</surname><given-names>Zeming</given-names></name>
-        <name><surname>Gimelshein</surname><given-names>Natalia</given-names></name>
-        <name><surname>Antiga</surname><given-names>Luca</given-names></name>
-        <name><surname>Desmaison</surname><given-names>Alban</given-names></name>
-        <name><surname>Kopf</surname><given-names>Andreas</given-names></name>
-        <name><surname>Yang</surname><given-names>Edward</given-names></name>
-        <name><surname>DeVito</surname><given-names>Zachary</given-names></name>
-        <name><surname>Raison</surname><given-names>Martin</given-names></name>
-        <name><surname>Tejani</surname><given-names>Alykhan</given-names></name>
-        <name><surname>Chilamkurthy</surname><given-names>Sasank</given-names></name>
-        <name><surname>Steiner</surname><given-names>Benoit</given-names></name>
-        <name><surname>Fang</surname><given-names>Lu</given-names></name>
-        <name><surname>Bai</surname><given-names>Junjie</given-names></name>
-        <name><surname>Chintala</surname><given-names>Soumith</given-names></name>
-      </person-group>
-      <article-title>PyTorch: An imperative style, high-performance deep learning library</article-title>
-      <source>Advances in neural information processing systems 32</source>
-      <person-group person-group-type="editor">
-        <name><surname>Wallach</surname><given-names>H.</given-names></name>
-        <name><surname>Larochelle</surname><given-names>H.</given-names></name>
-        <name><surname>Beygelzimer</surname><given-names>A.</given-names></name>
-        <name><surname>dAlché-Buc</surname><given-names>F.</given-names></name>
-        <name><surname>Fox</surname><given-names>E.</given-names></name>
-        <name><surname>Garnett</surname><given-names>R.</given-names></name>
-      </person-group>
-      <publisher-name>Curran Associates, Inc.</publisher-name>
-      <year iso-8601-date="2019">2019</year>
-      <uri>http://papers.neurips.cc/paper/9015-pytorch-an-imperative-style-high-performance-deep-learning-library.pdf</uri>
-      <fpage>8024</fpage>
-      <lpage>8035</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-scipy">
-    <element-citation publication-type="article-journal">
-      <person-group person-group-type="author">
-        <name><surname>Virtanen</surname><given-names>Pauli</given-names></name>
-        <name><surname>Gommers</surname><given-names>Ralf</given-names></name>
-        <name><surname>Oliphant</surname><given-names>Travis E.</given-names></name>
-        <name><surname>Haberland</surname><given-names>Matt</given-names></name>
-        <name><surname>Reddy</surname><given-names>Tyler</given-names></name>
-        <name><surname>Cournapeau</surname><given-names>David</given-names></name>
-        <name><surname>Burovski</surname><given-names>Evgeni</given-names></name>
-        <name><surname>Peterson</surname><given-names>Pearu</given-names></name>
-        <name><surname>Weckesser</surname><given-names>Warren</given-names></name>
-        <name><surname>Bright</surname><given-names>Jonathan</given-names></name>
-        <name><surname>van der Walt</surname><given-names>Stéfan J.</given-names></name>
-        <name><surname>Brett</surname><given-names>Matthew</given-names></name>
-        <name><surname>Wilson</surname><given-names>Joshua</given-names></name>
-        <name><surname>Millman</surname><given-names>K. Jarrod</given-names></name>
-        <name><surname>Mayorov</surname><given-names>Nikolay</given-names></name>
-        <name><surname>Nelson</surname><given-names>Andrew R. J.</given-names></name>
-        <name><surname>Jones</surname><given-names>Eric</given-names></name>
-        <name><surname>Kern</surname><given-names>Robert</given-names></name>
-        <name><surname>Larson</surname><given-names>Eric</given-names></name>
-        <name><surname>Carey</surname><given-names>C J</given-names></name>
-        <name><surname>Polat</surname><given-names>İlhan</given-names></name>
-        <name><surname>Feng</surname><given-names>Yu</given-names></name>
-        <name><surname>Moore</surname><given-names>Eric W.</given-names></name>
-        <name><surname>VanderPlas</surname><given-names>Jake</given-names></name>
-        <name><surname>Laxalde</surname><given-names>Denis</given-names></name>
-        <name><surname>Perktold</surname><given-names>Josef</given-names></name>
-        <name><surname>Cimrman</surname><given-names>Robert</given-names></name>
-        <name><surname>Henriksen</surname><given-names>Ian</given-names></name>
-        <name><surname>Quintero</surname><given-names>E. A.</given-names></name>
-        <name><surname>Harris</surname><given-names>Charles R.</given-names></name>
-        <name><surname>Archibald</surname><given-names>Anne M.</given-names></name>
-        <name><surname>Ribeiro</surname><given-names>Antônio H.</given-names></name>
-        <name><surname>Pedregosa</surname><given-names>Fabian</given-names></name>
-        <name><surname>van Mulbregt</surname><given-names>Paul</given-names></name>
-        <string-name>SciPy 1.0 Contributors</string-name>
-      </person-group>
-      <article-title>SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python</article-title>
-      <source>Nature Methods</source>
-      <year iso-8601-date="2020">2020</year>
-      <volume>17</volume>
-      <pub-id pub-id-type="doi">10.1038/s41592-019-0686-2</pub-id>
-      <fpage>261</fpage>
-      <lpage>272</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-numpy">
-    <element-citation publication-type="article-journal">
-      <person-group person-group-type="author">
-        <name><surname>Harris</surname><given-names>Charles R.</given-names></name>
-        <name><surname>Millman</surname><given-names>K. Jarrod</given-names></name>
-        <name><surname>Walt</surname><given-names>Stéfan J. van der</given-names></name>
-        <name><surname>Gommers</surname><given-names>Ralf</given-names></name>
-        <name><surname>Virtanen</surname><given-names>Pauli</given-names></name>
-        <name><surname>Cournapeau</surname><given-names>David</given-names></name>
-        <name><surname>Wieser</surname><given-names>Eric</given-names></name>
-        <name><surname>Taylor</surname><given-names>Julian</given-names></name>
-        <name><surname>Berg</surname><given-names>Sebastian</given-names></name>
-        <name><surname>Smith</surname><given-names>Nathaniel J.</given-names></name>
-        <name><surname>Kern</surname><given-names>Robert</given-names></name>
-        <name><surname>Picus</surname><given-names>Matti</given-names></name>
-        <name><surname>Hoyer</surname><given-names>Stephan</given-names></name>
-        <name><surname>Kerkwijk</surname><given-names>Marten H. van</given-names></name>
-        <name><surname>Brett</surname><given-names>Matthew</given-names></name>
-        <name><surname>Haldane</surname><given-names>Allan</given-names></name>
-        <name><surname>Río</surname><given-names>Jaime Fernández del</given-names></name>
-        <name><surname>Wiebe</surname><given-names>Mark</given-names></name>
-        <name><surname>Peterson</surname><given-names>Pearu</given-names></name>
-        <name><surname>Gérard-Marchant</surname><given-names>Pierre</given-names></name>
-        <name><surname>Sheppard</surname><given-names>Kevin</given-names></name>
-        <name><surname>Reddy</surname><given-names>Tyler</given-names></name>
-        <name><surname>Weckesser</surname><given-names>Warren</given-names></name>
-        <name><surname>Abbasi</surname><given-names>Hameer</given-names></name>
-        <name><surname>Gohlke</surname><given-names>Christoph</given-names></name>
-        <name><surname>Oliphant</surname><given-names>Travis E.</given-names></name>
-      </person-group>
-      <article-title>Array programming with NumPy</article-title>
-      <source>Nature</source>
-      <publisher-name>Springer Science; Business Media LLC</publisher-name>
-      <year iso-8601-date="2020-09">2020</year><month>09</month>
-      <volume>585</volume>
-      <issue>7825</issue>
-      <uri>https://doi.org/10.1038/s41586-020-2649-2</uri>
-      <pub-id pub-id-type="doi">10.1038/s41586-020-2649-2</pub-id>
-      <fpage>357</fpage>
-      <lpage>362</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-pandas">
-    <element-citation publication-type="paper-conference">
-      <person-group person-group-type="author">
-        <name><surname>McKinney</surname><given-names>Wes</given-names></name>
-        <name><surname>others</surname></name>
-      </person-group>
-      <article-title>Data structures for statistical computing in python</article-title>
-      <source>Proceedings of the 9th python in science conference</source>
-      <publisher-name>Austin, TX</publisher-name>
-      <year iso-8601-date="2010">2010</year>
-      <volume>445</volume>
-      <fpage>51</fpage>
-      <lpage>56</lpage>
-    </element-citation>
-  </ref>
-  <ref id="ref-finrl">
-    <element-citation publication-type="webpage">
-      <article-title>AI4Finance-foundation</article-title>
-      <year iso-8601-date="2022">2022</year>
-      <date-in-citation content-type="access-date"><year iso-8601-date="2022-09-30">2022</year><month>09</month><day>30</day></date-in-citation>
-      <uri>https://github.com/AI4Finance-Foundation/FinRL</uri>
-    </element-citation>
-  </ref>
-  <ref id="ref-tensortrade">
-    <element-citation publication-type="webpage">
-      <article-title>Tensortrade</article-title>
-      <year iso-8601-date="2022">2022</year>
-      <date-in-citation content-type="access-date"><year iso-8601-date="2022-09-30">2022</year><month>09</month><day>30</day></date-in-citation>
-      <uri>https://tensortradex.readthedocs.io/en/latest/L</uri>
-    </element-citation>
-  </ref>
-</ref-list>
-</back>
-</article>

docs/JOSS_paper/paper.md

@@ -1,212 +0,0 @@
----
-title: '`FreqAI`: generalizing adaptive modeling for chaotic time-series market forecasts'
-tags:
-  - Python
-  - Machine Learning
-  - adaptive modeling
-  - chaotic systems
-  - time-series forecasting
-authors:
-  - name: Robert A. Caulk Ph.D
-    orcid: 0000-0001-5618-8629
-    affiliation: 1, 2 
-  - name: Elin Törnquist Ph.D
-    orcid: 0000-0003-3289-8604
-    affiliation: 1, 2
-  - name: Matthias Voppichler 
-    orcid: 
-    affiliation: 2
-  - name: Andrew R. Lawless
-    orcid: 
-    affiliation: 2
-  - name: Ryan McMullan
-    orcid: 
-    affiliation: 2
-  - name: Wagner Costa Santos
-    orcid: 
-    affiliation: 1, 2
-  - name: Timothy C. Pogue
-    orcid: 
-    affiliation: 1, 2
-  - name: Johan van der Vlugt
-    orcid: 
-    affiliation: 2
-  - name: Stefan P. Gehring
-    orcid: 
-    affiliation: 2
-  - name: Pascal Schmidt
-    orcid: 0000-0001-9328-4345
-    affiliation: 2
-
-<!-- affiliation: "1, 2" # (Multiple affiliations must be quoted) -->
-affiliations:
- - name: Emergent Methods LLC, Arvada Colorado, 80005, USA
-   index: 1
- - name: Freqtrade open source project
-   index: 2
-date: October 2022
-bibliography: paper.bib
-
-
----
-
-
-# Statement of need
-
-Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`), has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citizen scientists" to use their basic Python skills for data-exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data-collection, storage, and handling presents a disparate challenge. [`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
-
-
-# Summary
-
-[`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) evolved from a desire to test and compare a range of adaptive time-series forecasting methods on chaotic data. Cryptocurrency markets provide a unique data source since they are operational 24/7 and the data is freely available via a variety of open-sourced [exchange APIs](https://docs.ccxt.com/en/latest/manual.html#exchange-structure). Luckily, an existing open-source software, [`Freqtrade`](https://www.freqtrade.io/en/stable/), had already matured under a range of talented developers to support robust data collection/storage, as well as robust live environmental interactions for standard algorithmic trading. `Freqtrade` also provides a set of data analysis/visualization tools for the evaluation of historical performance as well as live environmental feedback. `FreqAI` builds on top of `Freqtrade` to include a user-friendly well tested interface for integrating external machine learning libraries for adaptive time-series forecasting. Beyond enabling the integration of existing libraries, `FreqAI` hosts a range of custom algorithms and methodologies aimed at improving computational and predictive performances. Thus, `FreqAI` contains a range of unique features which can be easily tested in combination with all the existing Python-accessible machine learning libraries to generate novel research on live and historical data. 
-
-The high-level overview of the software is depicted in Figure 1.
-
-![freqai-algo](assets/freqai_algo.jpg)
-*Abstracted overview of FreqAI algorithm*
-
-## Connecting machine learning libraries
-
-Although the `FreqAI`  framework is designed to accommodate any Python library in the "Model training" and "Feature set engineering" portions of the software (Figure 1), it already boasts a wide range of well documented examples based on various combinations of:
-
-* scikit-learn [@scikit-learn], Catboost [@catboost], LightGBM [@lightgbm], XGBoost [@xgboost], stable_baselines3 [@stable-baselines3], openai gym [@openai], tensorflow [@tensorflow], pytorch [@pytorch], Scipy [@scipy], Numpy [@numpy], and pandas [@pandas]. 
-
-These mature projects contain a wide range of peer-reviewed and industry standard methods, including:
-
-* Regression, Classification, Neural Networks, Reinforcement Learning, Support Vector Machines, Principal Component Analysis, point clustering, and much more. 
-
-which are all leveraged in `FreqAI` for users to use as templates or extend with their own methods.
-  
-## Furnishing novel methods and features
-
-Beyond the industry standard methods available through external libraries - `FreqAI` includes novel methods which are not available anywhere else in the open-source (or scientific) world. For example, `FreqAI` provides :
-
-* a custom algorithm/methodology for adaptive modeling details [here](https://www.freqtrade.io/en/stable/freqai/#general-approach) and [here](https://www.freqtrade.io/en/stable/freqai-developers/#project-architecture)
-* rapid and self-monitored feature engineering tools, details [here](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#feature-engineering)
-* unique model features/indicators, such as the [inlier metric](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#inlier-metric)
-* optimized data collection/storage algorithms, all code shown [here](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/freqai/data_drawer.py)
-* safely integrated outlier detection methods, details [here](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#outlier-detection)
-* websocket communicated forecasts, details [here](https://www.freqtrade.io/en/stable/producer-consumer/)
-
-Of particular interest for researchers, `FreqAI` provides the option of large scale experimentation via an optimized [websocket communications interface](https://www.freqtrade.io/en/stable/producer-consumer/).
-
-## Optimizing the back-end
-
-`FreqAI` aims to make it simple for users to combine all the above tools to run studies based in two distinct modules:
-
-* backtesting studies
-* live-deployments 
-
-Both of these modules and their respective data management systems are built on top of [`Freqtrade`](https://www.freqtrade.io/en/latest/), a mature and actively developed cryptocurrency trading software. This means that `FreqAI` benefits from a wide range of tangential/disparate feature developments such as:
-
-* FreqUI, a graphical interface for backtesting and live monitoring
-* telegram control
-* robust database handling
-* futures/leverage trading
-* dollar cost averaging
-* trading strategy handling
-* a variety of free data sources via [CCXT](https://docs.ccxt.com/en/latest/manual.html#exchange-structure) (FTX, Binance, Kucoin etc.)
-
-These features derive from a strong external developer community that shares in the benefit and stability of a communal CI (Continuous Integration) system. Beyond the developer community, `FreqAI` benefits strongly from the userbase of `Freqtrade`, where most `FreqAI` beta-testers/developers originated. This symbiotic relationship between `Freqtrade` and `FreqAI` ignited a thoroughly tested [`beta`](https://github.com/freqtrade/freqtrade/pull/6832), which demanded a four month beta and [comprehensive documentation](https://www.freqtrade.io/en/latest/freqai/) containing:
-
-* numerous example scripts
-* a full parameter table
-* methodological descriptions
-* high-resolution diagrams/figures
-* detailed parameter setting recommendations
-
-## Providing a reproducible foundation for researchers
-
-`FreqAI` provides an extensible, robust, framework for researchers and citizen data scientists. The `FreqAI` sandbox enables rapid conception and testing of exotic hypotheses. From a research perspective, `FreqAI` handles the multitude of logistics associated with live deployments, historical backtesting, and feature engineering. With `FreqAI`, researchers can focus on their primary interests of feature engineering and hypothesis testing rather than figuring out how to collect and handle data. Further - the well maintained and easily installed open-source framework of `FreqAI` enables reproducible scientific studies. This reproducibility component is essential to general scientific advancement in time-series forecasting for chaotic systems. 
-
-# Technical details
-
-Typical users configure `FreqAI` via two files:
-
-1. A `configuration` file (`--config`) which provides access to the full parameter list available [here](https://www.freqtrade.io/en/latest/freqai/):
-  * control high-level feature engineering
-  * customize adaptive modeling techniques
-  * set any model training parameters available in third-party libraries
-  * manage adaptive modeling parameters (retrain frequency, training window size, continual learning, etc.)
-
-2. A strategy file (`--strategy`) where users:
-  * list of the base training features
-  * set standard technical-analysis strategies
-  * control trade entry/exit criteria
-
-With these two files, most users can exploit a wide range of pre-existing integrations in `Catboost` and 7 other libraries with a simple command:
-
-```
-freqtrade trade --config config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel CatboostRegressor
-```
-
-Advanced users will edit one of the existing `--freqaimodel` files, which are simply an children of the `IFreqaiModel` (details below). Within these files, advanced users can customize training procedures, prediction procedures, outlier detection methods, data preparation, data saving methods, etc. This is all configured in a way where they can customize as little or as much as they want. This flexible customization is owed to the foundational architecture in `FreqAI`, which is comprised of three distinct Python objects:
-
-* `IFreqaiModel`
-  * A singular long-lived object containing all the necessary logic to collect data, store data, process data, engineer features, run training, and inference models. 
-* `FreqaiDataKitchen`
-  * A short-lived object which is uniquely created for each asset/model. Beyond metadata, it also contains a variety of data processing tools. 
-* `FreqaiDataDrawer`
-  * Singular long-lived object containing all the historical predictions, models, and save/load methods. 
-
-These objects interact with one another with one goal in mind - to provide a clean data set to machine learning experts/enthusiasts at the user endpoint. These power-users interact with an inherited `IFreqaiModel` that allows them to dig as deep or as shallow as they wish into the inheritence tree. Typical power-users focus their efforts on customizing training procedures and testing exotic functionalities available in third-party libraries. Thus, power-users are freed from the algorithmic weight associated with data management, and can instead focus their energy on testing creative hypotheses. Meanwhile, some users choose to override deeper functionalities within `IFreqaiModel` to help them craft unique data structures and training procedures.
-
-The class structure and algorithmic details are depicted in the following diagram: 
-
-![image](assets/freqai_algorithm-diagram.jpg)
-*Class diagram summarizing object interactions in FreqAI*
-
-# Online documentation
-
-The documentation for [`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) is available online at [https://www.freqtrade.io/en/latest/freqai/](https://www.freqtrade.io/en/latest/freqai/) and covers a wide range of materials:
-
-* Quick-start with a single command and example files - (beginners)
-* Introduction to the feature engineering interface and basic configurations - (intermediate users)
-* Parameter table with indepth descriptions and default parameter setting recommendations - (intermediate users)
-* Data analysis and post-processing - (advanced users)
-* Methodological considerations complemented by high resolution figures - (advanced users)
-* Instructions for integrating third party machine learning libraries into custom prediction models - (advanced users)
-* Software architectural description with class diagram - (developers) 
-* File structure descriptions - (developers)
-
-The docs direct users to a variety of pre-made examples which integrate `Catboost`, `LightGBM`, `XGBoost`, `Sklearn`, `stable_baselines3`, `torch`, `tensorflow`. Meanwhile, developers will also find thorough docstrings and type hinting throughout the source code to aid in code readability and customization. 
-
-`FreqAI` also benefits from a strong support network of users and developers on the [`Freqtrade` discord](https://discord.gg/w6nDM6cM4y) as well as on the [`FreqAI` discord](https://discord.gg/xE4RMg4QYw). Within the `FreqAI` discord, users will find a deep and easily searched knowledge base containing common errors. But more importantly, users in the `FreqAI` discord share anectdotal and quantitative observations which compare performance between various third-party libraries and methods.
-
-# State of the field
-
-There are two other open-source tools which are geared toward helping users build models for time-series forecasts on market based data. However, each of these tools suffer from a non-generalized frameworks that do not permit comparison of methods and libraries. Additionally, they do not permit easy live-deployments or adaptive-modeling methods. For example, two open-sourced projects called [`tensortrade`](https://tensortradex.readthedocs.io/en/latest/) [@tensortrade] and [`FinRL`](https://github.com/AI4Finance-Foundation/FinRL) [@finrl] limit users to the exploration of reinforcement learning on historical data. These softwares also do not provide robust live deployments, they do not furnish novel feature engineering algorithms, and they do not provide custom data analysis tools. `FreqAI` fills the gap. 
-
-# On-going research
-
-Emergent Methods, based in Arvada CO, is actively using `FreqAI` to perform large scale experiments aimed at comparing machine learning libraries in live and historical environments. Past projects include backtesting parametric sweeps, while active projects include a 3 week live deployment comparison between `CatboostRegressor`, `LightGBMRegressor`, and `XGBoostRegressor`. Results from these studies are planned for submission to scientific journals as well as more general data science blogs (e.g. Medium).
-
-# Installing and running `FreqAI`
-
-`FreqAI` is automatically installed with `Freqtrade` using the following commands on linux systems:
-
-```
-git clone git@github.com:freqtrade/freqtrade.git
-cd freqtrade
-./setup.sh -i
-```
-
-However, `FreqAI` also benefits from `Freqtrade` docker distributions, and can be run with docker by pulling the stable or develop images from `Freqtrade` distributions.
-
-# Funding sources
-
-[`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) has had no official sponsors, and is entirely grass roots. All donations into the project (e.g. the GitHub sponsor system) are kept inside the project to help support development of open-sourced and communally beneficial features. 
-
-# Acknowledgements
-
-We would like to acknowledge various beta testers of `FreqAI`:
-
-- Longlong Yu (lolongcovas)
-- Richárd Józsa (richardjozsa)
-- Juha Nykänen (suikula)
-- Emre Suzen (aemr3)
-- Salah Lamkadem (ikonx)
-
-As well as various `Freqtrade` [developers](https://github.com/freqtrade/freqtrade/graphs/contributors) maintaining tangential, yet essential, modules.
-
-# References

docs/advanced-hyperopt.md

@@ -78,6 +78,8 @@ This function needs to return a floating point number (`float`). Smaller numbers
 To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`), define a nested class called Hyperopt and define the required spaces as follows:
 
 ```python
+from freqtrade.optimize.space import Categorical, Dimension, Integer, SKDecimal
+
 class MyAwesomeStrategy(IStrategy):
     class HyperOpt:
         # Define a custom stoploss space.
@@ -94,6 +96,33 @@ class MyAwesomeStrategy(IStrategy):
                 SKDecimal(0.01, 0.07, decimals=3, name='roi_p2'),
                 SKDecimal(0.01, 0.20, decimals=3, name='roi_p3'),
             ]
+
+        def generate_roi_table(params: Dict) -> Dict[int, float]:
+
+            roi_table = {}
+            roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
+            roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
+            roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
+            roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
+
+            return roi_table
+
+        def trailing_space() -> List[Dimension]:
+            # All parameters here are mandatory, you can only modify their type or the range.
+            return [
+                # Fixed to true, if optimizing trailing_stop we assume to use trailing stop at all times.
+                Categorical([True], name='trailing_stop'),
+
+                SKDecimal(0.01, 0.35, decimals=3, name='trailing_stop_positive'),
+                # 'trailing_stop_positive_offset' should be greater than 'trailing_stop_positive',
+                # so this intermediate parameter is used as the value of the difference between
+                # them. The value of the 'trailing_stop_positive_offset' is constructed in the
+                # generate_trailing_params() method.
+                # This is similar to the hyperspace dimensions used for constructing the ROI tables.
+                SKDecimal(0.001, 0.1, decimals=3, name='trailing_stop_positive_offset_p1'),
+
+                Categorical([True, False], name='trailing_only_offset_is_reached'),
+        ]
 ```
 
 !!! Note

docs/backtesting.md

@@ -522,13 +522,13 @@ Since backtesting lacks some detailed information about what happens within a ca
 - ROI
   - exits are compared to high - but the ROI value is used (e.g. ROI = 2%, high=5% - so the exit will be at 2%)
   - exits are never "below the candle", so a ROI of 2% may result in a exit at 2.4% if low was at 2.4% profit
-  - Forceexits caused by `<N>=-1` ROI entries use low as exit value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
+  - Force-exits caused by `<N>=-1` ROI entries use low as exit value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
 - Stoploss exits happen exactly at stoploss price, even if low was lower, but the loss will be `2 * fees` higher than the stoploss price
 - Stoploss is evaluated before ROI within one candle. So you can often see more trades with the `stoploss` exit reason comparing to the results obtained with the same strategy in the Dry Run/Live Trade modes
 - Low happens before high for stoploss, protecting capital first
 - Trailing stoploss
   - Trailing Stoploss is only adjusted if it's below the candle's low (otherwise it would be triggered)
-  - On trade entry candles that trigger trailing stoploss, the "minimum offset" (`stop_positive_offset`) is assumed (instead of high) - and the stop is calculated from this point
+  - On trade entry candles that trigger trailing stoploss, the "minimum offset" (`stop_positive_offset`) is assumed (instead of high) - and the stop is calculated from this point. This rule is NOT applicable to custom-stoploss scenarios, since there's no information about the stoploss logic available.
   - High happens first - adjusting stoploss
   - Low uses the adjusted stoploss (so exits with large high-low difference are backtested correctly)
   - ROI applies before trailing-stop, ensuring profits are "top-capped" at ROI if both ROI and trailing stop applies
@@ -546,8 +546,8 @@ In addition to the above assumptions, strategy authors should carefully read the
 
 ### Trading limits in backtesting
 
-Exchanges have certain trading limits, like minimum base currency, or minimum stake (quote) currency.
-These limits are usually listed in the exchange documentation as "trading rules" or similar.
+Exchanges have certain trading limits, like minimum (and maximum) base currency, or minimum/maximum stake (quote) currency.
+These limits are usually listed in the exchange documentation as "trading rules" or similar and can be quite different between different pairs.
 
 Backtesting (as well as live and dry-run) does honor these limits, and will ensure that a stoploss can be placed below this value - so the value will be slightly higher than what the exchange specifies.
 Freqtrade has however no information about historic limits.

docs/configuration.md

@@ -215,16 +215,18 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `telegram.balance_dust_level` | Dust-level (in stake currency) - currencies with a balance below this will not be shown by `/balance`. <br> **Datatype:** float
 | `telegram.reload` | Allow "reload" buttons on telegram messages. <br>*Defaults to `True`.<br> **Datatype:** boolean
 | `telegram.notification_settings.*` | Detailed notification settings. Refer to the [telegram documentation](telegram-usage.md) for details.<br> **Datatype:** dictionary
+| `telegram.allow_custom_messages` | Enable the sending of Telegram messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
 | | **Webhook**
 | `webhook.enabled` | Enable usage of Webhook notifications <br> **Datatype:** Boolean
 | `webhook.url` | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookentry` | Payload to send on entry. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookentrycancel` | Payload to send on entry order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookentryfill` | Payload to send on entry order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookexit` | Payload to send on exit. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookexitcancel` | Payload to send on exit order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookexitfill` | Payload to send on exit order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.webhookstatus` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.entry` | Payload to send on entry. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.entry_cancel` | Payload to send on entry order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.entry_fill` | Payload to send on entry order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.exit` | Payload to send on exit. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.exit_cancel` | Payload to send on exit order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.exit_fill` | Payload to send on exit order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.status` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.allow_custom_messages` | Enable the sending of Webhook messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
 | | **Rest API / FreqUI / Producer-Consumer**
 | `api_server.enabled` | Enable usage of API Server. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** Boolean
 | `api_server.listen_ip_address` | Bind IP address. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** IPv4
@@ -251,6 +253,7 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `add_config_files` | Additional config files. These files will be loaded and merged with the current config file. The files are resolved relative to the initial file.<br> *Defaults to `[]`*. <br> **Datatype:** List of strings
 | `dataformat_ohlcv` | Data format to use to store historical candle (OHLCV) data. <br> *Defaults to `json`*. <br> **Datatype:** String
 | `dataformat_trades` | Data format to use to store historical trades data. <br> *Defaults to `jsongz`*. <br> **Datatype:** String
+| `reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage (and decreasing train/inference timing in FreqAI). (Currently only affects FreqAI use-cases) <br> **Datatype:** Boolean. <br> Default: `False`.
 
 ### Parameters in the strategy
 
@@ -550,7 +553,7 @@ The possible values are: `GTC` (default), `FOK` or `IOC`.
 ```
 
 !!! Warning
-    This is ongoing work. For now, it is supported only for binance, gate, ftx and kucoin.
+    This is ongoing work. For now, it is supported only for binance, gate and kucoin.
     Please don't change the default value unless you know what you are doing and have researched the impact of using different values for your particular exchange.
 
 ### What values can be used for fiat_display_currency?
@@ -662,6 +665,7 @@ You should also make sure to read the [Exchanges](exchanges.md) section of the d
 ### Using proxy with Freqtrade
 
 To use a proxy with freqtrade, export your proxy settings using the variables `"HTTP_PROXY"` and `"HTTPS_PROXY"` set to the appropriate values.
+This will have the proxy settings applied to everything (telegram, coingecko, ...) except exchange requests.
 
 ``` bash
 export HTTP_PROXY="http://addr:port"
@@ -669,17 +673,20 @@ export HTTPS_PROXY="http://addr:port"
 freqtrade
 ```
 
-#### Proxy just exchange requests
+#### Proxy exchange requests
 
-To use a proxy just for exchange connections (skips/ignores telegram and coingecko) - you can also define the proxies as part of the ccxt configuration.
+To use a proxy for exchange connections - you will have to define the proxies as part of the ccxt configuration.
 
 ``` json
-"ccxt_config": {
+{ 
+  "exchange": {
+    "ccxt_config": {
     "aiohttp_proxy": "http://addr:port",
     "proxies": {
-        "http": "http://addr:port",
-        "https": "http://addr:port"
+      "http": "http://addr:port",
+      "https": "http://addr:port"
     },
+  }
 }
 ```
 

docs/data-download.md

@@ -177,13 +177,13 @@ freqtrade download-data --exchange binance --pairs ETH/USDT XRP/USDT BTC/USDT --
 
 ### Data format
 
-Freqtrade currently supports 3 data-formats for both OHLCV and trades data:
+Freqtrade currently supports the following data-formats:
 
 * `json` -  plain "text" json files
 * `jsongz` - a gzip-zipped version of json files
 * `hdf5` - a high performance datastore
-* `feather` - a dataformat based on Apache Arrow
-* `parquet` - columnar datastore
+* `feather` - a dataformat based on Apache Arrow (OHLCV only)
+* `parquet` - columnar datastore (OHLCV only)
 
 By default, OHLCV data is stored as `json` data, while trades data is stored as `jsongz` data.
 

docs/deprecated.md

@@ -66,11 +66,11 @@ We will keep a compatibility layer for 1-2 versions (so both `buy_tag` and `ente
 
 #### Naming changes
 
-Webhook terminology changed from "sell" to "exit", and from "buy" to "entry".
+Webhook terminology changed from "sell" to "exit", and from "buy" to "entry", removing "webhook" in the process.
 
-* `webhookbuy` -> `webhookentry`
-* `webhookbuyfill` -> `webhookentryfill`
-* `webhookbuycancel` -> `webhookentrycancel`
-* `webhooksell` -> `webhookexit`
-* `webhooksellfill` -> `webhookexitfill`
-* `webhooksellcancel` -> `webhookexitcancel`
+* `webhookbuy`, `webhookentry` -> `entry`
+* `webhookbuyfill`, `webhookentryfill` -> `entry_fill`
+* `webhookbuycancel`, `webhookentrycancel` -> `entry_cancel`
+* `webhooksell`, `webhookexit` -> `exit`
+* `webhooksellfill`, `webhookexitfill` -> `exit_fill`
+* `webhooksellcancel`, `webhookexitcancel` -> `exit_cancel`

docs/developer.md

@@ -434,6 +434,11 @@ To keep the release-log short, best wrap the full git changelog into a collapsib
 </details>
 ```
 
+### FreqUI release
+
+If FreqUI has been updated substantially, make sure to create a release before merging the release branch.
+Make sure that freqUI CI on the release is finished and passed before merging the release.
+
 ### Create github release / tag
 
 Once the PR against stable is merged (best right after merging):

docs/exchanges.md

@@ -173,26 +173,6 @@ res = [p for p, x in lm.items() if 'US' in x['info']['prohibitedIn']]
 print(res)
 ```
 
-## FTX
-
-!!! Tip "Stoploss on Exchange"
-    FTX supports `stoploss_on_exchange` and can use both stop-loss-market and stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
-    You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type of stoploss shall be used.
-
-### Using subaccounts
-
-To use subaccounts with FTX, you need to edit the configuration and add the following:
-
-``` json
-"exchange": {
-    "ccxt_config": {
-        "headers": {
-            "FTX-SUBACCOUNT": "name"
-        }
-    },
-}
-```
-
 ## Kucoin
 
 Kucoin requires a passphrase for each api key, you will therefore need to add this key into the configuration so your exchange section looks as follows:

docs/faq.md

@@ -102,6 +102,12 @@ If this happens for all pairs in the pairlist, this might indicate a recent exch
 
 Irrespectively of the reason, Freqtrade will fill up these candles with "empty" candles, where open, high, low and close are set to the previous candle close - and volume is empty. In a chart, this will look like a `_` - and is aligned with how exchanges usually represent 0 volume candles.
 
+### I'm getting "Price jump between 2 candles detected"
+
+This message is a warning that the candles had a price jump of > 30%.
+This might be a sign that the pair stopped trading, and some token exchange took place (e.g. COCOS in 2021 - where price jumped from 0.0000154 to 0.01621).
+This message is often accompanied by ["Missing data fillup"](#im-getting-missing-data-fillup-messages-in-the-log) - as trading on such pairs is often stopped for some time.
+
 ### I'm getting "Outdated history for pair xxx" in the log
 
 The bot is trying to tell you that it got an outdated last candle (not the last complete candle).

docs/freqai-configuration.md

@@ -61,7 +61,7 @@ The FreqAI strategy requires including the following lines of code in the standa
         """
         Function designed to automatically generate, name and merge features
         from user indicated timeframes in the configuration file. User controls the indicators
-        passed to the training/prediction by prepending indicators with `'%-' + coin `
+        passed to the training/prediction by prepending indicators with `'%-' + pair `
         (see convention below). I.e. user should not prepend any supporting metrics
         (e.g. bb_lowerband below) with % unless they explicitly want to pass that metric to the
         model.
@@ -69,20 +69,17 @@ The FreqAI strategy requires including the following lines of code in the standa
         :param df: strategy dataframe which will receive merges from informatives
         :param tf: timeframe of the dataframe which will modify the feature names
         :param informative: the dataframe associated with the informative pair
-        :param coin: the name of the coin which will modify the feature names.
         """
 
-        coin = pair.split('/')[0]
-
         if informative is None:
             informative = self.dp.get_pair_dataframe(pair, tf)
 
         # first loop is automatically duplicating indicators for time periods
         for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
             t = int(t)
-            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
+            informative[f"%-{pair}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
+            informative[f"%-{pair}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
+            informative[f"%-{pair}adx-period_{t}"] = ta.ADX(informative, window=t)
 
         indicators = [col for col in informative if col.startswith("%")]
         # This loop duplicates and shifts all indicators to add a sense of recency to data
@@ -134,7 +131,7 @@ Notice also the location of the labels under `if set_generalized_indicators:` at
     (as exemplified in `freqtrade/templates/FreqaiExampleStrategy.py`):
 
     ```python
-        def populate_any_indicators(self, metadata, pair, df, tf, informative=None, coin="", set_generalized_indicators=False):
+        def populate_any_indicators(self, pair, df, tf, informative=None, set_generalized_indicators=False):
 
             ...
 
@@ -192,11 +189,11 @@ dataframe["target_roi"] = dataframe["&-s_close_mean"] + dataframe["&-s_close_std
 dataframe["sell_roi"] = dataframe["&-s_close_mean"] - dataframe["&-s_close_std"] * 1.25
 ```
 
-To consider the population of *historical predictions* for creating the dynamic target instead of information from the training as discussed above, you would set `fit_live_prediction_candles` in the config to the number of historical prediction candles you wish to use to generate target statistics.
+To consider the population of *historical predictions* for creating the dynamic target instead of information from the training as discussed above, you would set `fit_live_predictions_candles` in the config to the number of historical prediction candles you wish to use to generate target statistics.
 
 ```json
     "freqai": {
-        "fit_live_prediction_candles": 300,
+        "fit_live_predictions_candles": 300,
     }
 ```
 
@@ -204,14 +201,44 @@ If this value is set, FreqAI will initially use the predictions from the trainin
 
 ## Using different prediction models
 
-FreqAI has multiple example prediction model libraries that are ready to be used as is via the flag `--freqaimodel`. These libraries include `Catboost`, `LightGBM`, and `XGBoost` regression, classification, and multi-target models, and can be found in `freqai/prediction_models/`. However, it is possible to customize and create your own prediction models using the `IFreqaiModel` class. You are encouraged to inherit `fit()`, `train()`, and `predict()` to let these customize various aspects of the training procedures.
+FreqAI has multiple example prediction model libraries that are ready to be used as is via the flag `--freqaimodel`. These libraries include `CatBoost`, `LightGBM`, and `XGBoost` regression, classification, and multi-target models, and can be found in `freqai/prediction_models/`.
 
-### Setting classifier targets
+Regression and classification models differ in what targets they predict - a regression model will predict a target of continuous values, for example what price BTC will be at tomorrow, whilst a classifier will predict a target of discrete values, for example if the price of BTC will go up tomorrow or not. This means that you have to specify your targets differently depending on which model type you are using (see details [below](#setting-model-targets)).
 
-FreqAI includes a variety of classifiers, such as the `CatboostClassifier` via the flag `--freqaimodel CatboostClassifier`. If you elects to use a classifier, the classes need to be set using strings. For example:
+All of the aforementioned model libraries implement gradient boosted decision tree algorithms. They all work on the principle of ensemble learning, where predictions from multiple simple learners are combined to get a final prediction that is more stable and generalized. The simple learners in this case are decision trees. Gradient boosting refers to the method of learning, where each simple learner is built in sequence - the subsequent learner is used to improve on the error from the previous learner. If you want to learn more about the different model libraries you can find the information in their respective docs:
+
+* CatBoost: https://catboost.ai/en/docs/
+* LightGBM: https://lightgbm.readthedocs.io/en/v3.3.2/#
+* XGBoost: https://xgboost.readthedocs.io/en/stable/#
+
+There are also numerous online articles describing and comparing the algorithms. Some relatively light-weight examples would be [CatBoost vs. LightGBM vs. XGBoost — Which is the best algorithm?](https://towardsdatascience.com/catboost-vs-lightgbm-vs-xgboost-c80f40662924#:~:text=In%20CatBoost%2C%20symmetric%20trees%2C%20or,the%20same%20depth%20can%20differ.) and [XGBoost, LightGBM or CatBoost — which boosting algorithm should I use?](https://medium.com/riskified-technology/xgboost-lightgbm-or-catboost-which-boosting-algorithm-should-i-use-e7fda7bb36bc). Keep in mind that the performance of each model is highly dependent on the application and so any reported metrics might not be true for your particular use of the model.
+
+Apart from the models already available in FreqAI, it is also possible to customize and create your own prediction models using the `IFreqaiModel` class. You are encouraged to inherit `fit()`, `train()`, and `predict()` to customize various aspects of the training procedures. You can place custom FreqAI models in `user_data/freqaimodels` - and freqtrade will pick them up from there based on the provided `--freqaimodel` name - which has to correspond to the class name of your custom model.
+Make sure to use unique names to avoid overriding built-in models.
+
+### Setting model targets
+
+#### Regressors
+
+If you are using a regressor, you need to specify a target that has continuous values. FreqAI includes a variety of regressors, such as the `CatboostRegressor`via the flag `--freqaimodel CatboostRegressor`. An example of how you could set a regression target for predicting the price 100 candles into the future would be
+
+```python
+df['&s-close_price'] = df['close'].shift(-100)
+```
+
+If you want to predict multiple targets, you need to define multiple labels using the same syntax as shown above.
+
+#### Classifiers
+
+If you are using a classifier, you need to specify a target that has discrete values. FreqAI includes a variety of classifiers, such as the `CatboostClassifier` via the flag `--freqaimodel CatboostClassifier`. If you elects to use a classifier, the classes need to be set using strings. For example, if you want to predict if the price 100 candles into the future goes up or down you would set 
 
 ```python
 df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
 ```
 
-Additionally, the example classifier models do not accommodate multiple labels, but they do allow multi-class classification within a single label column.
+If you want to predict multiple targets you must specify all labels in the same label column. You could, for example, add the label `same` to define where the price was unchanged by setting
+
+```python
+df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
+df['&s-up_or_down'] = np.where( df["close"].shift(-100) == df["close"], 'same', df['&s-up_or_down'])
+```

docs/freqai-feature-engineering.md

@@ -2,7 +2,10 @@
 
 ## Defining the features
 
-Low level feature engineering is performed in the user strategy within a function called `populate_any_indicators()`. That function sets the `base features` such as, `RSI`, `MFI`, `EMA`, `SMA`, time of day, volume, etc. The `base features` can be custom indicators or they can be imported from any technical-analysis library that you can find. One important syntax rule is that all `base features` string names are prepended with `%`, while labels/targets are prepended with `&`.
+Low level feature engineering is performed in the user strategy within a function called `populate_any_indicators()`. That function sets the `base features` such as, `RSI`, `MFI`, `EMA`, `SMA`, time of day, volume, etc. The `base features` can be custom indicators or they can be imported from any technical-analysis library that you can find. One important syntax rule is that all `base features` string names are prepended with `%-{pair}`, while labels/targets are prepended with `&`.
+
+!!! Note
+    Adding the full pair string, e.g. XYZ/USD, in the feature name enables improved performance for dataframe caching on the backend. If you decide *not* to add the full pair string in the feature string, FreqAI will operate in a reduced performance mode.
 
 Meanwhile, high level feature engineering is handled within `"feature_parameters":{}` in the FreqAI config. Within this file, it is possible to decide large scale feature expansions on top of the `base_features` such as "including correlated pairs" or "including informative timeframes" or even "including recent candles."
 
@@ -15,7 +18,7 @@ It is advisable to start from the template `populate_any_indicators()` in the so
         """
         Function designed to automatically generate, name, and merge features
         from user-indicated timeframes in the configuration file. The user controls the indicators
-        passed to the training/prediction by prepending indicators with `'%-' + coin `
+        passed to the training/prediction by prepending indicators with `'%-' + pair `
         (see convention below). I.e., the user should not prepend any supporting metrics
         (e.g., bb_lowerband below) with % unless they explicitly want to pass that metric to the
         model.
@@ -23,37 +26,34 @@ It is advisable to start from the template `populate_any_indicators()` in the so
         :param df: strategy dataframe which will receive merges from informatives
         :param tf: timeframe of the dataframe which will modify the feature names
         :param informative: the dataframe associated with the informative pair
-        :param coin: the name of the coin which will modify the feature names.
         """
 
-        coin = pair.split('/')[0]
-
         if informative is None:
             informative = self.dp.get_pair_dataframe(pair, tf)
 
         # first loop is automatically duplicating indicators for time periods
         for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
             t = int(t)
-            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
+            informative[f"%-{pair}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
+            informative[f"%-{pair}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
+            informative[f"%-{pair}adx-period_{t}"] = ta.ADX(informative, window=t)
 
             bollinger = qtpylib.bollinger_bands(
                 qtpylib.typical_price(informative), window=t, stds=2.2
             )
-            informative[f"{coin}bb_lowerband-period_{t}"] = bollinger["lower"]
-            informative[f"{coin}bb_middleband-period_{t}"] = bollinger["mid"]
-            informative[f"{coin}bb_upperband-period_{t}"] = bollinger["upper"]
+            informative[f"{pair}bb_lowerband-period_{t}"] = bollinger["lower"]
+            informative[f"{pair}bb_middleband-period_{t}"] = bollinger["mid"]
+            informative[f"{pair}bb_upperband-period_{t}"] = bollinger["upper"]
 
-            informative[f"%-{coin}bb_width-period_{t}"] = (
-                informative[f"{coin}bb_upperband-period_{t}"]
-                - informative[f"{coin}bb_lowerband-period_{t}"]
-            ) / informative[f"{coin}bb_middleband-period_{t}"]
-            informative[f"%-{coin}close-bb_lower-period_{t}"] = (
-                informative["close"] / informative[f"{coin}bb_lowerband-period_{t}"]
+            informative[f"%-{pair}bb_width-period_{t}"] = (
+                informative[f"{pair}bb_upperband-period_{t}"]
+                - informative[f"{pair}bb_lowerband-period_{t}"]
+            ) / informative[f"{pair}bb_middleband-period_{t}"]
+            informative[f"%-{pair}close-bb_lower-period_{t}"] = (
+                informative["close"] / informative[f"{pair}bb_lowerband-period_{t}"]
             )
 
-            informative[f"%-{coin}relative_volume-period_{t}"] = (
+            informative[f"%-{pair}relative_volume-period_{t}"] = (
                 informative["volume"] / informative["volume"].rolling(t).mean()
             )
 

docs/freqai-parameter-table.md

@@ -18,6 +18,7 @@ Mandatory parameters are marked as **Required** and have to be set in one of the
 | `fit_live_predictions_candles` | Number of historical candles to use for computing target (label) statistics from prediction data, instead of from the training dataset (more information can be found [here](freqai-configuration.md#creating-a-dynamic-target-threshold)). <br> **Datatype:** Positive integer.
 | `follow_mode` | Use a `follower` that will look for models associated with a specific `identifier` and load those for inferencing. A `follower` will **not** train new models. <br> **Datatype:** Boolean. <br> Default: `False`.
 | `continual_learning` | Use the final state of the most recently trained model as starting point for the new model, allowing for incremental learning (more information can be found [here](freqai-running.md#continual-learning)). <br> **Datatype:** Boolean. <br> Default: `False`.
+| `write_metrics_to_disk` | Collect train timings, inference timings and cpu usage in json file. <br> **Datatype:** Boolean. <br> Default: `False`
 |  |  **Feature parameters**
 | `feature_parameters` | A dictionary containing the parameters used to engineer the feature set. Details and examples are shown [here](freqai-feature-engineering.md). <br> **Datatype:** Dictionary.
 | `include_timeframes` | A list of timeframes that all indicators in `populate_any_indicators` will be created for. The list is added as features to the base indicators dataset. <br> **Datatype:** List of timeframes (strings).
@@ -42,20 +43,11 @@ Mandatory parameters are marked as **Required** and have to be set in one of the
 | `test_size` | The fraction of data that should be used for testing instead of training. <br> **Datatype:** Positive float < 1.
 | `shuffle` | Shuffle the training data points during training. Typically, to not remove the chronological order of data in time-series forecasting, this is set to `False`. <br> **Datatype:** Boolean. <br> Defaut: `False`.
 |  |  **Model training parameters**
-| `model_training_parameters` | A flexible dictionary that includes all parameters available by the selected model library. For example, if you use `LightGBMRegressor`, this dictionary can contain any parameter available by the `LightGBMRegressor` [here](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html) (external website). If you select a different model, this dictionary can contain any parameter from that model.  <br> **Datatype:** Dictionary.
+| `model_training_parameters` | A flexible dictionary that includes all parameters available by the selected model library. For example, if you use `LightGBMRegressor`, this dictionary can contain any parameter available by the `LightGBMRegressor` [here](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html) (external website). If you select a different model, this dictionary can contain any parameter from that model. A list of the currently available models can be found [here](freqai-configuration.md#using-different-prediction-models).  <br> **Datatype:** Dictionary.
 | `n_estimators` | The number of boosted trees to fit in the training of the model. <br> **Datatype:** Integer.
 | `learning_rate` | Boosting learning rate during training of the model. <br> **Datatype:** Float.
 | `n_jobs`, `thread_count`, `task_type` | Set the number of threads for parallel processing and the `task_type` (`gpu` or `cpu`). Different model libraries use different parameter names. <br> **Datatype:** Float.
-|  |  *Reinforcement Learning Parameters**
-| `rl_config` | A dictionary containing the control parameters for a Reinforcement Learning model. <br> **Datatype:** Dictionary.
-| `train_cycles` | Training time steps will be set based on the `train_cycles * number of training data points. <br> **Datatype:** Integer.
-| `cpu_count` | Number of processors to dedicate to the Reinforcement Learning training process. <br> **Datatype:** int.
-| `max_trade_duration_candles`| Guides the agent training to keep trades below desired length. Example usage shown in `prediction_models/ReinforcementLearner.py` within the user customizable `calculate_reward()` <br> **Datatype:** int.
-| `model_type` | Model string from stable_baselines3 or SBcontrib. Available strings include: `'TRPO', 'ARS', 'RecurrentPPO', 'MaskablePPO', 'PPO', 'A2C', 'DQN'`. User should ensure that `model_training_parameters` match those available to the corresponding stable_baselines3 model by visiting their documentaiton. [PPO doc](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html) (external website) <br> **Datatype:** string.
-| `policy_type` | One of the available policy types from stable_baselines3 <br> **Datatype:** string.
-| `max_training_drawdown_pct` | The maximum drawdown that the agent is allowed to experience during training. <br> **Datatype:** float. <br> Default: 0.8
-| `cpu_count` | Number of threads/cpus to dedicate to the Reinforcement Learning training process (depending on if `ReinforcementLearning_multiproc` is selected or not). <br> **Datatype:** int. 
-| `model_reward_parameters` | Parameters used inside the user customizable `calculate_reward()` function in `ReinforcementLearner.py` <br> **Datatype:** int.
 |  |  **Extraneous parameters**
 | `keras` | If the selected model makes use of Keras (typical for Tensorflow-based prediction models), this flag needs to be activated so that the model save/loading follows Keras standards. <br> **Datatype:** Boolean. <br> Default: `False`.
-| `conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
+| `conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
+| `reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage and decreasing train/inference timing. This parameter is set in the main level of the Freqtrade configuration file (not inside FreqAI). <br> **Datatype:** Boolean. <br> Default: `False`.

docs/freqai-reinforcement-learning.md

@@ -1,202 +0,0 @@
-# Reinforcement Learning
-
-!!! Note
-    Reinforcement learning dependencies include large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl (~700mb additional space required) [y/N]?" Users who prefer docker should ensure they use the docker image appended with `_freqaiRL`. 
-
-Setting up and running a Reinforcement Learning model is the same as running a Regressor or Classifier. The same two flags, `--freqaimodel` and `--strategy`, must be defined on the command line:
-
-```bash
-freqtrade trade --freqaimodel ReinforcementLearner --strategy MyRLStrategy --config config.json
-```
-
-where `ReinforcementLearner` will use the templated `ReinforcementLearner` from `freqai/prediction_models/ReinforcementLearner`. The strategy, on the other hand, follows the same base [feature engineering](freqai-feature-engineering.md) with `populate_any_indicators` as a typical Regressor:
-
-```python
-    def populate_any_indicators(
-        self, pair, df, tf, informative=None, set_generalized_indicators=False
-    ):
-
-        coin = pair.split('/')[0]
-
-        if informative is None:
-            informative = self.dp.get_pair_dataframe(pair, tf)
-
-        # first loop is automatically duplicating indicators for time periods
-        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-
-            t = int(t)
-            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
-
-        # The following features are necessary for RL models
-        informative[f"%-{coin}raw_close"] = informative["close"]
-        informative[f"%-{coin}raw_open"] = informative["open"]
-        informative[f"%-{coin}raw_high"] = informative["high"]
-        informative[f"%-{coin}raw_low"] = informative["low"]
-
-        indicators = [col for col in informative if col.startswith("%")]
-        # This loop duplicates and shifts all indicators to add a sense of recency to data
-        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
-            if n == 0:
-                continue
-            informative_shift = informative[indicators].shift(n)
-            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
-            informative = pd.concat((informative, informative_shift), axis=1)
-
-        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
-        skip_columns = [
-            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
-        ]
-        df = df.drop(columns=skip_columns)
-
-        # Add generalized indicators here (because in live, it will call this
-        # function to populate indicators during training). Notice how we ensure not to
-        # add them multiple times
-        if set_generalized_indicators:
-
-            # For RL, there are no direct targets to set. This is filler (neutral)
-            # until the agent sends an action.
-            df["&-action"] = 0
-
-        return df
-```
-
-Most of the function remains the same as for typical Regressors, however, the function above shows how the strategy must pass the raw price data to the agent so that it has access to raw OHLCV in the training environent:
-
-```python
-        # The following features are necessary for RL models
-        informative[f"%-{coin}raw_close"] = informative["close"]
-        informative[f"%-{coin}raw_open"] = informative["open"]
-        informative[f"%-{coin}raw_high"] = informative["high"]
-        informative[f"%-{coin}raw_low"] = informative["low"]
-```
-
-Finally, there is no explicit "label" to make - instead the you need to assign the `&-action` column which will contain the agent's actions when accessed in `populate_entry/exit_trends()`. In the present example, the user set the neutral action to 0. This value should align with the environment used. FreqAI provides two environments, both use 0 as the neutral action.
-
-After users realize there are no labels to set, they will soon understand that the agent is making its "own" entry and exit decisions. This makes strategy construction rather simple. The entry and exit signals come from the agent in the form of an integer - which are used directly to decide entries and exits in the strategy:
-
-```python
-    def populate_entry_trend(self, df: DataFrame, metadata: dict) -> DataFrame:
-
-        enter_long_conditions = [df["do_predict"] == 1, df["&-action"] == 1]
-
-        if enter_long_conditions:
-            df.loc[
-                reduce(lambda x, y: x & y, enter_long_conditions), ["enter_long", "enter_tag"]
-            ] = (1, "long")
-
-        enter_short_conditions = [df["do_predict"] == 1, df["&-action"] == 3]
-
-        if enter_short_conditions:
-            df.loc[
-                reduce(lambda x, y: x & y, enter_short_conditions), ["enter_short", "enter_tag"]
-            ] = (1, "short")
-
-        return df
-
-    def populate_exit_trend(self, df: DataFrame, metadata: dict) -> DataFrame:
-        exit_long_conditions = [df["do_predict"] == 1, df["&-action"] == 2]
-        if exit_long_conditions:
-            df.loc[reduce(lambda x, y: x & y, exit_long_conditions), "exit_long"] = 1
-
-        exit_short_conditions = [df["do_predict"] == 1, df["&-action"] == 4]
-        if exit_short_conditions:
-            df.loc[reduce(lambda x, y: x & y, exit_short_conditions), "exit_short"] = 1
-
-        return df
-```
-
-It is important to consider that `&-action` depends on which environment they choose to use. The example above shows 5 actions, where 0 is neutral, 1 is enter long, 2 is exit long, 3 is enter short and 4 is exit short. 
-
-## Configuring the Reinforcement Learner
-
-In order to configure the `Reinforcement Learner` the following dictionary to their `freqai` config:
-
-```json
-        "rl_config": {
-            "train_cycles": 25,
-            "max_trade_duration_candles": 300,
-            "max_training_drawdown_pct": 0.02,
-            "cpu_count": 8,
-            "model_type": "PPO",
-            "policy_type": "MlpPolicy",
-            "model_reward_parameters": {
-                "rr": 1,
-                "profit_aim": 0.025
-            }
-        }
-```
-
-Parameter details can be found [here](freqai-parameter-table.md), but in general the `train_cycles` decides how many times the agent should cycle through the candle data in its artificial environemtn to train weights in the model. `model_type` is a string which selects one of the available models in [stable_baselines](https://stable-baselines3.readthedocs.io/en/master/)(external link). 
-
-## Creating the reward
-
-As users begin to modify the strategy and the prediction model, they will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, the user sets a `calculate_reward()` function inside their custom `ReinforcementLearner.py` file. A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to give users the necessary building blocks to start their own models. It is inside the `calculate_reward()` where users express their creative theories about the market. For example, the user wants to reward their agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, the user wishes to reward the agnet for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
-
-```python
-    class MyRLEnv(Base5ActionRLEnv):
-        """
-        User made custom environment. This class inherits from BaseEnvironment and gym.env.
-        Users can override any functions from those parent classes. Here is an example
-        of a user customized `calculate_reward()` function.
-        """
-        def calculate_reward(self, action):
-            # first, penalize if the action is not valid
-            if not self._is_valid(action):
-                return -2
-            pnl = self.get_unrealized_profit()
-
-            factor = 100
-            # reward agent for entering trades
-            if action in (Actions.Long_enter.value, Actions.Short_enter.value) \
-                    and self._position == Positions.Neutral:
-                return 25
-            # discourage agent from not entering trades
-            if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                return -1
-            max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-            trade_duration = self._current_tick - self._last_trade_tick
-            if trade_duration <= max_trade_duration:
-                factor *= 1.5
-            elif trade_duration > max_trade_duration:
-                factor *= 0.5
-            # discourage sitting in position
-            if self._position in (Positions.Short, Positions.Long) and \
-               action == Actions.Neutral.value:
-                return -1 * trade_duration / max_trade_duration
-            # close long
-            if action == Actions.Long_exit.value and self._position == Positions.Long:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(pnl * factor)
-            # close short
-            if action == Actions.Short_exit.value and self._position == Positions.Short:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(pnl * factor)
-            return 0.
-```
-
-### Creating a custom agent
-
-Users can inherit from `stable_baselines3` and customize anything they wish about their agent. Doing this is for advanced users only, an example is presented in `freqai/RL/ReinforcementLearnerCustomAgent.py`
-
-### Using Tensorboard
-
-Reinforcement Learning models benefit from tracking training metrics. FreqAI has integrated Tensorboard to allow users to track training and evaluation performance across all coins and across all retrainings. To start, the user should ensure Tensorboard is installed on their computer:
-
-```bash
-pip3 install tensorboard
-```
-
-Next, the user can activate Tensorboard with the following command:
-
-```bash
-cd freqtrade
-tensorboard --logdir user_data/models/unique-id
-```
-
-where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if the user wishes to view the output in their browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
-
-![tensorboard](assets/tensorboard.png)

docs/freqai-running.md

@@ -73,12 +73,24 @@ Backtesting mode requires [downloading the necessary data](#downloading-data-to-
 
 To allow for tweaking your strategy (**not** the features!), FreqAI will automatically save the predictions during backtesting so that they can be reused for future backtests and live runs using the same `identifier` model. This provides a performance enhancement geared towards enabling **high-level hyperopting** of entry/exit criteria.
 
-An additional directory called `predictions`, which contains all the predictions stored in `hdf` format, will be created in the `unique-id` folder.
+An additional directory called `backtesting_predictions`, which contains all the predictions stored in `hdf` format, will be created in the `unique-id` folder.
 
 To change your **features**, you **must** set a new `identifier` in the config to signal to FreqAI to train new models.
 
 To save the models generated during a particular backtest so that you can start a live deployment from one of them instead of training a new model, you must set `save_backtest_models` to `True` in the config.
 
+### Backtest live models
+
+FreqAI allow you to reuse ready models through the backtest parameter `--freqai-backtest-live-models`. This can be useful when you want to reuse models generated in dry/run for comparison or other study. For that, you must set `"purge_old_models"` to `True` in the config.
+
+The `--timerange` parameter must not be informed, as it will be automatically calculated through the training end dates of the models.
+
+Each model has an identifier derived from the training end date. If you have only 1 model trained, FreqAI will backtest from the training end date until the current date. If you have more than 1 model, each model will perform the backtesting according to the training end date until the training end date of the next model and so on. For the last model, the period of the previous model will be used for the execution.
+
+!!! Note
+    Currently, there is no checking for expired models, even if the `expired_hours` parameter is set.
+
+
 ### Downloading data to cover the full backtest period
 
 For live/dry deployments, FreqAI will download the necessary data automatically. However, to use backtesting functionality, you need to download the necessary data using `download-data` (details [here](data-download.md#data-downloading)). You need to pay careful attention to understanding how much *additional* data needs to be downloaded to ensure that there is a sufficient amount of training data *before* the start of the backtesting time range. The amount of additional data can be roughly estimated by moving the start date of the time range backwards by `train_period_days` and the `startup_candle_count` (see the [parameter table](freqai-parameter-table.md) for detailed descriptions of these parameters) from the beginning of the desired backtesting time range. 
@@ -142,15 +154,32 @@ dataframe['outlier'] = np.where(dataframe['DI_values'] > self.di_max.value/10, 1
 
 This specific hyperopt would help you understand the appropriate `DI_values` for your particular parameter space.
 
+## Using Tensorboard
+
+CatBoost models benefit from tracking training metrics via Tensorboard. You can take advantage of the FreqAI integration to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
+
+```bash
+cd freqtrade
+tensorboard --logdir user_data/models/unique-id
+```
+
+where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if you wish to view the output in your browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
+
+![tensorboard](assets/tensorboard.jpg)
+
 ## Setting up a follower
 
 You can indicate to the bot that it should not train models, but instead should look for models trained by a leader with a specific `identifier` by defining:
 
 ```json
     "freqai": {
+        "enabled": true,
         "follow_mode": true,
-        "identifier": "example"
+        "identifier": "example",
+        "feature_parameters": {
+        // leader bots feature_parameters inserted here 
+        },
     }
 ```
 
-In this example, the user has a leader bot with the `"identifier": "example"`. The leader bot is already running or is launched simultaneously with the follower. The follower will load models created by the leader and inference them to obtain predictions instead of training its own models.
+In this example, the user has a leader bot with the `"identifier": "example"`. The leader bot is already running or is launched simultaneously with the follower. The follower will load models created by the leader and inference them to obtain predictions instead of training its own models. The user will also need to duplicate the `feature_parameters` parameters from from the leaders freqai configuration file into the freqai section of the followers config. 

docs/freqai.md

@@ -4,7 +4,7 @@
 
 ## Introduction
 
-FreqAI is a software designed to automate a variety of tasks associated with training a predictive machine learning model to generate market forecasts given a set of input features.
+FreqAI is a software designed to automate a variety of tasks associated with training a predictive machine learning model to generate market forecasts given a set of input signals. In general, the FreqAI aims to be a sand-box for easily deploying robust machine-learning libraries on real-time data ([details])(#freqai-position-in-open-source-machine-learning-landscape).
 
 Features include:
 
@@ -72,6 +72,11 @@ pip install -r requirements-freqai.txt
 
 If you are using docker, a dedicated tag with FreqAI dependencies is available as `:freqai`. As such - you can replace the image line in your docker-compose file with `image: freqtradeorg/freqtrade:develop_freqai`. This image contains the regular FreqAI dependencies. Similar to native installs, Catboost will not be available on ARM based devices.
 
+
+### FreqAI position in open-source machine learning landscape
+
+Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`) has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citzen scientists" to use their basic Python skills for data-exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data-collection, storage, and handling presents a disparate challenge. [`FreqAI`](#freqai) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
+
 ## Common pitfalls
 
 FreqAI cannot be combined with dynamic `VolumePairlists` (or any pairlist filter that adds and removes pairs dynamically).

docs/includes/pairlists.md

@@ -268,7 +268,7 @@ This option is disabled by default, and will only apply if set to > 0.
 The `max_value` setting removes pairs where the minimum value change is above a specified value.
 This is useful when an exchange has unbalanced limits. For example, if step-size = 1 (so you can only buy 1, or 2, or 3, but not 1.1 Coins) - and the price is pretty high (like 20\$) as the coin has risen sharply since the last limit adaption.
 As a result of the above, you can only buy for 20\$, or 40\$ - but not for 25\$.
-On exchanges that deduct fees from the receiving currency (e.g. FTX) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.
+On exchanges that deduct fees from the receiving currency (e.g. binance) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.
 
 The `low_price_ratio` setting removes pairs where a raise of 1 price unit (pip) is above the `low_price_ratio` ratio.
 This option is disabled by default, and will only apply if set to > 0.
@@ -286,6 +286,18 @@ Min price precision for SHITCOIN/BTC is 8 decimals. If its price is 0.00000011 -
 
 Shuffles (randomizes) pairs in the pairlist. It can be used for preventing the bot from trading some of the pairs more frequently then others when you want all pairs be treated with the same priority.
 
+By default, ShuffleFilter will shuffle pairs once per candle.
+To shuffle on every iteration, set `"shuffle_frequency"` to `"iteration"` instead of  the default of `"candle"`.
+
+``` json
+    {
+        "method": "ShuffleFilter", 
+        "shuffle_frequency": "candle",
+        "seed": 42
+    }
+
+```
+
 !!! Tip
     You may set the `seed` value for this Pairlist to obtain reproducible results, which can be useful for repeated backtesting sessions. If `seed` is not set, the pairs are shuffled in the non-repeatable random order. ShuffleFilter will automatically detect runmodes and apply the `seed` only for backtesting modes - if a `seed` value is set.
 

docs/index.md

@@ -32,7 +32,7 @@ Freqtrade is a free and open source crypto trading bot written in Python. It is
 - Run: Test your strategy with simulated money (Dry-Run mode) or deploy it with real money (Live-Trade mode).
 - Run using Edge (optional module): The concept is to find the best historical [trade expectancy](edge.md#expectancy) by markets based on variation of the stop-loss and then allow/reject markets to trade. The sizing of the trade is based on a risk of a percentage of your capital.
 - Control/Monitor: Use Telegram or a WebUI (start/stop the bot, show profit/loss, daily summary, current open trades results, etc.).
-- Analyse: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
+- Analyze: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
 
 ## Supported exchange marketplaces
 
@@ -40,7 +40,6 @@ Please read the [exchange specific notes](exchanges.md) to learn about eventual,
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
-- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
 - [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
@@ -51,7 +50,7 @@ Please read the [exchange specific notes](exchanges.md) to learn about eventual,
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
-- [X] [OKX](https://okx.com/).
+- [X] [OKX](https://okx.com/)
 
 Please make sure to read the [exchange specific notes](exchanges.md), as well as the [trading with leverage](leverage.md) documentation before diving in.
 

docs/producer-consumer.md

@@ -21,6 +21,7 @@ Enable subscribing to an instance by adding the `external_message_consumer` sect
                 "name": "default", // This can be any name you'd like, default is "default"
                 "host": "127.0.0.1", // The host from your producer's api_server config
                 "port": 8080, // The port from your producer's api_server config
+                "secure": false, // Use a secure websockets connection, default false
                 "ws_token": "sercet_Ws_t0ken" // The ws_token from your producer's api_server config
             }
         ],
@@ -42,6 +43,7 @@ Enable subscribing to an instance by adding the `external_message_consumer` sect
 | `producers.name` | **Required.** Name of this producer. This name must be used in calls to `get_producer_pairs()` and `get_producer_df()` if more than one producer is used.<br> **Datatype:** string
 | `producers.host` | **Required.** The hostname or IP address from your producer.<br> **Datatype:** string
 | `producers.port` | **Required.** The port matching the above host.<br> **Datatype:** string
+| `producers.secure` | **Optional.**  Use ssl in websockets connection. Default False.<br> **Datatype:** string
 | `producers.ws_token` | **Required.**  `ws_token` as configured on the producer.<br> **Datatype:** string
 | | **Optional settings**
 | `wait_timeout` | Timeout until we ping again if no message is received. <br>*Defaults to `300`.*<br> **Datatype:** Integer - in seconds.

docs/requirements-docs.txt

@@ -1,6 +1,6 @@
 markdown==3.3.7
-mkdocs==1.4.0
-mkdocs-material==8.5.6
+mkdocs==1.4.2
+mkdocs-material==8.5.10
 mdx_truly_sane_lists==1.3
-pymdown-extensions==9.6
+pymdown-extensions==9.8
 jinja2==3.1.2

docs/rest-api.md

@@ -389,6 +389,44 @@ Now anytime those types of RPC messages are sent in the bot, you will receive th
 }
 ```
 
+#### Reverse Proxy setup
+
+When using [Nginx](https://nginx.org/en/docs/), the following configuration is required for WebSockets to work (Note this configuration is incomplete, it's missing some information and can not be used as is):
+
+Please make sure to replace `<freqtrade_listen_ip>` (and the subsequent port) with the IP and Port matching your configuration/setup.
+
+```
+http {
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        '' close;
+    }
+
+    #...
+
+    server {
+        #...
+
+        location / {
+            proxy_http_version 1.1;
+            proxy_pass http://<freqtrade_listen_ip>:8080;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header Host $host;
+        }
+    }
+}
+```
+
+To properly configure your reverse proxy (securely), please consult it's documentation for proxying websockets.
+
+- **Traefik**: Traefik supports websockets out of the box, see the [documentation](https://doc.traefik.io/traefik/)
+- **Caddy**: Caddy v2 supports websockets out of the box, see the [documentation](https://caddyserver.com/docs/v2-upgrade#proxy)
+
+!!! Tip "SSL certificates"
+    You can use tools like certbot to setup ssl certificates to access your bot's UI through encrypted connection by using any fo the above reverse proxies.
+    While this will protect your data in transit, we do not recommend to run the freqtrade API outside of your private network (VPN, SSH tunnel).
+
 ### OpenAPI interface
 
 To enable the builtin openAPI interface (Swagger UI), specify `"enable_openapi": true` in the api_server configuration.

docs/stoploss.md

@@ -24,7 +24,7 @@ These modes can be configured with these values:
 ```
 
 !!! Note
-    Stoploss on exchange is only supported for Binance (stop-loss-limit), Huobi (stop-limit), Kraken (stop-loss-market, stop-loss-limit), FTX (stop limit and stop-market) Gateio (stop-limit), and Kucoin (stop-limit and stop-market) as of now.  
+    Stoploss on exchange is only supported for Binance (stop-loss-limit), Huobi (stop-limit), Kraken (stop-loss-market, stop-loss-limit), Gateio (stop-limit), and Kucoin (stop-limit and stop-market) as of now.  
     <ins>Do not set too low/tight stoploss value if using stop loss on exchange!</ins>  
     If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work.
 
@@ -87,7 +87,7 @@ At this stage the bot contains the following stoploss support modes:
 2. Trailing stop loss.
 3. Trailing stop loss, custom positive loss.
 4. Trailing stop loss only once the trade has reached a certain offset.
-5. [Custom stoploss function](strategy-advanced.md#custom-stoploss)
+5. [Custom stoploss function](strategy-callbacks.md#custom-stoploss)
 
 ### Static Stop Loss
 

docs/strategy-callbacks.md

@@ -159,6 +159,7 @@ The stoploss price can only ever move upwards - if the stoploss value returned f
 
 The method must return a stoploss value (float / number) as a percentage of the current price.
 E.g. If the `current_rate` is 200 USD, then returning `0.02` will set the stoploss price 2% lower, at 196 USD.
+During backtesting, `current_rate` (and `current_profit`) are provided against the candle's high (or low for short trades) - while the resulting stoploss is evaluated against the candle's low (or high for short trades).
 
 The absolute value of the return value is used (the sign is ignored), so returning `0.05` or `-0.05` have the same result, a stoploss 5% below the current price.
 

docs/strategy-customization.md

@@ -446,15 +446,17 @@ A full sample can be found [in the DataProvider section](#complete-data-provider
 
 ??? Note "Alternative candle types"
     Informative_pairs can also provide a 3rd tuple element defining the candle type explicitly.
-    Availability of alternative candle-types will depend on the trading-mode and the exchange. Details about this can be found in the exchange documentation.
+    Availability of alternative candle-types will depend on the trading-mode and the exchange. 
+    In general, spot pairs cannot be used in futures markets, and futures candles can't be used as informative pairs for spot bots.
+    Details about this may vary, if they do, this can be found in the exchange documentation.
 
     ``` python
     def informative_pairs(self):
         return [
-            ("ETH/USDT", "5m", ""),   # Uses default candletype, depends on trading_mode 
-            ("ETH/USDT", "5m", "spot"),   # Forces usage of spot candles
-            ("BTC/TUSD", "15m", "futures"),  # Uses futures candles
-            ("BTC/TUSD", "15m", "mark"),  # Uses mark candles
+            ("ETH/USDT", "5m", ""),   # Uses default candletype, depends on trading_mode (recommended)
+            ("ETH/USDT", "5m", "spot"),   # Forces usage of spot candles (only valid for bots running on spot markets).
+            ("BTC/TUSD", "15m", "futures"),  # Uses futures candles (only bots with `trading_mode=futures`)
+            ("BTC/TUSD", "15m", "mark"),  # Uses mark candles (only bots with `trading_mode=futures`)
         ]
     ```
 ***
@@ -655,13 +657,13 @@ This is where calling `self.dp.current_whitelist()` comes in handy.
 # fetch live / historical candle (OHLCV) data for the first informative pair
 inf_pair, inf_timeframe = self.informative_pairs()[0]
 informative = self.dp.get_pair_dataframe(pair=inf_pair,
-                                            timeframe=inf_timeframe)
+                                         timeframe=inf_timeframe)
 ```
 
 !!! Warning "Warning about backtesting"
-    Be careful when using dataprovider in backtesting. `historic_ohlcv()` (and `get_pair_dataframe()`
-    for the backtesting runmode) provides the full time-range in one go,
-    so please be aware of it and make sure to not "look into the future" to avoid surprises when running in dry/live mode.
+    In backtesting, `dp.get_pair_dataframe()` behavior differs depending on where it's called.
+    Within `populate_*()` methods, `dp.get_pair_dataframe()` returns the full timerange. Please make sure to not "look into the future" to avoid surprises when running in dry/live mode.
+    Within [callbacks](strategy-callbacks.md), you'll get the full timerange up to the current (simulated) candle.
 
 ### *get_analyzed_dataframe(pair, timeframe)*
 
@@ -670,13 +672,13 @@ It can also be used in specific callbacks to get the signal that caused the acti
 
 ``` python
 # fetch current dataframe
-if self.dp.runmode.value in ('live', 'dry_run'):
-    dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
-                                                                timeframe=self.timeframe)
+dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
+                                                         timeframe=self.timeframe)
 ```
 
 !!! Note "No data available"
     Returns an empty dataframe if the requested pair was not cached.
+    You can check for this with `if dataframe.empty:` and handle this case accordingly.
     This should not happen when using whitelisted pairs.
 
 ### *orderbook(pair, maximum)*
@@ -723,7 +725,7 @@ if self.dp.runmode.value in ('live', 'dry_run'):
 
 !!! Warning
     Although the ticker data structure is a part of the ccxt Unified Interface, the values returned by this method can
-    vary for different exchanges. For instance, many exchanges do not return `vwap` values, the FTX exchange
+    vary for different exchanges. For instance, many exchanges do not return `vwap` values, some exchanges
     does not always fills in the `last` field (so it can be None), etc. So you need to carefully verify the ticker
     data returned from the exchange and add appropriate error handling / defaults.
 

docs/strategy_migration.md

@@ -43,19 +43,25 @@ Note : `forcesell`, `forcebuy`, `emergencysell` are changed to `force_exit`, `fo
   * `order_time_in_force` buy -> entry, sell -> exit.
   * `order_types` buy -> entry, sell -> exit.
   * `unfilledtimeout` buy -> entry, sell -> exit.
+  * `ignore_buying_expired_candle_after` -> moved to root level instead of "ask_strategy/exit_pricing"
 * Terminology changes
   * Sell reasons changed to reflect the new naming of "exit" instead of sells. Be careful in your strategy if you're using `exit_reason` checks and eventually update your strategy.
     * `sell_signal` -> `exit_signal`
     * `custom_sell` -> `custom_exit`
     * `force_sell` -> `force_exit`
     * `emergency_sell` -> `emergency_exit`
+  * Order pricing
+    * `bid_strategy` -> `entry_pricing`
+    * `ask_strategy` -> `exit_pricing`
+    * `ask_last_balance` -> `price_last_balance`
+    * `bid_last_balance` -> `price_last_balance`
   * Webhook terminology changed from "sell" to "exit", and from "buy" to entry
-    * `webhookbuy` -> `webhookentry`
-    * `webhookbuyfill` -> `webhookentryfill`
-    * `webhookbuycancel` -> `webhookentrycancel`
-    * `webhooksell` -> `webhookexit`
-    * `webhooksellfill` -> `webhookexitfill`
-    * `webhooksellcancel` -> `webhookexitcancel`
+    * `webhookbuy` -> `entry`
+    * `webhookbuyfill` -> `entry_fill`
+    * `webhookbuycancel` -> `entry_cancel`
+    * `webhooksell` -> `exit`
+    * `webhooksellfill` -> `exit_fill`
+    * `webhooksellcancel` -> `exit_cancel`
   * Telegram notification settings
     * `buy` -> `entry`
     * `buy_fill` -> `entry_fill`
@@ -443,6 +449,7 @@ Please refer to the [pricing documentation](configuration.md#prices-used-for-ord
         "use_order_book": true,
         "order_book_top": 1,
         "bid_last_balance": 0.0
+        "ignore_buying_expired_candle_after": 120
     }
 }
 ```
@@ -466,6 +473,7 @@ after:
         "use_order_book": true,
         "order_book_top": 1,
         "price_last_balance": 0.0
-    }
+    },
+    "ignore_buying_expired_candle_after": 120
 }
 ```

docs/telegram-usage.md

@@ -77,6 +77,7 @@ Example configuration showing the different settings:
     "enabled": true,
     "token": "your_telegram_token",
     "chat_id": "your_telegram_chat_id",
+    "allow_custom_messages": true,
     "notification_settings": {
         "status": "silent",
         "warning": "on",
@@ -115,6 +116,7 @@ Example configuration showing the different settings:
 `show_candle` - show candle values as part of entry/exit messages. Only possible values are `"ohlc"` or `"off"`.
 
 `balance_dust_level` will define what the `/balance` command takes as "dust" - Currencies with a balance below this will be shown.
+`allow_custom_messages` completely disable strategy messages.
 `reload` allows you to disable reload-buttons on selected messages.
 
 ## Create a custom keyboard (command shortcut buttons)

docs/utils.md

@@ -169,6 +169,43 @@ Example: Search dedicated strategy path.
 freqtrade list-strategies --strategy-path ~/.freqtrade/strategies/
 ```
 
+## List freqAI models
+
+Use the `list-freqaimodels` subcommand to see all freqAI models available.
+
+This subcommand is useful for finding problems in your environment with loading freqAI models: modules with models that contain errors and failed to load are printed in red (LOAD FAILED), while models with duplicate names are printed in yellow (DUPLICATE NAME).
+
+```
+usage: freqtrade list-freqaimodels [-h] [-v] [--logfile FILE] [-V] [-c PATH]
+                                   [-d PATH] [--userdir PATH]
+                                   [--freqaimodel-path PATH] [-1] [--no-color]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --freqaimodel-path PATH
+                        Specify additional lookup path for freqaimodels.
+  -1, --one-column      Print output in one column.
+  --no-color            Disable colorization of hyperopt results. May be
+                        useful if you are redirecting output to a file.
+
+Common arguments:
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified. Special values are:
+                        'syslog', 'journald'. See the documentation for more
+                        details.
+  -V, --version         show program's version number and exit
+  -c PATH, --config PATH
+                        Specify configuration file (default:
+                        `userdir/config.json` or `config.json` whichever
+                        exists). Multiple --config options may be used. Can be
+                        set to `-` to read config from stdin.
+  -d PATH, --datadir PATH, --data-dir PATH
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
+
+```
+
 ## List Exchanges
 
 Use the `list-exchanges` subcommand to see the exchanges available for the bot.
@@ -226,7 +263,6 @@ equos            True     missing opt: fetchTicker, fetchTickers
 eterbase         True
 fcoin            True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp          True     missing opt: fetchMyTrades, fetchTickers
-ftx              True
 gateio           True
 gemini           True
 gopax            True
@@ -332,7 +368,6 @@ fcoin               True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp             True     missing opt: fetchMyTrades, fetchTickers
 flowbtc             False    missing: fetchOrder, fetchOHLCV
 foxbit              False    missing: fetchOrder, fetchOHLCV
-ftx                 True
 gateio              True
 gemini              True
 gopax               True

docs/webhook-config.md

@@ -10,37 +10,37 @@ Sample configuration (tested using IFTTT).
   "webhook": {
         "enabled": true,
         "url": "https://maker.ifttt.com/trigger/<YOUREVENT>/with/key/<YOURKEY>/",
-        "webhookentry": {
+        "entry": {
             "value1": "Buying {pair}",
             "value2": "limit {limit:8f}",
             "value3": "{stake_amount:8f} {stake_currency}"
         },
-        "webhookentrycancel": {
+        "entry_cancel": {
             "value1": "Cancelling Open Buy Order for {pair}",
             "value2": "limit {limit:8f}",
             "value3": "{stake_amount:8f} {stake_currency}"
         },
-         "webhookentryfill": {
+         "entry_fill": {
             "value1": "Buy Order for {pair} filled",
             "value2": "at {open_rate:8f}",
             "value3": ""
         },
-        "webhookexit": {
+        "exit": {
             "value1": "Exiting {pair}",
             "value2": "limit {limit:8f}",
             "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
         },
-        "webhookexitcancel": {
+        "exit_cancel": {
             "value1": "Cancelling Open Exit Order for {pair}",
             "value2": "limit {limit:8f}",
             "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
         },
-        "webhookexitfill": {
+        "exit_fill": {
             "value1": "Exit Order for {pair} filled",
             "value2": "at {close_rate:8f}.",
             "value3": ""
         },
-        "webhookstatus": {
+        "status": {
             "value1": "Status: {status}",
             "value2": "",
             "value3": ""
@@ -57,7 +57,7 @@ You can set the POST body format to Form-Encoded (default), JSON-Encoded, or raw
         "enabled": true,
         "url": "https://<YOURSUBDOMAIN>.cloud.mattermost.com/hooks/<YOURHOOK>",
         "format": "json",
-        "webhookstatus": {
+        "status": {
             "text": "Status: {status}"
         }
     },
@@ -88,17 +88,30 @@ Optional parameters are available to enable automatic retries for webhook messag
         "url": "https://<YOURHOOKURL>",
         "retries": 3,
         "retry_delay": 0.2,
-        "webhookstatus": {
+        "status": {
             "status": "Status: {status}"
         }
     },
 ```
 
+Custom messages can be sent to Webhook endpoints via the `self.dp.send_msg()` function from within the strategy. To enable this, set the `allow_custom_messages` option to `true`:
+
+```json
+  "webhook": {
+        "enabled": true,
+        "url": "https://<YOURHOOKURL>",
+        "allow_custom_messages": true,
+        "strategy_msg": {
+            "status": "StrategyMessage: {msg}"
+        }
+    },
+```
+
 Different payloads can be configured for different events. Not all fields are necessary, but you should configure at least one of the dicts, otherwise the webhook will never be called.
 
-### Webhookentry
+### Entry
 
-The fields in `webhook.webhookentry` are filled when the bot executes a long/short. Parameters are filled using string.format.
+The fields in `webhook.entry` are filled when the bot executes a long/short. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -118,9 +131,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Webhookentrycancel
+### Entry cancel
 
-The fields in `webhook.webhookentrycancel` are filled when the bot cancels a long/short order. Parameters are filled using string.format.
+The fields in `webhook.entry_cancel` are filled when the bot cancels a long/short order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -139,9 +152,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Webhookentryfill
+### Entry fill
 
-The fields in `webhook.webhookentryfill` are filled when the bot filled a long/short order. Parameters are filled using string.format.
+The fields in `webhook.entry_fill` are filled when the bot filled a long/short order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -160,9 +173,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Webhookexit
+### Exit
 
-The fields in `webhook.webhookexit` are filled when the bot exits a trade. Parameters are filled using string.format.
+The fields in `webhook.exit` are filled when the bot exits a trade. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -184,9 +197,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Webhookexitfill
+### Exit fill
 
-The fields in `webhook.webhookexitfill` are filled when the bot fills a exit order (closes a Trade). Parameters are filled using string.format.
+The fields in `webhook.exit_fill` are filled when the bot fills a exit order (closes a Trade). Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -209,9 +222,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Webhookexitcancel
+### Exit cancel
 
-The fields in `webhook.webhookexitcancel` are filled when the bot cancels a exit order. Parameters are filled using string.format.
+The fields in `webhook.exit_cancel` are filled when the bot cancels a exit order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -234,9 +247,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Webhookstatus
+### Status
 
-The fields in `webhook.webhookstatus` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
+The fields in `webhook.status` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
 
 The only possible value here is `{status}`.
 
@@ -280,7 +293,6 @@ You can configure this as follows:
 }
 ```
 
-
 The above represents the default (`exit_fill` and `entry_fill` are optional and will default to the above configuration) - modifications are obviously possible.
 
 Available fields correspond to the fields for webhooks and are documented in the corresponding webhook sections.
@@ -288,3 +300,13 @@ Available fields correspond to the fields for webhooks and are documented in the
 The notifications will look as follows by default.
 
 ![discord-notification](assets/discord_notification.png)
+
+Custom messages can be sent from a strategy to Discord endpoints via the dataprovider.send_msg() function. To enable this, set the `allow_custom_messages` option to `true`:
+
+```json
+  "discord": {
+        "enabled": true,
+        "webhook_url": "https://discord.com/api/webhooks/<Your webhook URL ...>",
+        "allow_custom_messages": true,
+    },
+```

docs/windows_installation.md

@@ -3,15 +3,16 @@
 We **strongly** recommend that Windows users use [Docker](docker_quickstart.md) as this will work much easier and smoother (also more secure).
 
 If that is not possible, try using the Windows Linux subsystem (WSL) - for which the Ubuntu instructions should work.
-Otherwise, try the instructions below.
+Otherwise, please follow the instructions below.
 
 ## Install freqtrade manually
 
-!!! Note
-    Make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.
+!!! Note "64bit Python version"
+    Please make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.
+    32bit python versions are no longer supported under Windows.
 
 !!! Hint
-    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#Anaconda) in this document for more information.
+    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#installation-with-conda) in the documentation for more information.
 
 ### 1. Clone the git repository
 

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ Freqtrade bot """
-__version__ = '2022.10.dev'
+__version__ = '2022.11'
 
 if 'dev' in __version__:
     try:
@@ -16,6 +16,6 @@ if 'dev' in __version__:
             from pathlib import Path
             versionfile = Path('./freqtrade_commit')
             if versionfile.is_file():
-                __version__ = f"docker-{versionfile.read_text()[:8]}"
+                __version__ = f"docker-{__version__}-{versionfile.read_text()[:8]}"
         except Exception:
             pass

freqtrade/commands/__init__.py

@@ -15,9 +15,9 @@ from freqtrade.commands.db_commands import start_convert_db
 from freqtrade.commands.deploy_commands import (start_create_userdir, start_install_ui,
                                                 start_new_strategy)
 from freqtrade.commands.hyperopt_commands import start_hyperopt_list, start_hyperopt_show
-from freqtrade.commands.list_commands import (start_list_exchanges, start_list_markets,
-                                              start_list_strategies, start_list_timeframes,
-                                              start_show_trades)
+from freqtrade.commands.list_commands import (start_list_exchanges, start_list_freqAI_models,
+                                              start_list_markets, start_list_strategies,
+                                              start_list_timeframes, start_show_trades)
 from freqtrade.commands.optimize_commands import (start_backtesting, start_backtesting_show,
                                                   start_edge, start_hyperopt)
 from freqtrade.commands.pairlist_commands import start_test_pairlist

freqtrade/commands/arguments.py

@@ -25,7 +25,8 @@ ARGS_COMMON_OPTIMIZE = ["timeframe", "timerange", "dataformat_ohlcv",
 ARGS_BACKTEST = ARGS_COMMON_OPTIMIZE + ["position_stacking", "use_max_market_positions",
                                         "enable_protections", "dry_run_wallet", "timeframe_detail",
                                         "strategy_list", "export", "exportfilename",
-                                        "backtest_breakdown", "backtest_cache"]
+                                        "backtest_breakdown", "backtest_cache",
+                                        "freqai_backtest_live_models"]
 
 ARGS_HYPEROPT = ARGS_COMMON_OPTIMIZE + ["hyperopt", "hyperopt_path",
                                         "position_stacking", "use_max_market_positions",
@@ -41,6 +42,8 @@ ARGS_EDGE = ARGS_COMMON_OPTIMIZE + ["stoploss_range"]
 ARGS_LIST_STRATEGIES = ["strategy_path", "print_one_column", "print_colorized",
                         "recursive_strategy_search"]
 
+ARGS_LIST_FREQAIMODELS = ["freqaimodel_path", "print_one_column", "print_colorized"]
+
 ARGS_LIST_HYPEROPTS = ["hyperopt_path", "print_one_column", "print_colorized"]
 
 ARGS_BACKTEST_SHOW = ["exportfilename", "backtest_show_pair_list"]
@@ -106,8 +109,8 @@ ARGS_ANALYZE_ENTRIES_EXITS = ["exportfilename", "analysis_groups", "enter_reason
                               "exit_reason_list", "indicator_list"]
 
 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
-                    "list-markets", "list-pairs", "list-strategies", "list-data",
-                    "hyperopt-list", "hyperopt-show", "backtest-filter",
+                    "list-markets", "list-pairs", "list-strategies", "list-freqaimodels",
+                    "list-data", "hyperopt-list", "hyperopt-show", "backtest-filter",
                     "plot-dataframe", "plot-profit", "show-trades", "trades-to-ohlcv"]
 
 NO_CONF_ALLOWED = ["create-userdir", "list-exchanges", "new-strategy"]
@@ -192,10 +195,11 @@ class Arguments:
                                         start_create_userdir, start_download_data, start_edge,
                                         start_hyperopt, start_hyperopt_list, start_hyperopt_show,
                                         start_install_ui, start_list_data, start_list_exchanges,
-                                        start_list_markets, start_list_strategies,
-                                        start_list_timeframes, start_new_config, start_new_strategy,
-                                        start_plot_dataframe, start_plot_profit, start_show_trades,
-                                        start_test_pairlist, start_trading, start_webserver)
+                                        start_list_freqAI_models, start_list_markets,
+                                        start_list_strategies, start_list_timeframes,
+                                        start_new_config, start_new_strategy, start_plot_dataframe,
+                                        start_plot_profit, start_show_trades, start_test_pairlist,
+                                        start_trading, start_webserver)
 
         subparsers = self.parser.add_subparsers(dest='command',
                                                 # Use custom message when no subhandler is added
@@ -362,6 +366,15 @@ class Arguments:
         list_strategies_cmd.set_defaults(func=start_list_strategies)
         self._build_args(optionlist=ARGS_LIST_STRATEGIES, parser=list_strategies_cmd)
 
+        # Add list-freqAI Models subcommand
+        list_freqaimodels_cmd = subparsers.add_parser(
+            'list-freqaimodels',
+            help='Print available freqAI models.',
+            parents=[_common_parser],
+        )
+        list_freqaimodels_cmd.set_defaults(func=start_list_freqAI_models)
+        self._build_args(optionlist=ARGS_LIST_FREQAIMODELS, parser=list_freqaimodels_cmd)
+
         # Add list-timeframes subcommand
         list_timeframes_cmd = subparsers.add_parser(
             'list-timeframes',

freqtrade/commands/build_config_commands.py

@@ -108,7 +108,6 @@ def ask_user_config() -> Dict[str, Any]:
                 "binance",
                 "binanceus",
                 "bittrex",
-                "ftx",
                 "gateio",
                 "huobi",
                 "kraken",

freqtrade/commands/cli_options.py

@@ -49,7 +49,7 @@ AVAILABLE_CLI_OPTIONS = {
         default=0,
     ),
     "logfile": Arg(
-        '--logfile',
+        '--logfile', '--log-file',
         help="Log to the file specified. Special values are: 'syslog', 'journald'. "
              "See the documentation for more details.",
         metavar='FILE',
@@ -668,4 +668,9 @@ AVAILABLE_CLI_OPTIONS = {
         help='Specify additional lookup path for freqaimodels.',
         metavar='PATH',
     ),
+    "freqai_backtest_live_models": Arg(
+        '--freqai-backtest-live-models',
+        help='Run backtest with ready models.',
+        action='store_true'
+    ),
 }

freqtrade/commands/list_commands.py

@@ -1,7 +1,6 @@
 import csv
 import logging
 import sys
-from pathlib import Path
 from typing import Any, Dict, List
 
 import rapidjson
@@ -10,7 +9,6 @@ from colorama import init as colorama_init
 from tabulate import tabulate
 
 from freqtrade.configuration import setup_utils_configuration
-from freqtrade.constants import USERPATH_STRATEGIES
 from freqtrade.enums import RunMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import market_is_active, validate_exchanges
@@ -41,7 +39,7 @@ def start_list_exchanges(args: Dict[str, Any]) -> None:
         print(tabulate(exchanges, headers=['Exchange name', 'Valid', 'reason']))
 
 
-def _print_objs_tabular(objs: List, print_colorized: bool, base_dir: Path) -> None:
+def _print_objs_tabular(objs: List, print_colorized: bool) -> None:
     if print_colorized:
         colorama_init(autoreset=True)
         red = Fore.RED
@@ -55,7 +53,7 @@ def _print_objs_tabular(objs: List, print_colorized: bool, base_dir: Path) -> No
     names = [s['name'] for s in objs]
     objs_to_print = [{
         'name': s['name'] if s['name'] else "--",
-        'location': s['location'].relative_to(base_dir),
+        'location': s['location_rel'],
         'status': (red + "LOAD FAILED" + reset if s['class'] is None
                    else "OK" if names.count(s['name']) == 1
                    else yellow + "DUPLICATE NAME" + reset)
@@ -76,9 +74,8 @@ def start_list_strategies(args: Dict[str, Any]) -> None:
     """
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
 
-    directory = Path(config.get('strategy_path', config['user_data_dir'] / USERPATH_STRATEGIES))
     strategy_objs = StrategyResolver.search_all_objects(
-        directory, not args['print_one_column'], config.get('recursive_strategy_search', False))
+        config, not args['print_one_column'], config.get('recursive_strategy_search', False))
     # Sort alphabetically
     strategy_objs = sorted(strategy_objs, key=lambda x: x['name'])
     for obj in strategy_objs:
@@ -90,7 +87,22 @@ def start_list_strategies(args: Dict[str, Any]) -> None:
     if args['print_one_column']:
         print('\n'.join([s['name'] for s in strategy_objs]))
     else:
-        _print_objs_tabular(strategy_objs, config.get('print_colorized', False), directory)
+        _print_objs_tabular(strategy_objs, config.get('print_colorized', False))
+
+
+def start_list_freqAI_models(args: Dict[str, Any]) -> None:
+    """
+    Print files with FreqAI models custom classes available in the directory
+    """
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+    from freqtrade.resolvers.freqaimodel_resolver import FreqaiModelResolver
+    model_objs = FreqaiModelResolver.search_all_objects(config, not args['print_one_column'])
+    # Sort alphabetically
+    model_objs = sorted(model_objs, key=lambda x: x['name'])
+    if args['print_one_column']:
+        print('\n'.join([s['name'] for s in model_objs]))
+    else:
+        _print_objs_tabular(model_objs, config.get('print_colorized', False))
 
 
 def start_list_timeframes(args: Dict[str, Any]) -> None:

freqtrade/configuration/config_validation.py

@@ -86,6 +86,8 @@ def validate_config_consistency(conf: Dict[str, Any], preliminary: bool = False)
     _validate_unlimited_amount(conf)
     _validate_ask_orderbook(conf)
     _validate_freqai_hyperopt(conf)
+    _validate_freqai_backtest(conf)
+    _validate_freqai_include_timeframes(conf)
     _validate_consumers(conf)
     validate_migrated_strategy_settings(conf)
 
@@ -334,6 +336,46 @@ def _validate_freqai_hyperopt(conf: Dict[str, Any]) -> None:
             'Using analyze-per-epoch parameter is not supported with a FreqAI strategy.')
 
 
+def _validate_freqai_include_timeframes(conf: Dict[str, Any]) -> None:
+    freqai_enabled = conf.get('freqai', {}).get('enabled', False)
+    if freqai_enabled:
+        main_tf = conf.get('timeframe', '5m')
+        freqai_include_timeframes = conf.get('freqai', {}).get('feature_parameters', {}
+                                                               ).get('include_timeframes', [])
+
+        from freqtrade.exchange import timeframe_to_seconds
+        main_tf_s = timeframe_to_seconds(main_tf)
+        offending_lines = []
+        for tf in freqai_include_timeframes:
+            tf_s = timeframe_to_seconds(tf)
+            if tf_s < main_tf_s:
+                offending_lines.append(tf)
+        if offending_lines:
+            raise OperationalException(
+                f"Main timeframe of {main_tf} must be smaller or equal to FreqAI "
+                f"`include_timeframes`.Offending include-timeframes: {', '.join(offending_lines)}")
+
+
+def _validate_freqai_backtest(conf: Dict[str, Any]) -> None:
+    if conf.get('runmode', RunMode.OTHER) == RunMode.BACKTEST:
+        freqai_enabled = conf.get('freqai', {}).get('enabled', False)
+        timerange = conf.get('timerange')
+        freqai_backtest_live_models = conf.get('freqai_backtest_live_models', False)
+        if freqai_backtest_live_models and freqai_enabled and timerange:
+            raise OperationalException(
+                'Using timerange parameter is not supported with '
+                '--freqai-backtest-live-models parameter.')
+
+        if freqai_backtest_live_models and not freqai_enabled:
+            raise OperationalException(
+                'Using --freqai-backtest-live-models parameter is only '
+                'supported with a FreqAI strategy.')
+
+        if freqai_enabled and not freqai_backtest_live_models and not timerange:
+            raise OperationalException(
+                'Please pass --timerange if you intend to use FreqAI for backtesting.')
+
+
 def _validate_consumers(conf: Dict[str, Any]) -> None:
     emc_conf = conf.get('external_message_consumer', {})
     if emc_conf.get('enabled', False):

freqtrade/configuration/configuration.py

@@ -279,6 +279,9 @@ class Configuration:
         self._args_to_config(config, argname='disableparamexport',
                              logstring='Parameter --disableparamexport detected: {} ...')
 
+        self._args_to_config(config, argname='freqai_backtest_live_models',
+                             logstring='Parameter --freqai-backtest-live-models detected ...')
+
         # Edge section:
         if 'stoploss_range' in self.args and self.args["stoploss_range"]:
             txt_range = eval(self.args["stoploss_range"])

freqtrade/configuration/directory_operations.py

@@ -3,7 +3,8 @@ import shutil
 from pathlib import Path
 from typing import Optional
 
-from freqtrade.constants import USER_DATA_FILES, Config
+from freqtrade.constants import (USER_DATA_FILES, USERPATH_FREQAIMODELS, USERPATH_HYPEROPTS,
+                                 USERPATH_NOTEBOOKS, USERPATH_STRATEGIES, Config)
 from freqtrade.exceptions import OperationalException
 
 
@@ -49,8 +50,8 @@ def create_userdata_dir(directory: str, create_dir: bool = False) -> Path:
     :param create_dir: Create directory if it does not exist.
     :return: Path object containing the directory
     """
-    sub_dirs = ["backtest_results", "data", "hyperopts", "hyperopt_results", "logs",
-                "notebooks", "plot", "strategies", ]
+    sub_dirs = ["backtest_results", "data", USERPATH_HYPEROPTS, "hyperopt_results", "logs",
+                USERPATH_NOTEBOOKS, "plot", USERPATH_STRATEGIES, USERPATH_FREQAIMODELS]
     folder = Path(directory)
     chown_user_directory(folder)
     if not folder.is_dir():

freqtrade/configuration/timerange.py

@@ -3,11 +3,12 @@ This module contains the argument manager class
 """
 import logging
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 import arrow
 
+from freqtrade.constants import DATETIME_PRINT_FORMAT
 from freqtrade.exceptions import OperationalException
 
 
@@ -29,6 +30,52 @@ class TimeRange:
         self.startts: int = startts
         self.stopts: int = stopts
 
+    @property
+    def startdt(self) -> Optional[datetime]:
+        if self.startts:
+            return datetime.fromtimestamp(self.startts, tz=timezone.utc)
+        return None
+
+    @property
+    def stopdt(self) -> Optional[datetime]:
+        if self.stopts:
+            return datetime.fromtimestamp(self.stopts, tz=timezone.utc)
+        return None
+
+    @property
+    def timerange_str(self) -> str:
+        """
+        Returns a string representation of the timerange as used by parse_timerange.
+        Follows the format yyyymmdd-yyyymmdd - leaving out the parts that are not set.
+        """
+        start = ''
+        stop = ''
+        if startdt := self.startdt:
+            start = startdt.strftime('%Y%m%d')
+        if stopdt := self.stopdt:
+            stop = stopdt.strftime('%Y%m%d')
+        return f"{start}-{stop}"
+
+    @property
+    def start_fmt(self) -> str:
+        """
+        Returns a string representation of the start date
+        """
+        val = 'unbounded'
+        if (startdt := self.startdt) is not None:
+            val = startdt.strftime(DATETIME_PRINT_FORMAT)
+        return val
+
+    @property
+    def stop_fmt(self) -> str:
+        """
+        Returns a string representation of the stop date
+        """
+        val = 'unbounded'
+        if (stopdt := self.stopdt) is not None:
+            val = stopdt.strftime(DATETIME_PRINT_FORMAT)
+        return val
+
     def __eq__(self, other):
         """Override the default Equals behavior"""
         return (self.starttype == other.starttype and self.stoptype == other.stoptype

freqtrade/constants.py

@@ -5,7 +5,7 @@ bot constants
 """
 from typing import Any, Dict, List, Literal, Tuple
 
-from freqtrade.enums import CandleType
+from freqtrade.enums import CandleType, RPCMessageType
 
 
 DEFAULT_CONFIG = 'config.json'
@@ -159,6 +159,7 @@ CONF_SCHEMA = {
         'ignore_buying_expired_candle_after': {'type': 'number'},
         'trading_mode': {'type': 'string', 'enum': TRADING_MODES},
         'margin_mode': {'type': 'string', 'enum': MARGIN_MODES},
+        'reduce_df_footprint': {'type': 'boolean', 'default': False},
         'liquidation_buffer': {'type': 'number', 'minimum': 0.0, 'maximum': 0.99},
         'backtest_breakdown': {
             'type': 'array',
@@ -282,6 +283,7 @@ CONF_SCHEMA = {
                 'enabled': {'type': 'boolean'},
                 'token': {'type': 'string'},
                 'chat_id': {'type': 'string'},
+                'allow_custom_messages': {'type': 'boolean', 'default': True},
                 'balance_dust_level': {'type': 'number', 'minimum': 0.0},
                 'notification_settings': {
                     'type': 'object',
@@ -344,6 +346,8 @@ CONF_SCHEMA = {
                 'format': {'type': 'string', 'enum': WEBHOOK_FORMAT_OPTIONS, 'default': 'form'},
                 'retries': {'type': 'integer', 'minimum': 0},
                 'retry_delay': {'type': 'number', 'minimum': 0},
+                **dict([(x, {'type': 'object'}) for x in RPCMessageType]),
+                # Below -> Deprecated
                 'webhookentry': {'type': 'object'},
                 'webhookentrycancel': {'type': 'object'},
                 'webhookentryfill': {'type': 'object'},
@@ -508,6 +512,7 @@ CONF_SCHEMA = {
                                 'minimum': 0,
                                 'maximum': 65535
                             },
+                            'secure': {'type': 'boolean', 'default': False},
                             'ws_token': {'type': 'string'},
                         },
                         'required': ['name', 'host', 'ws_token']
@@ -537,7 +542,9 @@ CONF_SCHEMA = {
             "properties": {
                 "enabled": {"type": "boolean", "default": False},
                 "keras": {"type": "boolean", "default": False},
-                "conv_width": {"type": "integer", "default": 2},
+                "write_metrics_to_disk": {"type": "boolean", "default": False},
+                "purge_old_models": {"type": "boolean", "default": True},
+                "conv_width": {"type": "integer", "default": 1},
                 "train_period_days": {"type": "integer", "default": 0},
                 "backtest_period_days": {"type": "number", "default": 7},
                 "identifier": {"type": "string", "default": "example"},
@@ -571,7 +578,10 @@ CONF_SCHEMA = {
                     },
                 },
                 "model_training_parameters": {
-                    "type": "object"
+                    "type": "object",
+                    "properties": {
+                        "n_estimators": {"type": "integer", "default": 1000}
+                    },
                 },
             },
             "required": [
@@ -650,5 +660,6 @@ LongShort = Literal['long', 'short']
 EntryExit = Literal['entry', 'exit']
 BuySell = Literal['buy', 'sell']
 MakerTaker = Literal['maker', 'taker']
+BidAsk = Literal['bid', 'ask']
 
 Config = Dict[str, Any]

freqtrade/data/btanalysis.py

@@ -26,7 +26,7 @@ BT_DATA_COLUMNS = ['pair', 'stake_amount', 'amount', 'open_date', 'close_date',
                    'profit_ratio', 'profit_abs', 'exit_reason',
                    'initial_stop_loss_abs', 'initial_stop_loss_ratio', 'stop_loss_abs',
                    'stop_loss_ratio', 'min_rate', 'max_rate', 'is_open', 'enter_tag',
-                   'is_short', 'open_timestamp', 'close_timestamp', 'orders'
+                   'leverage', 'is_short', 'open_timestamp', 'close_timestamp', 'orders'
                    ]
 
 
@@ -280,6 +280,8 @@ def load_backtest_data(filename: Union[Path, str], strategy: Optional[str] = Non
             # Compatibility support for pre short Columns
             if 'is_short' not in df.columns:
                 df['is_short'] = 0
+            if 'leverage' not in df.columns:
+                df['leverage'] = 1.0
             if 'enter_tag' not in df.columns:
                 df['enter_tag'] = df['buy_tag']
                 df = df.drop(['buy_tag'], axis=1)

freqtrade/data/converter.py

@@ -3,10 +3,10 @@ Functions to convert data from one format to another
 """
 import itertools
 import logging
-from datetime import datetime, timezone
 from operator import itemgetter
 from typing import Dict, List
 
+import numpy as np
 import pandas as pd
 from pandas import DataFrame, to_datetime
 
@@ -137,11 +137,9 @@ def trim_dataframe(df: DataFrame, timerange, df_date_col: str = 'date',
         df = df.iloc[startup_candles:, :]
     else:
         if timerange.starttype == 'date':
-            start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
-            df = df.loc[df[df_date_col] >= start, :]
+            df = df.loc[df[df_date_col] >= timerange.startdt, :]
     if timerange.stoptype == 'date':
-        stop = datetime.fromtimestamp(timerange.stopts, tz=timezone.utc)
-        df = df.loc[df[df_date_col] <= stop, :]
+        df = df.loc[df[df_date_col] <= timerange.stopdt, :]
     return df
 
 
@@ -313,3 +311,29 @@ def convert_ohlcv_format(
                 if erase and convert_from != convert_to:
                     logger.info(f"Deleting source data for {pair} / {timeframe}")
                     src.ohlcv_purge(pair=pair, timeframe=timeframe, candle_type=candle_type)
+
+
+def reduce_dataframe_footprint(df: DataFrame) -> DataFrame:
+    """
+    Ensure all values are float32 in the incoming dataframe.
+    :param df: Dataframe to be converted to float/int 32s
+    :return: Dataframe converted to float/int 32s
+    """
+
+    logger.debug(f"Memory usage of dataframe is "
+                 f"{df.memory_usage().sum() / 1024**2:.2f} MB")
+
+    df_dtypes = df.dtypes
+    for column, dtype in df_dtypes.items():
+        if column in ['open', 'high', 'low', 'close', 'volume']:
+            continue
+        if dtype == np.float64:
+            df_dtypes[column] = np.float32
+        elif dtype == np.int64:
+            df_dtypes[column] = np.int32
+    df = df.astype(df_dtypes)
+
+    logger.debug(f"Memory usage after optimization is: "
+                 f"{df.memory_usage().sum() / 1024**2:.2f} MB")
+
+    return df

freqtrade/data/history/history_utils.py

@@ -1,6 +1,6 @@
 import logging
 import operator
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
@@ -160,9 +160,9 @@ def _load_cached_data_for_updating(
     end = None
     if timerange:
         if timerange.starttype == 'date':
-            start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
+            start = timerange.startdt
         if timerange.stoptype == 'date':
-            end = datetime.fromtimestamp(timerange.stopts, tz=timezone.utc)
+            end = timerange.stopdt
 
     # Intentionally don't pass timerange in - since we need to load the full dataset.
     data = data_handler.ohlcv_load(pair, timeframe=timeframe,

freqtrade/data/history/idatahandler.py

@@ -102,6 +102,11 @@ class IDataHandler(ABC):
         :return: (min, max)
         """
         data = self._ohlcv_load(pair, timeframe, None, candle_type)
+        if data.empty:
+            return (
+                datetime.fromtimestamp(0, tz=timezone.utc),
+                datetime.fromtimestamp(0, tz=timezone.utc)
+            )
         return data.iloc[0]['date'].to_pydatetime(), data.iloc[-1]['date'].to_pydatetime()
 
     @abstractmethod
@@ -303,7 +308,7 @@ class IDataHandler(ABC):
             timerange=timerange_startup,
             candle_type=candle_type
         )
-        if self._check_empty_df(pairdf, pair, timeframe, candle_type, warn_no_data):
+        if self._check_empty_df(pairdf, pair, timeframe, candle_type, warn_no_data, True):
             return pairdf
         else:
             enddate = pairdf.iloc[-1]['date']
@@ -323,8 +328,9 @@ class IDataHandler(ABC):
             self._check_empty_df(pairdf, pair, timeframe, candle_type, warn_no_data)
             return pairdf
 
-    def _check_empty_df(self, pairdf: DataFrame, pair: str, timeframe: str,
-                        candle_type: CandleType, warn_no_data: bool):
+    def _check_empty_df(
+            self, pairdf: DataFrame, pair: str, timeframe: str, candle_type: CandleType,
+            warn_no_data: bool, warn_price: bool = False) -> bool:
         """
         Warn on empty dataframe
         """
@@ -335,6 +341,20 @@ class IDataHandler(ABC):
                     "Use `freqtrade download-data` to download the data"
                 )
             return True
+        elif warn_price:
+            candle_price_gap = 0
+            if (candle_type in (CandleType.SPOT, CandleType.FUTURES) and
+                    not pairdf.empty
+                    and 'close' in pairdf.columns and 'open' in pairdf.columns):
+                # Detect gaps between prior close and open
+                gaps = ((pairdf['open'] - pairdf['close'].shift(1)) / pairdf['close'].shift(1))
+                gaps = gaps.dropna()
+                if len(gaps):
+                    candle_price_gap = max(abs(gaps))
+            if candle_price_gap > 0.1:
+                logger.info(f"Price jump in {pair}, {timeframe}, {candle_type} between two candles "
+                            f"of {candle_price_gap:.2%} detected.")
+
         return False
 
     def _validate_pairdata(self, pair, pairdata: DataFrame, timeframe: str,
@@ -346,13 +366,11 @@ class IDataHandler(ABC):
         """
 
         if timerange.starttype == 'date':
-            start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
-            if pairdata.iloc[0]['date'] > start:
+            if pairdata.iloc[0]['date'] > timerange.startdt:
                 logger.warning(f"{pair}, {candle_type}, {timeframe}, "
                                f"data starts at {pairdata.iloc[0]['date']:%Y-%m-%d %H:%M:%S}")
         if timerange.stoptype == 'date':
-            stop = datetime.fromtimestamp(timerange.stopts, tz=timezone.utc)
-            if pairdata.iloc[-1]['date'] < stop:
+            if pairdata.iloc[-1]['date'] < timerange.stopdt:
                 logger.warning(f"{pair}, {candle_type}, {timeframe}, "
                                f"data ends at {pairdata.iloc[-1]['date']:%Y-%m-%d %H:%M:%S}")
 

freqtrade/edge/edge_positioning.py

@@ -392,7 +392,7 @@ class Edge:
         # Returning a list of pairs in order of "expectancy"
         return final
 
-    def _find_trades_for_stoploss_range(self, df, pair, stoploss_range):
+    def _find_trades_for_stoploss_range(self, df, pair: str, stoploss_range) -> list:
         buy_column = df['enter_long'].values
         sell_column = df['exit_long'].values
         date_column = df['date'].values
@@ -407,7 +407,7 @@ class Edge:
         return result
 
     def _detect_next_stop_or_sell_point(self, buy_column, sell_column, date_column,
-                                        ohlc_columns, stoploss, pair):
+                                        ohlc_columns, stoploss, pair: str):
         """
         Iterate through ohlc_columns in order to find the next trade
         Next trade opens from the first buy signal noticed to

freqtrade/exchange/__init__.py

@@ -9,15 +9,15 @@ from freqtrade.exchange.bitpanda import Bitpanda
 from freqtrade.exchange.bittrex import Bittrex
 from freqtrade.exchange.bybit import Bybit
 from freqtrade.exchange.coinbasepro import Coinbasepro
-from freqtrade.exchange.exchange import (amount_to_contract_precision, amount_to_contracts,
-                                         amount_to_precision, available_exchanges, ccxt_exchanges,
-                                         contracts_to_amount, date_minus_candles,
-                                         is_exchange_known_ccxt, market_is_active,
-                                         price_to_precision, timeframe_to_minutes,
-                                         timeframe_to_msecs, timeframe_to_next_date,
-                                         timeframe_to_prev_date, timeframe_to_seconds,
-                                         validate_exchange, validate_exchanges)
-from freqtrade.exchange.ftx import Ftx
+from freqtrade.exchange.exchange_utils import (amount_to_contract_precision, amount_to_contracts,
+                                               amount_to_precision, available_exchanges,
+                                               ccxt_exchanges, contracts_to_amount,
+                                               date_minus_candles, is_exchange_known_ccxt,
+                                               market_is_active, price_to_precision,
+                                               timeframe_to_minutes, timeframe_to_msecs,
+                                               timeframe_to_next_date, timeframe_to_prev_date,
+                                               timeframe_to_seconds, validate_exchange,
+                                               validate_exchanges)
 from freqtrade.exchange.gateio import Gateio
 from freqtrade.exchange.hitbtc import Hitbtc
 from freqtrade.exchange.huobi import Huobi

freqtrade/exchange/binance.py

@@ -11,6 +11,7 @@ from freqtrade.enums import CandleType, MarginMode, TradingMode
 from freqtrade.exceptions import DDosProtection, OperationalException, TemporaryError
 from freqtrade.exchange import Exchange
 from freqtrade.exchange.common import retrier
+from freqtrade.exchange.types import Tickers
 from freqtrade.misc import deep_merge_dicts, json_load
 
 
@@ -41,25 +42,7 @@ class Binance(Exchange):
         (TradingMode.FUTURES, MarginMode.ISOLATED)
     ]
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
-        """
-        Verify stop_loss against stoploss-order value (limit or price)
-        Returns True if adjustment is necessary.
-        :param side: "buy" or "sell"
-        """
-        order_types = ('stop_loss_limit', 'stop', 'stop_market')
-
-        return (
-            order.get('stopPrice', None) is None
-            or (
-                order['type'] in order_types
-                and (
-                    (side == "sell" and stop_loss > float(order['stopPrice'])) or
-                    (side == "buy" and stop_loss < float(order['stopPrice']))
-                )
-            ))
-
-    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Dict:
+    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Tickers:
         tickers = super().get_tickers(symbols=symbols, cached=cached)
         if self.trading_mode == TradingMode.FUTURES:
             # Binance's future result has no bid/ask values.

freqtrade/exchange/bybit.py

@@ -20,8 +20,12 @@ class Bybit(Exchange):
     """
 
     _ft_has: Dict = {
-        "ohlcv_candle_limit": 200,
-        "ccxt_futures_name": "linear"
+        "ohlcv_candle_limit": 1000,
+        "ccxt_futures_name": "linear",
+        "ohlcv_has_history": False,
+    }
+    _ft_has_futures: Dict = {
+        "ohlcv_has_history": True,
     }
 
     _supported_trading_mode_margin_pairs: List[Tuple[TradingMode, MarginMode]] = [

freqtrade/exchange/common.py

@@ -52,7 +52,6 @@ MAP_EXCHANGE_CHILDCLASS = {
 SUPPORTED_EXCHANGES = [
     'binance',
     'bittrex',
-    'ftx',
     'gateio',
     'huobi',
     'kraken',

freqtrade/exchange/exchange.py

@@ -8,7 +8,6 @@ import inspect
 import logging
 from copy import deepcopy
 from datetime import datetime, timedelta, timezone
-from math import ceil
 from threading import Lock
 from typing import Any, Coroutine, Dict, List, Literal, Optional, Tuple, Union
 
@@ -16,28 +15,31 @@ import arrow
 import ccxt
 import ccxt.async_support as ccxt_async
 from cachetools import TTLCache
-from ccxt import ROUND_DOWN, ROUND_UP, TICK_SIZE, TRUNCATE, decimal_to_precision
+from ccxt import TICK_SIZE
 from dateutil import parser
-from pandas import DataFrame
+from pandas import DataFrame, concat
 
-from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES, BuySell,
-                                 Config, EntryExit, ListPairsWithTimeframes, MakerTaker,
+from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES, BidAsk,
+                                 BuySell, Config, EntryExit, ListPairsWithTimeframes, MakerTaker,
                                  PairWithTimeframe)
-from freqtrade.data.converter import ohlcv_to_dataframe, trades_dict_to_list
+from freqtrade.data.converter import clean_ohlcv_dataframe, ohlcv_to_dataframe, trades_dict_to_list
 from freqtrade.enums import OPTIMIZE_MODES, CandleType, MarginMode, TradingMode
 from freqtrade.exceptions import (DDosProtection, ExchangeError, InsufficientFundsError,
                                   InvalidOrderException, OperationalException, PricingError,
                                   RetryableOrderError, TemporaryError)
-from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, BAD_EXCHANGES,
-                                       EXCHANGE_HAS_OPTIONAL, EXCHANGE_HAS_REQUIRED,
-                                       remove_credentials, retrier, retrier_async)
+from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, remove_credentials, retrier,
+                                       retrier_async)
+from freqtrade.exchange.exchange_utils import (CcxtModuleType, amount_to_contract_precision,
+                                               amount_to_contracts, amount_to_precision,
+                                               contracts_to_amount, date_minus_candles,
+                                               is_exchange_known_ccxt, market_is_active,
+                                               price_to_precision, timeframe_to_minutes,
+                                               timeframe_to_msecs, timeframe_to_next_date,
+                                               timeframe_to_prev_date, timeframe_to_seconds)
+from freqtrade.exchange.types import Ticker, Tickers
 from freqtrade.misc import (chunks, deep_merge_dicts, file_dump_json, file_load_json,
                             safe_value_fallback2)
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
-from freqtrade.util import FtPrecise
-
-
-CcxtModuleType = Any
 
 
 logger = logging.getLogger(__name__)
@@ -179,13 +181,14 @@ class Exchange:
             exchange_config, ccxt_async, ccxt_kwargs=ccxt_async_config)
 
         logger.info(f'Using Exchange "{self.name}"')
-
+        self.required_candle_call_count = 1
         if validate:
             # Initial markets load
             self._load_markets()
             self.validate_config(config)
+            self._startup_candle_count: int = config.get('startup_candle_count', 0)
             self.required_candle_call_count = self.validate_required_startup_candles(
-                config.get('startup_candle_count', 0), config.get('timeframe', ''))
+                self._startup_candle_count, config.get('timeframe', ''))
 
         # Converts the interval provided in minutes in config to seconds
         self.markets_refresh_interval: int = exchange_config.get(
@@ -408,11 +411,13 @@ class Exchange:
         else:
             return DataFrame()
 
-    def get_contract_size(self, pair: str) -> float:
+    def get_contract_size(self, pair: str) -> Optional[float]:
         if self.trading_mode == TradingMode.FUTURES:
-            market = self.markets[pair]
+            market = self.markets.get(pair, {})
             contract_size: float = 1.0
-            if market['contractSize'] is not None:
+            if not market:
+                return None
+            if market.get('contractSize') is not None:
                 # ccxt has contractSize in markets as string
                 contract_size = float(market['contractSize'])
             return contract_size
@@ -1072,7 +1077,14 @@ class Exchange:
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
         """
-        raise OperationalException(f"stoploss is not implemented for {self.name}.")
+        if not self._ft_has.get('stoploss_on_exchange'):
+            raise OperationalException(f"stoploss is not implemented for {self.name}.")
+
+        return (
+            order.get('stopPrice', None) is None
+            or ((side == "sell" and stop_loss > float(order['stopPrice'])) or
+                (side == "buy" and stop_loss < float(order['stopPrice'])))
+        )
 
     def _get_stop_order_type(self, user_order_type) -> Tuple[str, str]:
 
@@ -1102,7 +1114,7 @@ class Exchange:
                 'In stoploss limit order, stop price should be more than limit price')
         return limit_rate
 
-    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
         params = self._params.copy()
         # Verify if stopPrice works for your exchange!
         params.update({'stopPrice': stop_price})
@@ -1151,7 +1163,8 @@ class Exchange:
             return dry_order
 
         try:
-            params = self._get_stop_params(ordertype=ordertype, stop_price=stop_price_norm)
+            params = self._get_stop_params(side=side, ordertype=ordertype,
+                                           stop_price=stop_price_norm)
             if self.trading_mode == TradingMode.FUTURES:
                 params['reduceOnly'] = True
 
@@ -1419,14 +1432,17 @@ class Exchange:
             raise OperationalException(e) from e
 
     @retrier
-    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Dict:
+    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Tickers:
         """
         :param cached: Allow cached result
         :return: fetch_tickers result
         """
+        tickers: Tickers
+        if not self.exchange_has('fetchTickers'):
+            return {}
         if cached:
             with self._cache_lock:
-                tickers = self._fetch_tickers_cache.get('fetch_tickers')
+                tickers = self._fetch_tickers_cache.get('fetch_tickers')  # type: ignore
             if tickers:
                 return tickers
         try:
@@ -1449,12 +1465,12 @@ class Exchange:
     # Pricing info
 
     @retrier
-    def fetch_ticker(self, pair: str) -> dict:
+    def fetch_ticker(self, pair: str) -> Ticker:
         try:
             if (pair not in self.markets or
                     self.markets[pair].get('active', False) is False):
                 raise ExchangeError(f"Pair {pair} not available")
-            data = self._api.fetch_ticker(pair)
+            data: Ticker = self._api.fetch_ticker(pair)
             return data
         except ccxt.DDoSProtection as e:
             raise DDosProtection(e) from e
@@ -1505,7 +1521,7 @@ class Exchange:
         except ccxt.BaseError as e:
             raise OperationalException(e) from e
 
-    def _get_price_side(self, side: str, is_short: bool, conf_strategy: Dict) -> str:
+    def _get_price_side(self, side: str, is_short: bool, conf_strategy: Dict) -> BidAsk:
         price_side = conf_strategy['price_side']
 
         if price_side in ('same', 'other'):
@@ -1524,7 +1540,7 @@ class Exchange:
 
     def get_rate(self, pair: str, refresh: bool,
                  side: EntryExit, is_short: bool,
-                 order_book: Optional[dict] = None, ticker: Optional[dict] = None) -> float:
+                 order_book: Optional[dict] = None, ticker: Optional[Ticker] = None) -> float:
         """
         Calculates bid/ask target
         bid rate - between current ask price and last price
@@ -1673,6 +1689,17 @@ class Exchange:
     @retrier
     def get_fee(self, symbol: str, type: str = '', side: str = '', amount: float = 1,
                 price: float = 1, taker_or_maker: MakerTaker = 'maker') -> float:
+        """
+        Retrieve fee from exchange
+        :param symbol: Pair
+        :param type: Type of order (market, limit, ...)
+        :param side: Side of order (buy, sell)
+        :param amount: Amount of order
+        :param price: Price of order
+        :param taker_or_maker: 'maker' or 'taker' (ignored if "type" is provided)
+        """
+        if type and type == 'market':
+            taker_or_maker = 'taker'
         try:
             if self._config['dry_run'] and self._config.get('fee', None) is not None:
                 return self._config['fee']
@@ -1850,10 +1877,22 @@ class Exchange:
         return pair, timeframe, candle_type, data
 
     def _build_coroutine(self, pair: str, timeframe: str, candle_type: CandleType,
-                         since_ms: Optional[int]) -> Coroutine:
+                         since_ms: Optional[int], cache: bool) -> Coroutine:
+        not_all_data = cache and self.required_candle_call_count > 1
+        if cache and (pair, timeframe, candle_type) in self._klines:
+            candle_limit = self.ohlcv_candle_limit(timeframe, candle_type)
+            min_date = date_minus_candles(timeframe, candle_limit - 5).timestamp()
+            # Check if 1 call can get us updated candles without hole in the data.
+            if min_date < self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0):
+                # Cache can be used - do one-off call.
+                not_all_data = False
+            else:
+                # Time jump detected, evict cache
+                logger.info(
+                    f"Time jump detected. Evicting cache for {pair}, {timeframe}, {candle_type}")
+                del self._klines[(pair, timeframe, candle_type)]
 
-        if (not since_ms
-                and (self._ft_has["ohlcv_require_since"] or self.required_candle_call_count > 1)):
+        if (not since_ms and (self._ft_has["ohlcv_require_since"] or not_all_data)):
             # Multiple calls for one pair - to get more history
             one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(
                 timeframe, candle_type, since_ms)
@@ -1878,10 +1917,8 @@ class Exchange:
         input_coroutines = []
         cached_pairs = []
         for pair, timeframe, candle_type in set(pair_list):
-            if (
-                timeframe not in self.timeframes
-                and candle_type in (CandleType.SPOT, CandleType.FUTURES)
-            ):
+            if (timeframe not in self.timeframes
+                    and candle_type in (CandleType.SPOT, CandleType.FUTURES)):
                 logger.warning(
                     f"Cannot download ({pair}, {timeframe}) combination as this timeframe is "
                     f"not available on {self.name}. Available timeframes are "
@@ -1890,8 +1927,9 @@ class Exchange:
 
             if ((pair, timeframe, candle_type) not in self._klines or not cache
                     or self._now_is_time_to_refresh(pair, timeframe, candle_type)):
-                input_coroutines.append(self._build_coroutine(
-                    pair, timeframe, candle_type=candle_type, since_ms=since_ms))
+
+                input_coroutines.append(
+                    self._build_coroutine(pair, timeframe, candle_type, since_ms, cache))
 
             else:
                 logger.debug(
@@ -1901,6 +1939,29 @@ class Exchange:
 
         return input_coroutines, cached_pairs
 
+    def _process_ohlcv_df(self, pair: str, timeframe: str, c_type: CandleType, ticks: List[List],
+                          cache: bool, drop_incomplete: bool) -> DataFrame:
+        # keeping last candle time as last refreshed time of the pair
+        if ticks and cache:
+            self._pairs_last_refresh_time[(pair, timeframe, c_type)] = ticks[-1][0] // 1000
+        # keeping parsed dataframe in cache
+        ohlcv_df = ohlcv_to_dataframe(ticks, timeframe, pair=pair, fill_missing=True,
+                                      drop_incomplete=drop_incomplete)
+        if cache:
+            if (pair, timeframe, c_type) in self._klines:
+                old = self._klines[(pair, timeframe, c_type)]
+                # Reassign so we return the updated, combined df
+                ohlcv_df = clean_ohlcv_dataframe(concat([old, ohlcv_df], axis=0), timeframe, pair,
+                                                 fill_missing=True, drop_incomplete=False)
+                candle_limit = self.ohlcv_candle_limit(timeframe, self._config['candle_type_def'])
+                # Age out old candles
+                ohlcv_df = ohlcv_df.tail(candle_limit + self._startup_candle_count)
+                ohlcv_df = ohlcv_df.reset_index(drop=True)
+                self._klines[(pair, timeframe, c_type)] = ohlcv_df
+            else:
+                self._klines[(pair, timeframe, c_type)] = ohlcv_df
+        return ohlcv_df
+
     def refresh_latest_ohlcv(self, pair_list: ListPairsWithTimeframes, *,
                              since_ms: Optional[int] = None, cache: bool = True,
                              drop_incomplete: Optional[bool] = None
@@ -1937,16 +1998,11 @@ class Exchange:
                     continue
                 # Deconstruct tuple (has 4 elements)
                 pair, timeframe, c_type, ticks = res
-                # keeping last candle time as last refreshed time of the pair
-                if ticks:
-                    self._pairs_last_refresh_time[(pair, timeframe, c_type)] = ticks[-1][0] // 1000
-                # keeping parsed dataframe in cache
-                ohlcv_df = ohlcv_to_dataframe(
-                    ticks, timeframe, pair=pair, fill_missing=True,
-                    drop_incomplete=drop_incomplete)
+                ohlcv_df = self._process_ohlcv_df(
+                    pair, timeframe, c_type, ticks, cache, drop_incomplete)
+
                 results_df[(pair, timeframe, c_type)] = ohlcv_df
-                if cache:
-                    self._klines[(pair, timeframe, c_type)] = ohlcv_df
+
         # Return cached klines
         for pair, timeframe, c_type in cached_pairs:
             results_df[(pair, timeframe, c_type)] = self.klines(
@@ -1959,11 +2015,8 @@ class Exchange:
     def _now_is_time_to_refresh(self, pair: str, timeframe: str, candle_type: CandleType) -> bool:
         # Timeframe in seconds
         interval_in_sec = timeframe_to_seconds(timeframe)
-
-        return not (
-            (self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0)
-             + interval_in_sec) >= arrow.utcnow().int_timestamp
-        )
+        plr = self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0) + interval_in_sec
+        return plr < arrow.utcnow().int_timestamp
 
     @retrier_async
     async def _async_get_candle_history(
@@ -1989,8 +2042,8 @@ class Exchange:
             candle_limit = self.ohlcv_candle_limit(
                 timeframe, candle_type=candle_type, since_ms=since_ms)
 
-            if candle_type != CandleType.SPOT:
-                params.update({'price': candle_type})
+            if candle_type and candle_type != CandleType.SPOT:
+                params.update({'price': candle_type.value})
             if candle_type != CandleType.FUNDING_RATE:
                 data = await self._api_async.fetch_ohlcv(
                     pair, timeframe=timeframe, since=since_ms,
@@ -2766,240 +2819,3 @@ class Exchange:
             # describes the min amt for a tier, and the lowest tier will always go down to 0
         else:
             raise OperationalException(f"Cannot get maintenance ratio using {self.name}")
-
-
-def is_exchange_known_ccxt(exchange_name: str, ccxt_module: CcxtModuleType = None) -> bool:
-    return exchange_name in ccxt_exchanges(ccxt_module)
-
-
-def ccxt_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:
-    """
-    Return the list of all exchanges known to ccxt
-    """
-    return ccxt_module.exchanges if ccxt_module is not None else ccxt.exchanges
-
-
-def available_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:
-    """
-    Return exchanges available to the bot, i.e. non-bad exchanges in the ccxt list
-    """
-    exchanges = ccxt_exchanges(ccxt_module)
-    return [x for x in exchanges if validate_exchange(x)[0]]
-
-
-def validate_exchange(exchange: str) -> Tuple[bool, str]:
-    ex_mod = getattr(ccxt, exchange.lower())()
-    if not ex_mod or not ex_mod.has:
-        return False, ''
-    missing = [k for k in EXCHANGE_HAS_REQUIRED if ex_mod.has.get(k) is not True]
-    if missing:
-        return False, f"missing: {', '.join(missing)}"
-
-    missing_opt = [k for k in EXCHANGE_HAS_OPTIONAL if not ex_mod.has.get(k)]
-
-    if exchange.lower() in BAD_EXCHANGES:
-        return False, BAD_EXCHANGES.get(exchange.lower(), '')
-    if missing_opt:
-        return True, f"missing opt: {', '.join(missing_opt)}"
-
-    return True, ''
-
-
-def validate_exchanges(all_exchanges: bool) -> List[Tuple[str, bool, str]]:
-    """
-    :return: List of tuples with exchangename, valid, reason.
-    """
-    exchanges = ccxt_exchanges() if all_exchanges else available_exchanges()
-    exchanges_valid = [
-        (e, *validate_exchange(e)) for e in exchanges
-    ]
-    return exchanges_valid
-
-
-def timeframe_to_seconds(timeframe: str) -> int:
-    """
-    Translates the timeframe interval value written in the human readable
-    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
-    of seconds for one timeframe interval.
-    """
-    return ccxt.Exchange.parse_timeframe(timeframe)
-
-
-def timeframe_to_minutes(timeframe: str) -> int:
-    """
-    Same as timeframe_to_seconds, but returns minutes.
-    """
-    return ccxt.Exchange.parse_timeframe(timeframe) // 60
-
-
-def timeframe_to_msecs(timeframe: str) -> int:
-    """
-    Same as timeframe_to_seconds, but returns milliseconds.
-    """
-    return ccxt.Exchange.parse_timeframe(timeframe) * 1000
-
-
-def timeframe_to_prev_date(timeframe: str, date: datetime = None) -> datetime:
-    """
-    Use Timeframe and determine the candle start date for this date.
-    Does not round when given a candle start date.
-    :param timeframe: timeframe in string format (e.g. "5m")
-    :param date: date to use. Defaults to now(utc)
-    :returns: date of previous candle (with utc timezone)
-    """
-    if not date:
-        date = datetime.now(timezone.utc)
-
-    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
-                                                  ROUND_DOWN) // 1000
-    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
-
-
-def timeframe_to_next_date(timeframe: str, date: datetime = None) -> datetime:
-    """
-    Use Timeframe and determine next candle.
-    :param timeframe: timeframe in string format (e.g. "5m")
-    :param date: date to use. Defaults to now(utc)
-    :returns: date of next candle (with utc timezone)
-    """
-    if not date:
-        date = datetime.now(timezone.utc)
-    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
-                                                  ROUND_UP) // 1000
-    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
-
-
-def date_minus_candles(
-        timeframe: str, candle_count: int, date: Optional[datetime] = None) -> datetime:
-    """
-    subtract X candles from a date.
-    :param timeframe: timeframe in string format (e.g. "5m")
-    :param candle_count: Amount of candles to subtract.
-    :param date: date to use. Defaults to now(utc)
-
-    """
-    if not date:
-        date = datetime.now(timezone.utc)
-
-    tf_min = timeframe_to_minutes(timeframe)
-    new_date = timeframe_to_prev_date(timeframe, date) - timedelta(minutes=tf_min * candle_count)
-    return new_date
-
-
-def market_is_active(market: Dict) -> bool:
-    """
-    Return True if the market is active.
-    """
-    # "It's active, if the active flag isn't explicitly set to false. If it's missing or
-    # true then it's true. If it's undefined, then it's most likely true, but not 100% )"
-    # See https://github.com/ccxt/ccxt/issues/4874,
-    # https://github.com/ccxt/ccxt/issues/4075#issuecomment-434760520
-    return market.get('active', True) is not False
-
-
-def amount_to_contracts(amount: float, contract_size: Optional[float]) -> float:
-    """
-    Convert amount to contracts.
-    :param amount: amount to convert
-    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
-    :return: num-contracts
-    """
-    if contract_size and contract_size != 1:
-        return float(FtPrecise(amount) / FtPrecise(contract_size))
-    else:
-        return amount
-
-
-def contracts_to_amount(num_contracts: float, contract_size: Optional[float]) -> float:
-    """
-    Takes num-contracts and converts it to contract size
-    :param num_contracts: number of contracts
-    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
-    :return: Amount
-    """
-
-    if contract_size and contract_size != 1:
-        return float(FtPrecise(num_contracts) * FtPrecise(contract_size))
-    else:
-        return num_contracts
-
-
-def amount_to_precision(amount: float, amount_precision: Optional[float],
-                        precisionMode: Optional[int]) -> float:
-    """
-    Returns the amount to buy or sell to a precision the Exchange accepts
-    Re-implementation of ccxt internal methods - ensuring we can test the result is correct
-    based on our definitions.
-    :param amount: amount to truncate
-    :param amount_precision: amount precision to use.
-                             should be retrieved from markets[pair]['precision']['amount']
-    :param precisionMode: precision mode to use. Should be used from precisionMode
-                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
-    :return: truncated amount
-    """
-    if amount_precision is not None and precisionMode is not None:
-        precision = int(amount_precision) if precisionMode != TICK_SIZE else amount_precision
-        # precision must be an int for non-ticksize inputs.
-        amount = float(decimal_to_precision(amount, rounding_mode=TRUNCATE,
-                                            precision=precision,
-                                            counting_mode=precisionMode,
-                                            ))
-
-    return amount
-
-
-def amount_to_contract_precision(
-        amount, amount_precision: Optional[float], precisionMode: Optional[int],
-        contract_size: Optional[float]) -> float:
-    """
-    Returns the amount to buy or sell to a precision the Exchange accepts
-    including calculation to and from contracts.
-    Re-implementation of ccxt internal methods - ensuring we can test the result is correct
-    based on our definitions.
-    :param amount: amount to truncate
-    :param amount_precision: amount precision to use.
-                             should be retrieved from markets[pair]['precision']['amount']
-    :param precisionMode: precision mode to use. Should be used from precisionMode
-                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
-    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
-    :return: truncated amount
-    """
-    if amount_precision is not None and precisionMode is not None:
-        contracts = amount_to_contracts(amount, contract_size)
-        amount_p = amount_to_precision(contracts, amount_precision, precisionMode)
-        return contracts_to_amount(amount_p, contract_size)
-    return amount
-
-
-def price_to_precision(price: float, price_precision: Optional[float],
-                       precisionMode: Optional[int]) -> float:
-    """
-    Returns the price rounded up to the precision the Exchange accepts.
-    Partial Re-implementation of ccxt internal method decimal_to_precision(),
-    which does not support rounding up
-    TODO: If ccxt supports ROUND_UP for decimal_to_precision(), we could remove this and
-    align with amount_to_precision().
-    !!! Rounds up
-    :param price: price to convert
-    :param price_precision: price precision to use. Used from markets[pair]['precision']['price']
-    :param precisionMode: precision mode to use. Should be used from precisionMode
-                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
-    :return: price rounded up to the precision the Exchange accepts
-
-    """
-    if price_precision is not None and precisionMode is not None:
-        # price = float(decimal_to_precision(price, rounding_mode=ROUND,
-        #                                    precision=price_precision,
-        #                                    counting_mode=self.precisionMode,
-        #                                    ))
-        if precisionMode == TICK_SIZE:
-            precision = FtPrecise(price_precision)
-            price_str = FtPrecise(price)
-            missing = price_str % precision
-            if not missing == FtPrecise("0"):
-                price = round(float(str(price_str - missing + precision)), 14)
-        else:
-            symbol_prec = price_precision
-            big_price = price * pow(10, symbol_prec)
-            price = ceil(big_price) / pow(10, symbol_prec)
-    return price

freqtrade/exchange/exchange_utils.py

@@ -0,0 +1,252 @@
+"""
+Exchange support utils
+"""
+from datetime import datetime, timedelta, timezone
+from math import ceil
+from typing import Any, Dict, List, Optional, Tuple
+
+import ccxt
+from ccxt import ROUND_DOWN, ROUND_UP, TICK_SIZE, TRUNCATE, decimal_to_precision
+
+from freqtrade.exchange.common import BAD_EXCHANGES, EXCHANGE_HAS_OPTIONAL, EXCHANGE_HAS_REQUIRED
+from freqtrade.util import FtPrecise
+
+
+CcxtModuleType = Any
+
+
+def is_exchange_known_ccxt(exchange_name: str, ccxt_module: CcxtModuleType = None) -> bool:
+    return exchange_name in ccxt_exchanges(ccxt_module)
+
+
+def ccxt_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:
+    """
+    Return the list of all exchanges known to ccxt
+    """
+    return ccxt_module.exchanges if ccxt_module is not None else ccxt.exchanges
+
+
+def available_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:
+    """
+    Return exchanges available to the bot, i.e. non-bad exchanges in the ccxt list
+    """
+    exchanges = ccxt_exchanges(ccxt_module)
+    return [x for x in exchanges if validate_exchange(x)[0]]
+
+
+def validate_exchange(exchange: str) -> Tuple[bool, str]:
+    ex_mod = getattr(ccxt, exchange.lower())()
+    if not ex_mod or not ex_mod.has:
+        return False, ''
+    missing = [k for k in EXCHANGE_HAS_REQUIRED if ex_mod.has.get(k) is not True]
+    if missing:
+        return False, f"missing: {', '.join(missing)}"
+
+    missing_opt = [k for k in EXCHANGE_HAS_OPTIONAL if not ex_mod.has.get(k)]
+
+    if exchange.lower() in BAD_EXCHANGES:
+        return False, BAD_EXCHANGES.get(exchange.lower(), '')
+    if missing_opt:
+        return True, f"missing opt: {', '.join(missing_opt)}"
+
+    return True, ''
+
+
+def validate_exchanges(all_exchanges: bool) -> List[Tuple[str, bool, str]]:
+    """
+    :return: List of tuples with exchangename, valid, reason.
+    """
+    exchanges = ccxt_exchanges() if all_exchanges else available_exchanges()
+    exchanges_valid = [
+        (e, *validate_exchange(e)) for e in exchanges
+    ]
+    return exchanges_valid
+
+
+def timeframe_to_seconds(timeframe: str) -> int:
+    """
+    Translates the timeframe interval value written in the human readable
+    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
+    of seconds for one timeframe interval.
+    """
+    return ccxt.Exchange.parse_timeframe(timeframe)
+
+
+def timeframe_to_minutes(timeframe: str) -> int:
+    """
+    Same as timeframe_to_seconds, but returns minutes.
+    """
+    return ccxt.Exchange.parse_timeframe(timeframe) // 60
+
+
+def timeframe_to_msecs(timeframe: str) -> int:
+    """
+    Same as timeframe_to_seconds, but returns milliseconds.
+    """
+    return ccxt.Exchange.parse_timeframe(timeframe) * 1000
+
+
+def timeframe_to_prev_date(timeframe: str, date: datetime = None) -> datetime:
+    """
+    Use Timeframe and determine the candle start date for this date.
+    Does not round when given a candle start date.
+    :param timeframe: timeframe in string format (e.g. "5m")
+    :param date: date to use. Defaults to now(utc)
+    :returns: date of previous candle (with utc timezone)
+    """
+    if not date:
+        date = datetime.now(timezone.utc)
+
+    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
+                                                  ROUND_DOWN) // 1000
+    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
+
+
+def timeframe_to_next_date(timeframe: str, date: datetime = None) -> datetime:
+    """
+    Use Timeframe and determine next candle.
+    :param timeframe: timeframe in string format (e.g. "5m")
+    :param date: date to use. Defaults to now(utc)
+    :returns: date of next candle (with utc timezone)
+    """
+    if not date:
+        date = datetime.now(timezone.utc)
+    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
+                                                  ROUND_UP) // 1000
+    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
+
+
+def date_minus_candles(
+        timeframe: str, candle_count: int, date: Optional[datetime] = None) -> datetime:
+    """
+    subtract X candles from a date.
+    :param timeframe: timeframe in string format (e.g. "5m")
+    :param candle_count: Amount of candles to subtract.
+    :param date: date to use. Defaults to now(utc)
+
+    """
+    if not date:
+        date = datetime.now(timezone.utc)
+
+    tf_min = timeframe_to_minutes(timeframe)
+    new_date = timeframe_to_prev_date(timeframe, date) - timedelta(minutes=tf_min * candle_count)
+    return new_date
+
+
+def market_is_active(market: Dict) -> bool:
+    """
+    Return True if the market is active.
+    """
+    # "It's active, if the active flag isn't explicitly set to false. If it's missing or
+    # true then it's true. If it's undefined, then it's most likely true, but not 100% )"
+    # See https://github.com/ccxt/ccxt/issues/4874,
+    # https://github.com/ccxt/ccxt/issues/4075#issuecomment-434760520
+    return market.get('active', True) is not False
+
+
+def amount_to_contracts(amount: float, contract_size: Optional[float]) -> float:
+    """
+    Convert amount to contracts.
+    :param amount: amount to convert
+    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
+    :return: num-contracts
+    """
+    if contract_size and contract_size != 1:
+        return float(FtPrecise(amount) / FtPrecise(contract_size))
+    else:
+        return amount
+
+
+def contracts_to_amount(num_contracts: float, contract_size: Optional[float]) -> float:
+    """
+    Takes num-contracts and converts it to contract size
+    :param num_contracts: number of contracts
+    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
+    :return: Amount
+    """
+
+    if contract_size and contract_size != 1:
+        return float(FtPrecise(num_contracts) * FtPrecise(contract_size))
+    else:
+        return num_contracts
+
+
+def amount_to_precision(amount: float, amount_precision: Optional[float],
+                        precisionMode: Optional[int]) -> float:
+    """
+    Returns the amount to buy or sell to a precision the Exchange accepts
+    Re-implementation of ccxt internal methods - ensuring we can test the result is correct
+    based on our definitions.
+    :param amount: amount to truncate
+    :param amount_precision: amount precision to use.
+                             should be retrieved from markets[pair]['precision']['amount']
+    :param precisionMode: precision mode to use. Should be used from precisionMode
+                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
+    :return: truncated amount
+    """
+    if amount_precision is not None and precisionMode is not None:
+        precision = int(amount_precision) if precisionMode != TICK_SIZE else amount_precision
+        # precision must be an int for non-ticksize inputs.
+        amount = float(decimal_to_precision(amount, rounding_mode=TRUNCATE,
+                                            precision=precision,
+                                            counting_mode=precisionMode,
+                                            ))
+
+    return amount
+
+
+def amount_to_contract_precision(
+        amount, amount_precision: Optional[float], precisionMode: Optional[int],
+        contract_size: Optional[float]) -> float:
+    """
+    Returns the amount to buy or sell to a precision the Exchange accepts
+    including calculation to and from contracts.
+    Re-implementation of ccxt internal methods - ensuring we can test the result is correct
+    based on our definitions.
+    :param amount: amount to truncate
+    :param amount_precision: amount precision to use.
+                             should be retrieved from markets[pair]['precision']['amount']
+    :param precisionMode: precision mode to use. Should be used from precisionMode
+                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
+    :param contract_size: contract size - taken from exchange.get_contract_size(pair)
+    :return: truncated amount
+    """
+    if amount_precision is not None and precisionMode is not None:
+        contracts = amount_to_contracts(amount, contract_size)
+        amount_p = amount_to_precision(contracts, amount_precision, precisionMode)
+        return contracts_to_amount(amount_p, contract_size)
+    return amount
+
+
+def price_to_precision(price: float, price_precision: Optional[float],
+                       precisionMode: Optional[int]) -> float:
+    """
+    Returns the price rounded up to the precision the Exchange accepts.
+    Partial Re-implementation of ccxt internal method decimal_to_precision(),
+    which does not support rounding up
+    TODO: If ccxt supports ROUND_UP for decimal_to_precision(), we could remove this and
+    align with amount_to_precision().
+    !!! Rounds up
+    :param price: price to convert
+    :param price_precision: price precision to use. Used from markets[pair]['precision']['price']
+    :param precisionMode: precision mode to use. Should be used from precisionMode
+                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
+    :return: price rounded up to the precision the Exchange accepts
+
+    """
+    if price_precision is not None and precisionMode is not None:
+        # price = float(decimal_to_precision(price, rounding_mode=ROUND,
+        #                                    precision=price_precision,
+        #                                    counting_mode=self.precisionMode,
+        #                                    ))
+        if precisionMode == TICK_SIZE:
+            precision = FtPrecise(price_precision)
+            price_str = FtPrecise(price)
+            missing = price_str % precision
+            if not missing == FtPrecise("0"):
+                price = round(float(str(price_str - missing + precision)), 14)
+        else:
+            symbol_prec = price_precision
+            big_price = price * pow(10, symbol_prec)
+            price = ceil(big_price) / pow(10, symbol_prec)
+    return price

freqtrade/exchange/ftx.py

@@ -1,178 +0,0 @@
-""" FTX exchange subclass """
-import logging
-from typing import Any, Dict, List, Optional, Tuple
-
-import ccxt
-
-from freqtrade.constants import BuySell
-from freqtrade.enums import MarginMode, TradingMode
-from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
-                                  OperationalException, TemporaryError)
-from freqtrade.exchange import Exchange
-from freqtrade.exchange.common import API_FETCH_ORDER_RETRY_COUNT, retrier
-from freqtrade.misc import safe_value_fallback2
-
-
-logger = logging.getLogger(__name__)
-
-
-class Ftx(Exchange):
-
-    _ft_has: Dict = {
-        "order_time_in_force": ['GTC', 'IOC', 'PO'],
-        "stoploss_on_exchange": True,
-        "ohlcv_candle_limit": 1500,
-        "ohlcv_require_since": True,
-        "ohlcv_volume_currency": "quote",
-        "mark_ohlcv_price": "index",
-        "mark_ohlcv_timeframe": "1h",
-    }
-
-    _supported_trading_mode_margin_pairs: List[Tuple[TradingMode, MarginMode]] = [
-        # TradingMode.SPOT always supported and not required in this list
-        # (TradingMode.MARGIN, MarginMode.CROSS),
-        # (TradingMode.FUTURES, MarginMode.CROSS)
-    ]
-
-    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
-        """
-        Verify stop_loss against stoploss-order value (limit or price)
-        Returns True if adjustment is necessary.
-        """
-        return order['type'] == 'stop' and (
-            side == "sell" and stop_loss > float(order['price']) or
-            side == "buy" and stop_loss < float(order['price'])
-        )
-
-    @retrier(retries=0)
-    def stoploss(self, pair: str, amount: float, stop_price: float,
-                 order_types: Dict, side: BuySell, leverage: float) -> Dict:
-        """
-        Creates a stoploss order.
-        depending on order_types.stoploss configuration, uses 'market' or limit order.
-
-        Limit orders are defined by having orderPrice set, otherwise a market order is used.
-        """
-        limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
-        if side == "sell":
-            limit_rate = stop_price * limit_price_pct
-        else:
-            limit_rate = stop_price * (2 - limit_price_pct)
-
-        ordertype = "stop"
-
-        stop_price = self.price_to_precision(pair, stop_price)
-
-        if self._config['dry_run']:
-            dry_order = self.create_dry_run_order(
-                pair, ordertype, side, amount, stop_price, leverage, stop_loss=True)
-            return dry_order
-
-        try:
-            params = self._params.copy()
-            if order_types.get('stoploss', 'market') == 'limit':
-                # set orderPrice to place limit order, otherwise it's a market order
-                params['orderPrice'] = limit_rate
-            if self.trading_mode == TradingMode.FUTURES:
-                params.update({'reduceOnly': True})
-
-            params['stopPrice'] = stop_price
-            amount = self.amount_to_precision(pair, amount)
-
-            self._lev_prep(pair, leverage, side)
-            order = self._api.create_order(symbol=pair, type=ordertype, side=side,
-                                           amount=amount, params=params)
-            self._log_exchange_response('create_stoploss_order', order)
-            logger.info('stoploss order added for %s. '
-                        'stop price: %s.', pair, stop_price)
-            return order
-        except ccxt.InsufficientFunds as e:
-            raise InsufficientFundsError(
-                f'Insufficient funds to create {ordertype} {side} order on market {pair}. '
-                f'Tried to create stoploss with amount {amount} at stoploss {stop_price}. '
-                f'Message: {e}') from e
-        except ccxt.InvalidOrder as e:
-            raise InvalidOrderException(
-                f'Could not create {ordertype} {side} order on market {pair}. '
-                f'Tried to create stoploss with amount {amount} at stoploss {stop_price}. '
-                f'Message: {e}') from e
-        except ccxt.DDoSProtection as e:
-            raise DDosProtection(e) from e
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}') from e
-        except ccxt.BaseError as e:
-            raise OperationalException(e) from e
-
-    @retrier(retries=API_FETCH_ORDER_RETRY_COUNT)
-    def fetch_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
-        if self._config['dry_run']:
-            return self.fetch_dry_run_order(order_id)
-
-        try:
-            orders = self._api.fetch_orders(pair, None, params={'type': 'stop'})
-
-            order = [order for order in orders if order['id'] == order_id]
-            self._log_exchange_response('fetch_stoploss_order', order)
-            if len(order) == 1:
-                if order[0].get('status') == 'closed':
-                    # Trigger order was triggered ...
-                    real_order_id: Optional[str] = order[0].get('info', {}).get('orderId')
-                    # OrderId may be None for stoploss-market orders
-                    # So we need to get it through the endpoint
-                    # /conditional_orders/{conditional_order_id}/triggers
-                    if not real_order_id:
-                        res = self._api.privateGetConditionalOrdersConditionalOrderIdTriggers(
-                            params={'conditional_order_id': order_id})
-                        self._log_exchange_response('fetch_stoploss_order2', res)
-                        real_order_id = res['result'][0]['orderId'] if res.get(
-                            'result', []) else None
-
-                    if real_order_id:
-                        order1 = self._api.fetch_order(real_order_id, pair)
-                        self._log_exchange_response('fetch_stoploss_order1', order1)
-                        # Fake type to stop - as this was really a stop order.
-                        order1['id_stop'] = order1['id']
-                        order1['id'] = order_id
-                        order1['type'] = 'stop'
-                        order1['status_stop'] = 'triggered'
-                        return order1
-
-                return order[0]
-            else:
-                raise InvalidOrderException(f"Could not get stoploss order for id {order_id}")
-
-        except ccxt.InvalidOrder as e:
-            raise InvalidOrderException(
-                f'Tried to get an invalid order (id: {order_id}). Message: {e}') from e
-        except ccxt.DDoSProtection as e:
-            raise DDosProtection(e) from e
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not get order due to {e.__class__.__name__}. Message: {e}') from e
-        except ccxt.BaseError as e:
-            raise OperationalException(e) from e
-
-    @retrier
-    def cancel_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
-        if self._config['dry_run']:
-            return {}
-        try:
-            order = self._api.cancel_order(order_id, pair, params={'type': 'stop'})
-            self._log_exchange_response('cancel_stoploss_order', order)
-            return order
-        except ccxt.InvalidOrder as e:
-            raise InvalidOrderException(
-                f'Could not cancel order. Message: {e}') from e
-        except ccxt.DDoSProtection as e:
-            raise DDosProtection(e) from e
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}') from e
-        except ccxt.BaseError as e:
-            raise OperationalException(e) from e
-
-    def get_order_id_conditional(self, order: Dict[str, Any]) -> str:
-        if order['type'] == 'stop':
-            return safe_value_fallback2(order, order, 'id_stop', 'id')
-        return order['id']

freqtrade/exchange/gateio.py

@@ -126,13 +126,3 @@ class Gateio(Exchange):
             pair=pair,
             params={'stop': True}
         )
-
-    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
-        """
-        Verify stop_loss against stoploss-order value (limit or price)
-        Returns True if adjustment is necessary.
-        """
-        return (order.get('stopPrice', None) is None or (
-            side == "sell" and stop_loss > float(order['stopPrice'])) or
-            (side == "buy" and stop_loss < float(order['stopPrice']))
-            )

freqtrade/exchange/huobi.py

@@ -2,6 +2,7 @@
 import logging
 from typing import Dict
 
+from freqtrade.constants import BuySell
 from freqtrade.exchange import Exchange
 
 
@@ -22,20 +23,7 @@ class Huobi(Exchange):
         "l2_limit_range_required": False,
     }
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
-        """
-        Verify stop_loss against stoploss-order value (limit or price)
-        Returns True if adjustment is necessary.
-        """
-        return (
-            order.get('stopPrice', None) is None
-            or (
-                order['type'] == 'stop'
-                and stop_loss > float(order['stopPrice'])
-            )
-        )
-
-    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
 
         params = self._params.copy()
         params.update({

freqtrade/exchange/kraken.py

@@ -12,6 +12,7 @@ from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, Invali
                                   OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
 from freqtrade.exchange.common import retrier
+from freqtrade.exchange.types import Tickers
 
 
 logger = logging.getLogger(__name__)
@@ -45,7 +46,7 @@ class Kraken(Exchange):
         return (parent_check and
                 market.get('darkpool', False) is False)
 
-    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Dict:
+    def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Tickers:
         # Only fetch tickers for current stake currency
         # Otherwise the request for kraken becomes too large.
         symbols = list(self.get_markets(quote_currencies=[self._config['stake_currency']]))
@@ -217,3 +218,19 @@ class Kraken(Exchange):
             fees = sum(df['open_fund'] * df['open_mark'] * amount * time_in_ratio)
 
         return fees if is_short else -fees
+
+    def _trades_contracts_to_amount(self, trades: List) -> List:
+        """
+        Fix "last" id issue for kraken data downloads
+        This whole override can probably be removed once the following
+        issue is closed in ccxt: https://github.com/ccxt/ccxt/issues/15827
+        """
+        super()._trades_contracts_to_amount(trades)
+        if (
+            len(trades) > 0
+            and isinstance(trades[-1].get('info'), list)
+            and len(trades[-1].get('info', [])) > 7
+        ):
+
+            trades[-1]['id'] = trades[-1].get('info', [])[-1]
+        return trades

freqtrade/exchange/kucoin.py

@@ -2,6 +2,7 @@
 import logging
 from typing import Dict
 
+from freqtrade.constants import BuySell
 from freqtrade.exchange import Exchange
 
 
@@ -27,17 +28,7 @@ class Kucoin(Exchange):
         "ohlcv_candle_limit": 1500,
     }
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
-        """
-        Verify stop_loss against stoploss-order value (limit or price)
-        Returns True if adjustment is necessary.
-        """
-        return (
-            order.get('stopPrice', None) is None
-            or stop_loss > float(order['stopPrice'])
-        )
-
-    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
 
         params = self._params.copy()
         params.update({

freqtrade/exchange/types.py

@@ -0,0 +1,16 @@
+from typing import Dict, Optional, TypedDict
+
+
+class Ticker(TypedDict):
+    symbol: str
+    ask: Optional[float]
+    askVolume: Optional[float]
+    bid: Optional[float]
+    bidVolume: Optional[float]
+    last: Optional[float]
+    quoteVolume: Optional[float]
+    baseVolume: Optional[float]
+    # Several more - only listing required.
+
+
+Tickers = Dict[str, Ticker]

freqtrade/freqai/RL/Base4ActionRLEnv.py

@@ -1,134 +0,0 @@
-import logging
-from enum import Enum
-
-from gym import spaces
-
-from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment, Positions
-
-
-logger = logging.getLogger(__name__)
-
-
-class Actions(Enum):
-    Neutral = 0
-    Exit = 1
-    Long_enter = 2
-    Short_enter = 3
-
-
-class Base4ActionRLEnv(BaseEnvironment):
-    """
-    Base class for a 4 action environment
-    """
-
-    def set_action_space(self):
-        self.action_space = spaces.Discrete(len(Actions))
-
-    def step(self, action: int):
-        """
-        Logic for a single step (incrementing one candle in time)
-        by the agent
-        :param: action: int = the action type that the agent plans
-            to take for the current step.
-        :returns:
-            observation = current state of environment
-            step_reward = the reward from `calculate_reward()`
-            _done = if the agent "died" or if the candles finished
-            info = dict passed back to openai gym lib
-        """
-        self._done = False
-        self._current_tick += 1
-
-        if self._current_tick == self._end_tick:
-            self._done = True
-
-        self._update_unrealized_total_profit()
-
-        step_reward = self.calculate_reward(action)
-        self.total_reward += step_reward
-
-        trade_type = None
-        if self.is_tradesignal(action):
-            """
-            Action: Neutral, position: Long ->  Close Long
-            Action: Neutral, position: Short -> Close Short
-
-            Action: Long, position: Neutral -> Open Long
-            Action: Long, position: Short -> Close Short and Open Long
-
-            Action: Short, position: Neutral -> Open Short
-            Action: Short, position: Long -> Close Long and Open Short
-            """
-
-            if action == Actions.Neutral.value:
-                self._position = Positions.Neutral
-                trade_type = "neutral"
-                self._last_trade_tick = None
-            elif action == Actions.Long_enter.value:
-                self._position = Positions.Long
-                trade_type = "long"
-                self._last_trade_tick = self._current_tick
-            elif action == Actions.Short_enter.value:
-                self._position = Positions.Short
-                trade_type = "short"
-                self._last_trade_tick = self._current_tick
-            elif action == Actions.Exit.value:
-                self._position = Positions.Neutral
-                trade_type = "neutral"
-                self._last_trade_tick = None
-            else:
-                print("case not defined")
-
-            if trade_type is not None:
-                self.trade_history.append(
-                    {'price': self.current_price(), 'index': self._current_tick,
-                     'type': trade_type})
-
-        if self._total_profit < 1 - self.rl_config.get('max_training_drawdown_pct', 0.8):
-            self._done = True
-
-        self._position_history.append(self._position)
-
-        info = dict(
-            tick=self._current_tick,
-            total_reward=self.total_reward,
-            total_profit=self._total_profit,
-            position=self._position.value
-        )
-
-        observation = self._get_observation()
-
-        self._update_history(info)
-
-        return observation, step_reward, self._done, info
-
-    def is_tradesignal(self, action: int):
-        """
-        Determine if the signal is a trade signal
-        e.g.: agent wants a Actions.Long_exit while it is in a Positions.short
-        """
-        return not ((action == Actions.Neutral.value and self._position == Positions.Neutral) or
-                    (action == Actions.Neutral.value and self._position == Positions.Short) or
-                    (action == Actions.Neutral.value and self._position == Positions.Long) or
-                    (action == Actions.Short_enter.value and self._position == Positions.Short) or
-                    (action == Actions.Short_enter.value and self._position == Positions.Long) or
-                    (action == Actions.Exit.value and self._position == Positions.Neutral) or
-                    (action == Actions.Long_enter.value and self._position == Positions.Long) or
-                    (action == Actions.Long_enter.value and self._position == Positions.Short))
-
-    def _is_valid(self, action: int):
-        """
-        Determine if the signal is valid.
-        e.g.: agent wants a Actions.Long_exit while it is in a Positions.short
-        """
-        # Agent should only try to exit if it is in position
-        if action == Actions.Exit.value:
-            if self._position not in (Positions.Short, Positions.Long):
-                return False
-
-        # Agent should only try to enter if it is not in position
-        if action in (Actions.Short_enter.value, Actions.Long_enter.value):
-            if self._position != Positions.Neutral:
-                return False
-
-        return True

freqtrade/freqai/RL/Base5ActionRLEnv.py

@@ -1,201 +0,0 @@
-import logging
-from enum import Enum
-
-import numpy as np
-import pandas as pd
-from gym import spaces
-from pandas import DataFrame
-
-from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment, Positions
-
-
-logger = logging.getLogger(__name__)
-
-
-class Actions(Enum):
-    Neutral = 0
-    Long_enter = 1
-    Long_exit = 2
-    Short_enter = 3
-    Short_exit = 4
-
-
-def mean_over_std(x):
-    std = np.std(x, ddof=1)
-    mean = np.mean(x)
-    return mean / std if std > 0 else 0
-
-
-class Base5ActionRLEnv(BaseEnvironment):
-    """
-    Base class for a 5 action environment
-    """
-
-    def set_action_space(self):
-        self.action_space = spaces.Discrete(len(Actions))
-
-    def reset(self):
-
-        self._done = False
-
-        if self.starting_point is True:
-            self._position_history = (self._start_tick * [None]) + [self._position]
-        else:
-            self._position_history = (self.window_size * [None]) + [self._position]
-
-        self._current_tick = self._start_tick
-        self._last_trade_tick = None
-        self._position = Positions.Neutral
-
-        self.total_reward = 0.
-        self._total_profit = 1.  # unit
-        self.history = {}
-        self.trade_history = []
-        self.portfolio_log_returns = np.zeros(len(self.prices))
-
-        self._profits = [(self._start_tick, 1)]
-        self.close_trade_profit = []
-        self._total_unrealized_profit = 1
-
-        return self._get_observation()
-
-    def step(self, action: int):
-        """
-        Logic for a single step (incrementing one candle in time)
-        by the agent
-        :param: action: int = the action type that the agent plans
-            to take for the current step.
-        :returns:
-            observation = current state of environment
-            step_reward = the reward from `calculate_reward()`
-            _done = if the agent "died" or if the candles finished
-            info = dict passed back to openai gym lib
-        """
-        self._done = False
-        self._current_tick += 1
-
-        if self._current_tick == self._end_tick:
-            self._done = True
-
-        self.update_portfolio_log_returns(action)
-
-        self._update_unrealized_total_profit()
-        step_reward = self.calculate_reward(action)
-        self.total_reward += step_reward
-
-        trade_type = None
-        if self.is_tradesignal(action):
-            """
-            Action: Neutral, position: Long ->  Close Long
-            Action: Neutral, position: Short -> Close Short
-
-            Action: Long, position: Neutral -> Open Long
-            Action: Long, position: Short -> Close Short and Open Long
-
-            Action: Short, position: Neutral -> Open Short
-            Action: Short, position: Long -> Close Long and Open Short
-            """
-
-            if action == Actions.Neutral.value:
-                self._position = Positions.Neutral
-                trade_type = "neutral"
-                self._last_trade_tick = None
-            elif action == Actions.Long_enter.value:
-                self._position = Positions.Long
-                trade_type = "long"
-                self._last_trade_tick = self._current_tick
-            elif action == Actions.Short_enter.value:
-                self._position = Positions.Short
-                trade_type = "short"
-                self._last_trade_tick = self._current_tick
-            elif action == Actions.Long_exit.value:
-                self._update_total_profit()
-                self._position = Positions.Neutral
-                trade_type = "neutral"
-                self._last_trade_tick = None
-            elif action == Actions.Short_exit.value:
-                self._update_total_profit()
-                self._position = Positions.Neutral
-                trade_type = "neutral"
-                self._last_trade_tick = None
-            else:
-                print("case not defined")
-
-            if trade_type is not None:
-                self.trade_history.append(
-                    {'price': self.current_price(), 'index': self._current_tick,
-                     'type': trade_type})
-
-        if (self._total_profit < self.max_drawdown or
-                self._total_unrealized_profit < self.max_drawdown):
-            self._done = True
-
-        self._position_history.append(self._position)
-
-        info = dict(
-            tick=self._current_tick,
-            total_reward=self.total_reward,
-            total_profit=self._total_profit,
-            position=self._position.value
-        )
-
-        observation = self._get_observation()
-
-        self._update_history(info)
-
-        return observation, step_reward, self._done, info
-
-    def _get_observation(self):
-        features_window = self.signal_features[(
-            self._current_tick - self.window_size):self._current_tick]
-        features_and_state = DataFrame(np.zeros((len(features_window), 3)),
-                                       columns=['current_profit_pct', 'position', 'trade_duration'],
-                                       index=features_window.index)
-
-        features_and_state['current_profit_pct'] = self.get_unrealized_profit()
-        features_and_state['position'] = self._position.value
-        features_and_state['trade_duration'] = self.get_trade_duration()
-        features_and_state = pd.concat([features_window, features_and_state], axis=1)
-        return features_and_state
-
-    def get_trade_duration(self):
-        if self._last_trade_tick is None:
-            return 0
-        else:
-            return self._current_tick - self._last_trade_tick
-
-    def is_tradesignal(self, action: int):
-        # trade signal
-        """
-        Determine if the signal is a trade signal
-        e.g.: agent wants a Actions.Long_exit while it is in a Positions.short
-        """
-        return not ((action == Actions.Neutral.value and self._position == Positions.Neutral) or
-                    (action == Actions.Neutral.value and self._position == Positions.Short) or
-                    (action == Actions.Neutral.value and self._position == Positions.Long) or
-                    (action == Actions.Short_enter.value and self._position == Positions.Short) or
-                    (action == Actions.Short_enter.value and self._position == Positions.Long) or
-                    (action == Actions.Short_exit.value and self._position == Positions.Long) or
-                    (action == Actions.Short_exit.value and self._position == Positions.Neutral) or
-                    (action == Actions.Long_enter.value and self._position == Positions.Long) or
-                    (action == Actions.Long_enter.value and self._position == Positions.Short) or
-                    (action == Actions.Long_exit.value and self._position == Positions.Short) or
-                    (action == Actions.Long_exit.value and self._position == Positions.Neutral))
-
-    def _is_valid(self, action: int):
-        # trade signal
-        """
-        Determine if the signal is valid.
-        e.g.: agent wants a Actions.Long_exit while it is in a Positions.short
-        """
-        # Agent should only try to exit if it is in position
-        if action in (Actions.Short_exit.value, Actions.Long_exit.value):
-            if self._position not in (Positions.Short, Positions.Long):
-                return False
-
-        # Agent should only try to enter if it is not in position
-        if action in (Actions.Short_enter.value, Actions.Long_enter.value):
-            if self._position != Positions.Neutral:
-                return False
-
-        return True

freqtrade/freqai/RL/BaseEnvironment.py

@@ -1,267 +0,0 @@
-import logging
-from abc import abstractmethod
-from enum import Enum
-from typing import Optional
-
-import gym
-import numpy as np
-import pandas as pd
-from gym import spaces
-from gym.utils import seeding
-from pandas import DataFrame
-
-
-logger = logging.getLogger(__name__)
-
-
-class Positions(Enum):
-    Short = 0
-    Long = 1
-    Neutral = 0.5
-
-    def opposite(self):
-        return Positions.Short if self == Positions.Long else Positions.Long
-
-
-class BaseEnvironment(gym.Env):
-    """
-    Base class for environments. This class is agnostic to action count.
-    Inherited classes customize this to include varying action counts/types,
-    See RL/Base5ActionRLEnv.py and RL/Base4ActionRLEnv.py
-    """
-
-    def __init__(self, df: DataFrame = DataFrame(), prices: DataFrame = DataFrame(),
-                 reward_kwargs: dict = {}, window_size=10, starting_point=True,
-                 id: str = 'baseenv-1', seed: int = 1, config: dict = {}):
-
-        self.rl_config = config['freqai']['rl_config']
-        self.id = id
-        self.seed(seed)
-        self.reset_env(df, prices, window_size, reward_kwargs, starting_point)
-        self.max_drawdown = 1 - self.rl_config.get('max_training_drawdown_pct', 0.8)
-        self.compound_trades = config['stake_amount'] == 'unlimited'
-
-    def reset_env(self, df: DataFrame, prices: DataFrame, window_size: int,
-                  reward_kwargs: dict, starting_point=True):
-        """
-        Resets the environment when the agent fails (in our case, if the drawdown
-        exceeds the user set max_training_drawdown_pct)
-        """
-        self.df = df
-        self.signal_features = self.df
-        self.prices = prices
-        self.window_size = window_size
-        self.starting_point = starting_point
-        self.rr = reward_kwargs["rr"]
-        self.profit_aim = reward_kwargs["profit_aim"]
-
-        self.fee = 0.0015
-
-        # # spaces
-        self.shape = (window_size, self.signal_features.shape[1] + 3)
-        self.set_action_space()
-        self.observation_space = spaces.Box(
-            low=-1, high=1, shape=self.shape, dtype=np.float32)
-
-        # episode
-        self._start_tick: int = self.window_size
-        self._end_tick: int = len(self.prices) - 1
-        self._done: bool = False
-        self._current_tick: int = self._start_tick
-        self._last_trade_tick: Optional[int] = None
-        self._position = Positions.Neutral
-        self._position_history: list = [None]
-        self.total_reward: float = 0
-        self._total_profit: float = 1
-        self._total_unrealized_profit: float = 1
-        self.history: dict = {}
-        self.trade_history: list = []
-
-    @abstractmethod
-    def set_action_space(self):
-        """
-        Unique to the environment action count. Must be inherited.
-        """
-
-    def seed(self, seed: int = 1):
-        self.np_random, seed = seeding.np_random(seed)
-        return [seed]
-
-    def reset(self):
-
-        self._done = False
-
-        if self.starting_point is True:
-            self._position_history = (self._start_tick * [None]) + [self._position]
-        else:
-            self._position_history = (self.window_size * [None]) + [self._position]
-
-        self._current_tick = self._start_tick
-        self._last_trade_tick = None
-        self._position = Positions.Neutral
-
-        self.total_reward = 0.
-        self._total_profit = 1.  # unit
-        self.history = {}
-        self.trade_history = []
-        self.portfolio_log_returns = np.zeros(len(self.prices))
-
-        self._profits = [(self._start_tick, 1)]
-        self.close_trade_profit = []
-        self._total_unrealized_profit = 1
-
-        return self._get_observation()
-
-    @abstractmethod
-    def step(self, action: int):
-        """
-        Step depeneds on action types, this must be inherited.
-        """
-        return
-
-    def _get_observation(self):
-        """
-        This may or may not be independent of action types, user can inherit
-        this in their custom "MyRLEnv"
-        """
-        features_window = self.signal_features[(
-            self._current_tick - self.window_size):self._current_tick]
-        features_and_state = DataFrame(np.zeros((len(features_window), 3)),
-                                       columns=['current_profit_pct', 'position', 'trade_duration'],
-                                       index=features_window.index)
-
-        features_and_state['current_profit_pct'] = self.get_unrealized_profit()
-        features_and_state['position'] = self._position.value
-        features_and_state['trade_duration'] = self.get_trade_duration()
-        features_and_state = pd.concat([features_window, features_and_state], axis=1)
-        return features_and_state
-
-    def get_trade_duration(self):
-        """
-        Get the trade duration if the agent is in a trade
-        """
-        if self._last_trade_tick is None:
-            return 0
-        else:
-            return self._current_tick - self._last_trade_tick
-
-    def get_unrealized_profit(self):
-        """
-        Get the unrealized profit if the agent is in a trade
-        """
-        if self._last_trade_tick is None:
-            return 0.
-
-        if self._position == Positions.Neutral:
-            return 0.
-        elif self._position == Positions.Short:
-            current_price = self.add_entry_fee(self.prices.iloc[self._current_tick].open)
-            last_trade_price = self.add_exit_fee(self.prices.iloc[self._last_trade_tick].open)
-            return (last_trade_price - current_price) / last_trade_price
-        elif self._position == Positions.Long:
-            current_price = self.add_exit_fee(self.prices.iloc[self._current_tick].open)
-            last_trade_price = self.add_entry_fee(self.prices.iloc[self._last_trade_tick].open)
-            return (current_price - last_trade_price) / last_trade_price
-        else:
-            return 0.
-
-    @abstractmethod
-    def is_tradesignal(self, action: int):
-        """
-        Determine if the signal is a trade signal. This is
-        unique to the actions in the environment, and therefore must be
-        inherited.
-        """
-        return
-
-    def _is_valid(self, action: int):
-        """
-        Determine if the signal is valid.This is
-        unique to the actions in the environment, and therefore must be
-        inherited.
-        """
-        return
-
-    def add_entry_fee(self, price):
-        return price * (1 + self.fee)
-
-    def add_exit_fee(self, price):
-        return price / (1 + self.fee)
-
-    def _update_history(self, info):
-        if not self.history:
-            self.history = {key: [] for key in info.keys()}
-
-        for key, value in info.items():
-            self.history[key].append(value)
-
-    @abstractmethod
-    def calculate_reward(self, action):
-        """
-        An example reward function. This is the one function that users will likely
-        wish to inject their own creativity into.
-        :params:
-        action: int = The action made by the agent for the current candle.
-        :returns:
-        float = the reward to give to the agent for current step (used for optimization
-            of weights in NN)
-        """
-
-    def _update_unrealized_total_profit(self):
-        """
-        Update the unrealized total profit incase of episode end.
-        """
-        if self._position in (Positions.Long, Positions.Short):
-            pnl = self.get_unrealized_profit()
-            if self.compound_trades:
-                # assumes unit stake and compounding
-                unrl_profit = self._total_profit * (1 + pnl)
-            else:
-                # assumes unit stake and no compounding
-                unrl_profit = self._total_profit + pnl
-            self._total_unrealized_profit = unrl_profit
-
-    def _update_total_profit(self):
-        pnl = self.get_unrealized_profit()
-        if self.compound_trades:
-            # assumes unite stake and compounding
-            self._total_profit = self._total_profit * (1 + pnl)
-        else:
-            # assumes unit stake and no compounding
-            self._total_profit += pnl
-
-    def most_recent_return(self, action: int):
-        """
-        Calculate the tick to tick return if in a trade.
-        Return is generated from rising prices in Long
-        and falling prices in Short positions.
-        The actions Sell/Buy or Hold during a Long position trigger the sell/buy-fee.
-        """
-        # Long positions
-        if self._position == Positions.Long:
-            current_price = self.prices.iloc[self._current_tick].open
-            previous_price = self.prices.iloc[self._current_tick - 1].open
-
-            if (self._position_history[self._current_tick - 1] == Positions.Short
-                    or self._position_history[self._current_tick - 1] == Positions.Neutral):
-                previous_price = self.add_entry_fee(previous_price)
-
-            return np.log(current_price) - np.log(previous_price)
-
-        # Short positions
-        if self._position == Positions.Short:
-            current_price = self.prices.iloc[self._current_tick].open
-            previous_price = self.prices.iloc[self._current_tick - 1].open
-            if (self._position_history[self._current_tick - 1] == Positions.Long
-                    or self._position_history[self._current_tick - 1] == Positions.Neutral):
-                previous_price = self.add_exit_fee(previous_price)
-
-            return np.log(previous_price) - np.log(current_price)
-
-        return 0
-
-    def update_portfolio_log_returns(self, action):
-        self.portfolio_log_returns[self._current_tick] = self.most_recent_return(action)
-
-    def current_price(self) -> float:
-        return self.prices.iloc[self._current_tick].open

freqtrade/freqai/RL/BaseReinforcementLearningModel.py

@@ -1,376 +0,0 @@
-import logging
-from abc import abstractmethod
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Callable, Dict, Tuple, Type, Union
-
-import gym
-import numpy as np
-import numpy.typing as npt
-import pandas as pd
-import torch as th
-import torch.multiprocessing
-from pandas import DataFrame
-from stable_baselines3.common.callbacks import EvalCallback
-from stable_baselines3.common.monitor import Monitor
-from stable_baselines3.common.utils import set_random_seed
-from stable_baselines3.common.vec_env import SubprocVecEnv
-
-from freqtrade.exceptions import OperationalException
-from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-from freqtrade.freqai.freqai_interface import IFreqaiModel
-from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv
-from freqtrade.freqai.RL.BaseEnvironment import Positions
-from freqtrade.persistence import Trade
-
-
-logger = logging.getLogger(__name__)
-
-torch.multiprocessing.set_sharing_strategy('file_system')
-
-SB3_MODELS = ['PPO', 'A2C', 'DQN']
-SB3_CONTRIB_MODELS = ['TRPO', 'ARS', 'RecurrentPPO', 'MaskablePPO']
-
-
-class BaseReinforcementLearningModel(IFreqaiModel):
-    """
-    User created Reinforcement Learning Model prediction class
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(config=kwargs['config'])
-        self.max_threads = min(self.freqai_info['rl_config'].get(
-            'cpu_count', 1), max(int(self.max_system_threads / 2), 1))
-        th.set_num_threads(self.max_threads)
-        self.reward_params = self.freqai_info['rl_config']['model_reward_parameters']
-        self.train_env: Union[SubprocVecEnv, gym.Env] = None
-        self.eval_env: Union[SubprocVecEnv, gym.Env] = None
-        self.eval_callback: EvalCallback = None
-        self.model_type = self.freqai_info['rl_config']['model_type']
-        self.rl_config = self.freqai_info['rl_config']
-        self.continual_learning = self.freqai_info.get('continual_learning', False)
-        if self.model_type in SB3_MODELS:
-            import_str = 'stable_baselines3'
-        elif self.model_type in SB3_CONTRIB_MODELS:
-            import_str = 'sb3_contrib'
-        else:
-            raise OperationalException(f'{self.model_type} not available in stable_baselines3 or '
-                                       f'sb3_contrib. please choose one of {SB3_MODELS} or '
-                                       f'{SB3_CONTRIB_MODELS}')
-
-        mod = __import__(import_str, fromlist=[
-                         self.model_type])
-        self.MODELCLASS = getattr(mod, self.model_type)
-        self.policy_type = self.freqai_info['rl_config']['policy_type']
-        self.unset_outlier_removal()
-
-    def unset_outlier_removal(self):
-        """
-        If user has activated any function that may remove training points, this
-        function will set them to false and warn them
-        """
-        if self.ft_params.get('use_SVM_to_remove_outliers', False):
-            self.ft_params.update({'use_SVM_to_remove_outliers': False})
-            logger.warning('User tried to use SVM with RL. Deactivating SVM.')
-        if self.ft_params.get('use_DBSCAN_to_remove_outliers', False):
-            self.ft_params.update({'use_SVM_to_remove_outliers': False})
-            logger.warning('User tried to use DBSCAN with RL. Deactivating DBSCAN.')
-        if self.freqai_info['data_split_parameters'].get('shuffle', False):
-            self.freqai_info['data_split_parameters'].update('shuffle', False)
-            logger.warning('User tried to shuffle training data. Setting shuffle to False')
-
-    def train(
-        self, unfiltered_df: DataFrame, pair: str, dk: FreqaiDataKitchen, **kwargs
-    ) -> Any:
-        """
-        Filter the training data and train a model to it. Train makes heavy use of the datakitchen
-        for storing, saving, loading, and analyzing the data.
-        :param unfiltered_df: Full dataframe for the current training period
-        :param metadata: pair metadata from strategy.
-        :returns:
-        :model: Trained model which can be used to inference (self.predict)
-        """
-
-        logger.info("--------------------Starting training " f"{pair} --------------------")
-
-        features_filtered, labels_filtered = dk.filter_features(
-            unfiltered_df,
-            dk.training_features_list,
-            dk.label_list,
-            training_filter=True,
-        )
-
-        data_dictionary: Dict[str, Any] = dk.make_train_test_datasets(
-            features_filtered, labels_filtered)
-        dk.fit_labels()  # FIXME useless for now, but just satiating append methods
-
-        # normalize all data based on train_dataset only
-        prices_train, prices_test = self.build_ohlc_price_dataframes(dk.data_dictionary, pair, dk)
-        data_dictionary = dk.normalize_data(data_dictionary)
-
-        # data cleaning/analysis
-        self.data_cleaning_train(dk)
-
-        logger.info(
-            f'Training model on {len(dk.data_dictionary["train_features"].columns)}'
-            f' features and {len(data_dictionary["train_features"])} data points'
-        )
-
-        self.set_train_and_eval_environments(data_dictionary, prices_train, prices_test, dk)
-
-        model = self.fit(data_dictionary, dk)
-
-        logger.info(f"--------------------done training {pair}--------------------")
-
-        return model
-
-    def set_train_and_eval_environments(self, data_dictionary: Dict[str, DataFrame],
-                                        prices_train: DataFrame, prices_test: DataFrame,
-                                        dk: FreqaiDataKitchen):
-        """
-        User can override this if they are using a custom MyRLEnv
-        :params:
-        data_dictionary: dict = common data dictionary containing train and test
-            features/labels/weights.
-        prices_train/test: DataFrame = dataframe comprised of the prices to be used in the
-            environment during training
-        or testing
-        dk: FreqaiDataKitchen = the datakitchen for the current pair
-        """
-        train_df = data_dictionary["train_features"]
-        test_df = data_dictionary["test_features"]
-
-        self.train_env = self.MyRLEnv(df=train_df, prices=prices_train, window_size=self.CONV_WIDTH,
-                                      reward_kwargs=self.reward_params, config=self.config)
-        self.eval_env = Monitor(self.MyRLEnv(df=test_df, prices=prices_test,
-                                window_size=self.CONV_WIDTH,
-                                reward_kwargs=self.reward_params, config=self.config))
-        self.eval_callback = EvalCallback(self.eval_env, deterministic=True,
-                                          render=False, eval_freq=len(train_df),
-                                          best_model_save_path=str(dk.data_path))
-
-    @abstractmethod
-    def fit(self, data_dictionary: Dict[str, Any], dk: FreqaiDataKitchen, **kwargs):
-        """
-        Agent customizations and abstract Reinforcement Learning customizations
-        go in here. Abstract method, so this function must be overridden by
-        user class.
-        """
-        return
-
-    def get_state_info(self, pair: str) -> Tuple[float, float, int]:
-        """
-        State info during dry/live/backtesting which is fed back
-        into the model.
-        :param:
-        pair: str = COIN/STAKE to get the environment information for
-        :returns:
-        market_side: float = representing short, long, or neutral for
-            pair
-        trade_duration: int = the number of candles that the trade has
-            been open for
-        """
-        open_trades = Trade.get_trades_proxy(is_open=True)
-        market_side = 0.5
-        current_profit: float = 0
-        trade_duration = 0
-        for trade in open_trades:
-            if trade.pair == pair:
-                if self.strategy.dp._exchange is None:  # type: ignore
-                    logger.error('No exchange available.')
-                else:
-                    current_value = self.strategy.dp._exchange.get_rate(  # type: ignore
-                                pair, refresh=False, side="exit", is_short=trade.is_short)
-                openrate = trade.open_rate
-                now = datetime.now(timezone.utc).timestamp()
-                trade_duration = int((now - trade.open_date.timestamp()) / self.base_tf_seconds)
-                if 'long' in str(trade.enter_tag):
-                    market_side = 1
-                    current_profit = (current_value - openrate) / openrate
-                else:
-                    market_side = 0
-                    current_profit = (openrate - current_value) / openrate
-
-        return market_side, current_profit, int(trade_duration)
-
-    def predict(
-        self, unfiltered_df: DataFrame, dk: FreqaiDataKitchen, **kwargs
-    ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
-        """
-        Filter the prediction features data and predict with it.
-        :param: unfiltered_dataframe: Full dataframe for the current backtest period.
-        :return:
-        :pred_df: dataframe containing the predictions
-        :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove
-        data (NaNs) or felt uncertain about data (PCA and DI index)
-        """
-
-        dk.find_features(unfiltered_df)
-        filtered_dataframe, _ = dk.filter_features(
-            unfiltered_df, dk.training_features_list, training_filter=False
-        )
-        filtered_dataframe = dk.normalize_data_from_metadata(filtered_dataframe)
-        dk.data_dictionary["prediction_features"] = filtered_dataframe
-
-        # optional additional data cleaning/analysis
-        self.data_cleaning_predict(dk)
-
-        pred_df = self.rl_model_predict(
-            dk.data_dictionary["prediction_features"], dk, self.model)
-        pred_df.fillna(0, inplace=True)
-
-        return (pred_df, dk.do_predict)
-
-    def rl_model_predict(self, dataframe: DataFrame,
-                         dk: FreqaiDataKitchen, model: Any) -> DataFrame:
-        """
-        A helper function to make predictions in the Reinforcement learning module.
-        :params:
-        dataframe: DataFrame = the dataframe of features to make the predictions on
-        dk: FreqaiDatakitchen = data kitchen for the current pair
-        model: Any = the trained model used to inference the features.
-        """
-        output = pd.DataFrame(np.zeros(len(dataframe)), columns=dk.label_list)
-
-        def _predict(window):
-            market_side, current_profit, trade_duration = self.get_state_info(dk.pair)
-            observations = dataframe.iloc[window.index]
-            observations['current_profit_pct'] = current_profit
-            observations['position'] = market_side
-            observations['trade_duration'] = trade_duration
-            res, _ = model.predict(observations, deterministic=True)
-            return res
-
-        output = output.rolling(window=self.CONV_WIDTH).apply(_predict)
-
-        return output
-
-    def build_ohlc_price_dataframes(self, data_dictionary: dict,
-                                    pair: str, dk: FreqaiDataKitchen) -> Tuple[DataFrame,
-                                                                               DataFrame]:
-        """
-        Builds the train prices and test prices for the environment.
-        """
-
-        coin = pair.split('/')[0]
-        train_df = data_dictionary["train_features"]
-        test_df = data_dictionary["test_features"]
-
-        # price data for model training and evaluation
-        tf = self.config['timeframe']
-        ohlc_list = [f'%-{coin}raw_open_{tf}', f'%-{coin}raw_low_{tf}',
-                     f'%-{coin}raw_high_{tf}', f'%-{coin}raw_close_{tf}']
-        rename_dict = {f'%-{coin}raw_open_{tf}': 'open', f'%-{coin}raw_low_{tf}': 'low',
-                       f'%-{coin}raw_high_{tf}': ' high', f'%-{coin}raw_close_{tf}': 'close'}
-
-        prices_train = train_df.filter(ohlc_list, axis=1)
-        prices_train.rename(columns=rename_dict, inplace=True)
-        prices_train.reset_index(drop=True)
-
-        prices_test = test_df.filter(ohlc_list, axis=1)
-        prices_test.rename(columns=rename_dict, inplace=True)
-        prices_test.reset_index(drop=True)
-
-        return prices_train, prices_test
-
-    def load_model_from_disk(self, dk: FreqaiDataKitchen) -> Any:
-        """
-        Can be used by user if they are trying to limit_ram_usage *and*
-        perform continual learning.
-        For now, this is unused.
-        """
-        exists = Path(dk.data_path / f"{dk.model_filename}_model").is_file()
-        if exists:
-            model = self.MODELCLASS.load(dk.data_path / f"{dk.model_filename}_model")
-        else:
-            logger.info('No model file on disk to continue learning from.')
-
-        return model
-
-    # Nested class which can be overridden by user to customize further
-    class MyRLEnv(Base5ActionRLEnv):
-        """
-        User can override any function in BaseRLEnv and gym.Env. Here the user
-        sets a custom reward based on profit and trade duration.
-        """
-
-        def calculate_reward(self, action: int) -> float:
-            """
-            An example reward function. This is the one function that users will likely
-            wish to inject their own creativity into.
-            :params:
-            action: int = The action made by the agent for the current candle.
-            :returns:
-            float = the reward to give to the agent for current step (used for optimization
-                of weights in NN)
-            """
-            # first, penalize if the action is not valid
-            if not self._is_valid(action):
-                return -2
-
-            pnl = self.get_unrealized_profit()
-            rew = np.sign(pnl) * (pnl + 1)
-            factor = 100.
-
-            # reward agent for entering trades
-            if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
-                    and self._position == Positions.Neutral):
-                return 25
-            # discourage agent from not entering trades
-            if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                return -1
-
-            max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-            if self._last_trade_tick:
-                trade_duration = self._current_tick - self._last_trade_tick
-            else:
-                trade_duration = 0
-
-            if trade_duration <= max_trade_duration:
-                factor *= 1.5
-            elif trade_duration > max_trade_duration:
-                factor *= 0.5
-
-            # discourage sitting in position
-            if (self._position in (Positions.Short, Positions.Long) and
-               action == Actions.Neutral.value):
-                return -1 * trade_duration / max_trade_duration
-
-            # close long
-            if action == Actions.Long_exit.value and self._position == Positions.Long:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(rew * factor)
-
-            # close short
-            if action == Actions.Short_exit.value and self._position == Positions.Short:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(rew * factor)
-
-            return 0.
-
-
-def make_env(MyRLEnv: Type[gym.Env], env_id: str, rank: int,
-             seed: int, train_df: DataFrame, price: DataFrame,
-             reward_params: Dict[str, int], window_size: int, monitor: bool = False,
-             config: Dict[str, Any] = {}) -> Callable:
-    """
-    Utility function for multiprocessed env.
-
-    :param env_id: (str) the environment ID
-    :param num_env: (int) the number of environment you wish to have in subprocesses
-    :param seed: (int) the inital seed for RNG
-    :param rank: (int) index of the subprocess
-    :return: (Callable)
-    """
-
-    def _init() -> gym.Env:
-
-        env = MyRLEnv(df=train_df, prices=price, window_size=window_size,
-                      reward_kwargs=reward_params, id=env_id, seed=seed + rank, config=config)
-        if monitor:
-            env = Monitor(env)
-        return env
-    set_random_seed(seed)
-    return _init

freqtrade/freqai/base_models/BaseClassifierModel.py

@@ -51,7 +51,7 @@ class BaseClassifierModel(IFreqaiModel):
                     f"{end_date} --------------------")
         # split data into train/test data.
         data_dictionary = dk.make_train_test_datasets(features_filtered, labels_filtered)
-        if not self.freqai_info.get("fit_live_predictions", 0) or not self.live:
+        if not self.freqai_info.get("fit_live_predictions_candles", 0) or not self.live:
             dk.fit_labels()
         # normalize all data based on train_dataset only
         data_dictionary = dk.normalize_data(data_dictionary)
@@ -78,7 +78,7 @@ class BaseClassifierModel(IFreqaiModel):
     ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
         """
         Filter the prediction features data and predict with it.
-        :param: unfiltered_df: Full dataframe for the current backtest period.
+        :param unfiltered_df: Full dataframe for the current backtest period.
         :return:
         :pred_df: dataframe containing the predictions
         :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove

freqtrade/freqai/base_models/BaseRegressionModel.py

@@ -50,7 +50,7 @@ class BaseRegressionModel(IFreqaiModel):
                     f"{end_date} --------------------")
         # split data into train/test data.
         data_dictionary = dk.make_train_test_datasets(features_filtered, labels_filtered)
-        if not self.freqai_info.get("fit_live_predictions", 0) or not self.live:
+        if not self.freqai_info.get("fit_live_predictions_candles", 0) or not self.live:
             dk.fit_labels()
         # normalize all data based on train_dataset only
         data_dictionary = dk.normalize_data(data_dictionary)
@@ -77,7 +77,7 @@ class BaseRegressionModel(IFreqaiModel):
     ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
         """
         Filter the prediction features data and predict with it.
-        :param: unfiltered_df: Full dataframe for the current backtest period.
+        :param unfiltered_df: Full dataframe for the current backtest period.
         :return:
         :pred_df: dataframe containing the predictions
         :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove

freqtrade/freqai/base_models/BaseTensorFlowModel.py

@@ -3,10 +3,10 @@ from time import time
 from typing import Any
 
 from pandas import DataFrame
-import numpy as np
+
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
 from freqtrade.freqai.freqai_interface import IFreqaiModel
-import tensorflow as tf
+
 
 logger = logging.getLogger(__name__)
 
@@ -17,13 +17,6 @@ class BaseTensorFlowModel(IFreqaiModel):
     User *must* inherit from this class and set fit() and predict().
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(config=kwargs['config'])
-        self.keras = True
-        if self.ft_params.get("DI_threshold", 0):
-            self.ft_params["DI_threshold"] = 0
-            logger.warning("DI threshold is not configured for Keras models yet. Deactivating.")
-
     def train(
         self, unfiltered_df: DataFrame, pair: str, dk: FreqaiDataKitchen, **kwargs
     ) -> Any:
@@ -54,7 +47,7 @@ class BaseTensorFlowModel(IFreqaiModel):
                     f"{end_date} --------------------")
         # split data into train/test data.
         data_dictionary = dk.make_train_test_datasets(features_filtered, labels_filtered)
-        if not self.freqai_info.get("fit_live_predictions", 0) or not self.live:
+        if not self.freqai_info.get("fit_live_predictions_candles", 0) or not self.live:
             dk.fit_labels()
         # normalize all data based on train_dataset only
         data_dictionary = dk.normalize_data(data_dictionary)
@@ -75,76 +68,3 @@ class BaseTensorFlowModel(IFreqaiModel):
                     f"({end_time - start_time:.2f} secs) --------------------")
 
         return model
-
-
-class WindowGenerator:
-    def __init__(
-        self,
-        input_width,
-        label_width,
-        shift,
-        train_df=None,
-        val_df=None,
-        test_df=None,
-        train_labels=None,
-        val_labels=None,
-        test_labels=None,
-        batch_size=None,
-    ):
-        # Store the raw data.
-        self.train_df = train_df
-        self.val_df = val_df
-        self.test_df = test_df
-        self.train_labels = train_labels
-        self.val_labels = val_labels
-        self.test_labels = test_labels
-        self.batch_size = batch_size
-        self.input_width = input_width
-        self.label_width = label_width
-        self.shift = shift
-        self.total_window_size = input_width + shift
-        self.input_slice = slice(0, input_width)
-        self.input_indices = np.arange(self.total_window_size)[self.input_slice]
-
-    def make_dataset(self, data, labels=None):
-        data = np.array(data, dtype=np.float32)
-        if labels is not None:
-            labels = np.array(labels, dtype=np.float32)
-        ds = tf.keras.preprocessing.timeseries_dataset_from_array(
-            data=data,
-            targets=labels,
-            sequence_length=self.total_window_size,
-            sequence_stride=1,
-            sampling_rate=1,
-            shuffle=False,
-            batch_size=self.batch_size,
-        )
-
-        return ds
-
-    @property
-    def train(self):
-        return self.make_dataset(self.train_df, self.train_labels)
-
-    @property
-    def val(self):
-        return self.make_dataset(self.val_df, self.val_labels)
-
-    @property
-    def test(self):
-        return self.make_dataset(self.test_df, self.test_labels)
-
-    @property
-    def inference(self):
-        return self.make_dataset(self.test_df)
-
-    @property
-    def example(self):
-        """Get and cache an example batch of `inputs, labels` for plotting."""
-        result = getattr(self, "_example", None)
-        if result is None:
-            # No example batch was found, so get one from the `.train` dataset
-            result = next(iter(self.train))
-            # And cache it for next time
-            self._example = result
-        return result

freqtrade/freqai/base_models/FreqaiMultiOutputClassifier.py

@@ -0,0 +1,93 @@
+import numpy as np
+from joblib import Parallel
+from sklearn.base import is_classifier
+from sklearn.multioutput import MultiOutputClassifier, _fit_estimator
+from sklearn.utils.fixes import delayed
+from sklearn.utils.multiclass import check_classification_targets
+from sklearn.utils.validation import has_fit_parameter
+
+from freqtrade.exceptions import OperationalException
+
+
+class FreqaiMultiOutputClassifier(MultiOutputClassifier):
+
+    def fit(self, X, y, sample_weight=None, fit_params=None):
+        """Fit the model to data, separately for each output variable.
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input data.
+        y : {array-like, sparse matrix} of shape (n_samples, n_outputs)
+            Multi-output targets. An indicator matrix turns on multilabel
+            estimation.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If `None`, then samples are equally weighted.
+            Only supported if the underlying classifier supports sample
+            weights.
+        fit_params : A list of dicts for the fit_params
+            Parameters passed to the ``estimator.fit`` method of each step.
+            Each dict may contain same or different values (e.g. different
+            eval_sets or init_models)
+            .. versionadded:: 0.23
+        Returns
+        -------
+        self : object
+            Returns a fitted instance.
+        """
+
+        if not hasattr(self.estimator, "fit"):
+            raise ValueError("The base estimator should implement a fit method")
+
+        y = self._validate_data(X="no_validation", y=y, multi_output=True)
+
+        if is_classifier(self):
+            check_classification_targets(y)
+
+        if y.ndim == 1:
+            raise ValueError(
+                "y must have at least two dimensions for "
+                "multi-output regression but has only one."
+            )
+
+        if sample_weight is not None and not has_fit_parameter(
+            self.estimator, "sample_weight"
+        ):
+            raise ValueError("Underlying estimator does not support sample weights.")
+
+        if not fit_params:
+            fit_params = [None] * y.shape[1]
+
+        self.estimators_ = Parallel(n_jobs=self.n_jobs)(
+            delayed(_fit_estimator)(
+                self.estimator, X, y[:, i], sample_weight, **fit_params[i]
+            )
+            for i in range(y.shape[1])
+        )
+
+        self.classes_ = []
+        for estimator in self.estimators_:
+            self.classes_.extend(estimator.classes_)
+        if len(set(self.classes_)) != len(self.classes_):
+            raise OperationalException(f"Class labels must be unique across targets: "
+                                       f"{self.classes_}")
+
+        if hasattr(self.estimators_[0], "n_features_in_"):
+            self.n_features_in_ = self.estimators_[0].n_features_in_
+        if hasattr(self.estimators_[0], "feature_names_in_"):
+            self.feature_names_in_ = self.estimators_[0].feature_names_in_
+
+        return self
+
+    def predict_proba(self, X):
+        """
+        Get predict_proba and stack arrays horizontally
+        """
+        results = np.hstack(super().predict_proba(X))
+        return np.squeeze(results)
+
+    def predict(self, X):
+        """
+        Get predict and squeeze into 2D array
+        """
+        results = super().predict(X)
+        return np.squeeze(results)

freqtrade/freqai/data_drawer.py

@@ -1,14 +1,15 @@
 import collections
-import json
 import logging
 import re
 import shutil
 import threading
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Tuple, TypedDict
 
 import numpy as np
 import pandas as pd
+import psutil
 import rapidjson
 from joblib import dump, load
 from joblib.externals import cloudpickle
@@ -65,6 +66,8 @@ class FreqaiDataDrawer:
         self.pair_dict: Dict[str, pair_info] = {}
         # dictionary holding all actively inferenced models in memory given a model filename
         self.model_dictionary: Dict[str, Any] = {}
+        # all additional metadata that we want to keep in ram
+        self.meta_data_dictionary: Dict[str, Dict[str, Any]] = {}
         self.model_return_values: Dict[str, DataFrame] = {}
         self.historic_data: Dict[str, Dict[str, DataFrame]] = {}
         self.historic_predictions: Dict[str, DataFrame] = {}
@@ -78,37 +81,60 @@ class FreqaiDataDrawer:
         self.historic_predictions_bkp_path = Path(
             self.full_path / "historic_predictions.backup.pkl")
         self.pair_dictionary_path = Path(self.full_path / "pair_dictionary.json")
+        self.metric_tracker_path = Path(self.full_path / "metric_tracker.json")
         self.follow_mode = follow_mode
         if follow_mode:
             self.create_follower_dict()
         self.load_drawer_from_disk()
         self.load_historic_predictions_from_disk()
+        self.metric_tracker: Dict[str, Dict[str, Dict[str, list]]] = {}
+        self.load_metric_tracker_from_disk()
         self.training_queue: Dict[str, int] = {}
         self.history_lock = threading.Lock()
         self.save_lock = threading.Lock()
         self.pair_dict_lock = threading.Lock()
+        self.metric_tracker_lock = threading.Lock()
         self.old_DBSCAN_eps: Dict[str, float] = {}
         self.empty_pair_dict: pair_info = {
                 "model_filename": "", "trained_timestamp": 0,
                 "data_path": "", "extras": {}}
-        self.limit_ram_use = self.freqai_info.get('limit_ram_usage', False)
-        if 'rl_config' in self.freqai_info:
-            self.model_type = 'stable_baselines'
-            logger.warning('User indicated rl_config, FreqAI will now use stable_baselines3'
-                           ' to save models.')
-        else:
-            self.model_type = self.freqai_info.get('model_save_type', 'joblib')
+
+    def update_metric_tracker(self, metric: str, value: float, pair: str) -> None:
+        """
+        General utility for adding and updating custom metrics. Typically used
+        for adding training performance, train timings, inferenc timings, cpu loads etc.
+        """
+        with self.metric_tracker_lock:
+            if pair not in self.metric_tracker:
+                self.metric_tracker[pair] = {}
+            if metric not in self.metric_tracker[pair]:
+                self.metric_tracker[pair][metric] = {'timestamp': [], 'value': []}
+
+            timestamp = int(datetime.now(timezone.utc).timestamp())
+            self.metric_tracker[pair][metric]['value'].append(value)
+            self.metric_tracker[pair][metric]['timestamp'].append(timestamp)
+
+    def collect_metrics(self, time_spent: float, pair: str):
+        """
+        Add metrics to the metric tracker dictionary
+        """
+        load1, load5, load15 = psutil.getloadavg()
+        cpus = psutil.cpu_count()
+        self.update_metric_tracker('train_time', time_spent, pair)
+        self.update_metric_tracker('cpu_load1min', load1 / cpus, pair)
+        self.update_metric_tracker('cpu_load5min', load5 / cpus, pair)
+        self.update_metric_tracker('cpu_load15min', load15 / cpus, pair)
 
     def load_drawer_from_disk(self):
         """
         Locate and load a previously saved data drawer full of all pair model metadata in
         present model folder.
-        :return: bool - whether or not the drawer was located
+        Load any existing metric tracker that may be present.
         """
         exists = self.pair_dictionary_path.is_file()
         if exists:
             with open(self.pair_dictionary_path, "r") as fp:
-                self.pair_dict = json.load(fp)
+                self.pair_dict = rapidjson.load(fp, number_mode=rapidjson.NM_NATIVE)
         elif not self.follow_mode:
             logger.info("Could not find existing datadrawer, starting from scratch")
         else:
@@ -117,7 +143,19 @@ class FreqaiDataDrawer:
                 "sending null values back to strategy"
             )
 
-        return exists
+    def load_metric_tracker_from_disk(self):
+        """
+        Tries to load an existing metrics dictionary if the user
+        wants to collect metrics.
+        """
+        if self.freqai_info.get('write_metrics_to_disk', False):
+            exists = self.metric_tracker_path.is_file()
+            if exists:
+                with open(self.metric_tracker_path, "r") as fp:
+                    self.metric_tracker = rapidjson.load(fp, number_mode=rapidjson.NM_NATIVE)
+                logger.info("Loading existing metric tracker from disk.")
+            else:
+                logger.info("Could not find existing metric tracker, starting from scratch")
 
     def load_historic_predictions_from_disk(self):
         """
@@ -153,7 +191,7 @@ class FreqaiDataDrawer:
 
     def save_historic_predictions_to_disk(self):
         """
-        Save data drawer full of all pair model metadata in present model folder.
+        Save historic predictions pickle to disk
         """
         with open(self.historic_predictions_path, "wb") as fp:
             cloudpickle.dump(self.historic_predictions, fp, protocol=cloudpickle.DEFAULT_PROTOCOL)
@@ -161,6 +199,15 @@ class FreqaiDataDrawer:
         # create a backup
         shutil.copy(self.historic_predictions_path, self.historic_predictions_bkp_path)
 
+    def save_metric_tracker_to_disk(self):
+        """
+        Save metric tracker of all pair metrics collected.
+        """
+        with self.save_lock:
+            with open(self.metric_tracker_path, 'w') as fp:
+                rapidjson.dump(self.metric_tracker, fp, default=self.np_encoder,
+                               number_mode=rapidjson.NM_NATIVE)
+
     def save_drawer_to_disk(self):
         """
         Save data drawer full of all pair model metadata in present model folder.
@@ -419,9 +466,8 @@ class FreqaiDataDrawer:
     def save_data(self, model: Any, coin: str, dk: FreqaiDataKitchen) -> None:
         """
         Saves all data associated with a model for a single sub-train time range
-        :params:
-        :model: User trained model which can be reused for inferencing to generate
-        predictions
+        :param model: User trained model which can be reused for inferencing to generate
+                      predictions
         """
 
         if not dk.data_path.is_dir():
@@ -430,12 +476,10 @@ class FreqaiDataDrawer:
         save_path = Path(dk.data_path)
 
         # Save the trained model
-        if self.model_type == 'joblib':
+        if not dk.keras:
             dump(model, save_path / f"{dk.model_filename}_model.joblib")
-        elif self.model_type == 'keras':
+        else:
             model.save(save_path / f"{dk.model_filename}_model.h5")
-        elif 'stable_baselines' in self.model_type:
-            model.save(save_path / f"{dk.model_filename}_model.zip")
 
         if dk.svm_model is not None:
             dump(dk.svm_model, save_path / f"{dk.model_filename}_svm_model.joblib")
@@ -462,10 +506,15 @@ class FreqaiDataDrawer:
                 dk.pca, open(dk.data_path / f"{dk.model_filename}_pca_object.pkl", "wb")
             )
 
-        if not self.limit_ram_use:
-            self.model_dictionary[coin] = model
+        # if self.live:
+        # store as much in ram as possible to increase performance
+        self.model_dictionary[coin] = model
         self.pair_dict[coin]["model_filename"] = dk.model_filename
         self.pair_dict[coin]["data_path"] = str(dk.data_path)
+        if coin not in self.meta_data_dictionary:
+            self.meta_data_dictionary[coin] = {}
+        self.meta_data_dictionary[coin]["train_df"] = dk.data_dictionary["train_features"]
+        self.meta_data_dictionary[coin]["meta_data"] = dk.data
         self.save_drawer_to_disk()
 
         return
@@ -476,7 +525,7 @@ class FreqaiDataDrawer:
         presaved backtesting (prediction file loading).
         """
         with open(dk.data_path / f"{dk.model_filename}_metadata.json", "r") as fp:
-            dk.data = json.load(fp)
+            dk.data = rapidjson.load(fp, number_mode=rapidjson.NM_NATIVE)
             dk.training_features_list = dk.data["training_features_list"]
             dk.label_list = dk.data["label_list"]
 
@@ -502,28 +551,29 @@ class FreqaiDataDrawer:
                     / dk.data_path.parts[-1]
                 )
 
-        with open(dk.data_path / f"{dk.model_filename}_metadata.json", "r") as fp:
-            dk.data = json.load(fp)
-            dk.training_features_list = dk.data["training_features_list"]
-            dk.label_list = dk.data["label_list"]
+        if coin in self.meta_data_dictionary:
+            dk.data = self.meta_data_dictionary[coin]["meta_data"]
+            dk.data_dictionary["train_features"] = self.meta_data_dictionary[coin]["train_df"]
+        else:
+            with open(dk.data_path / f"{dk.model_filename}_metadata.json", "r") as fp:
+                dk.data = rapidjson.load(fp, number_mode=rapidjson.NM_NATIVE)
 
-        dk.data_dictionary["train_features"] = pd.read_pickle(
-            dk.data_path / f"{dk.model_filename}_trained_df.pkl"
-        )
+            dk.data_dictionary["train_features"] = pd.read_pickle(
+                dk.data_path / f"{dk.model_filename}_trained_df.pkl"
+            )
+
+        dk.training_features_list = dk.data["training_features_list"]
+        dk.label_list = dk.data["label_list"]
 
         # try to access model in memory instead of loading object from disk to save time
-        if dk.live and coin in self.model_dictionary and not self.limit_ram_use:
+        if dk.live and coin in self.model_dictionary:
             model = self.model_dictionary[coin]
-        elif self.model_type == 'joblib':
+        elif not dk.keras:
             model = load(dk.data_path / f"{dk.model_filename}_model.joblib")
-        elif self.model_type == 'keras':
+        else:
             from tensorflow import keras
+
             model = keras.models.load_model(dk.data_path / f"{dk.model_filename}_model.h5")
-        elif self.model_type == 'stable_baselines':
-            mod = __import__('stable_baselines3', fromlist=[
-                             self.freqai_info['rl_config']['model_type']])
-            MODELCLASS = getattr(mod, self.freqai_info['rl_config']['model_type'])
-            model = MODELCLASS.load(dk.data_path / f"{dk.model_filename}_model")
 
         if Path(dk.data_path / f"{dk.model_filename}_svm_model.joblib").is_file():
             dk.svm_model = load(dk.data_path / f"{dk.model_filename}_svm_model.joblib")
@@ -533,10 +583,6 @@ class FreqaiDataDrawer:
                 f"Unable to load model, ensure model exists at " f"{dk.data_path} "
             )
 
-        # load it into ram if it was loaded from disk
-        if coin not in self.model_dictionary and not self.limit_ram_use:
-            self.model_dictionary[coin] = model
-
         if self.config["freqai"]["feature_parameters"]["principal_component_analysis"]:
             dk.pca = cloudpickle.load(
                 open(dk.data_path / f"{dk.model_filename}_pca_object.pkl", "rb")
@@ -549,8 +595,7 @@ class FreqaiDataDrawer:
         Append new candles to our stores historic data (in memory) so that
         we do not need to load candle history from disk and we dont need to
         pinging exchange multiple times for the same candle.
-        :params:
-        dataframe: DataFrame = strategy provided dataframe
+        :param dataframe: DataFrame = strategy provided dataframe
         """
         feat_params = self.freqai_info["feature_parameters"]
         with self.history_lock:
@@ -592,13 +637,14 @@ class FreqaiDataDrawer:
                         axis=0,
                     )
 
+            self.current_candle = history_data[dk.pair][self.config['timeframe']].iloc[-1]['date']
+
     def load_all_pair_histories(self, timerange: TimeRange, dk: FreqaiDataKitchen) -> None:
         """
         Load pair histories for all whitelist and corr_pairlist pairs.
         Only called once upon startup of bot.
-        :params:
-        timerange: TimeRange = full timerange required to populate all indicators
-        for training according to user defined train_period_days
+        :param timerange: TimeRange = full timerange required to populate all indicators
+                          for training according to user defined train_period_days
         """
         history_data = self.historic_data
 
@@ -621,10 +667,9 @@ class FreqaiDataDrawer:
         """
         Searches through our historic_data in memory and returns the dataframes relevant
         to the present pair.
-        :params:
-        timerange: TimeRange = full timerange required to populate all indicators
-        for training according to user defined train_period_days
-        metadata: dict = strategy furnished pair metadata
+        :param timerange: TimeRange = full timerange required to populate all indicators
+                          for training according to user defined train_period_days
+        :param metadata: dict = strategy furnished pair metadata
         """
         with self.history_lock:
             corr_dataframes: Dict[Any, Any] = {}
@@ -635,7 +680,8 @@ class FreqaiDataDrawer:
             )
 
             for tf in self.freqai_info["feature_parameters"].get("include_timeframes"):
-                base_dataframes[tf] = dk.slice_dataframe(timerange, historic_data[pair][tf])
+                base_dataframes[tf] = dk.slice_dataframe(
+                    timerange, historic_data[pair][tf]).reset_index(drop=True)
                 if pairs:
                     for p in pairs:
                         if pair in p:
@@ -644,6 +690,6 @@ class FreqaiDataDrawer:
                             corr_dataframes[p] = {}
                         corr_dataframes[p][tf] = dk.slice_dataframe(
                             timerange, historic_data[p][tf]
-                        )
+                        ).reset_index(drop=True)
 
         return corr_dataframes, base_dataframes

freqtrade/freqai/data_kitchen.py

@@ -1,7 +1,7 @@
 import copy
 import logging
 import shutil
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from math import cos, sin
 from pathlib import Path
 from typing import Any, Dict, List, Tuple
@@ -9,7 +9,6 @@ from typing import Any, Dict, List, Tuple
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
-import psutil
 from pandas import DataFrame
 from scipy import stats
 from sklearn import linear_model
@@ -20,6 +19,7 @@ from sklearn.neighbors import NearestNeighbors
 
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import Config
+from freqtrade.data.converter import reduce_dataframe_footprint
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_seconds
 from freqtrade.strategy.interface import IStrategy
@@ -77,33 +77,36 @@ class FreqaiDataKitchen:
         self.backtest_predictions_folder: str = "backtesting_predictions"
         self.live = live
         self.pair = pair
-        self.model_save_type = self.freqai_config.get('model_save_type', 'joblib')
 
         self.svm_model: linear_model.SGDOneClassSVM = None
-        # self.model_save_type: bool = self.freqai_config.get("keras", False)
+        self.keras: bool = self.freqai_config.get("keras", False)
         self.set_all_pairs()
-        if not self.live:
-            if not self.config["timerange"]:
-                raise OperationalException(
-                    'Please pass --timerange if you intend to use FreqAI for backtesting.')
-            self.full_timerange = self.create_fulltimerange(
-                self.config["timerange"], self.freqai_config.get("train_period_days", 0)
-            )
+        self.backtest_live_models = config.get("freqai_backtest_live_models", False)
 
-            (self.training_timeranges, self.backtesting_timeranges) = self.split_timerange(
-                self.full_timerange,
-                config["freqai"]["train_period_days"],
-                config["freqai"]["backtest_period_days"],
-            )
+        if not self.live:
+            self.full_path = self.get_full_models_path(self.config)
+
+            if self.backtest_live_models:
+                if self.pair:
+                    self.set_timerange_from_ready_models()
+                    (self.training_timeranges,
+                     self.backtesting_timeranges) = self.split_timerange_live_models()
+            else:
+                self.full_timerange = self.create_fulltimerange(
+                    self.config["timerange"], self.freqai_config.get("train_period_days", 0)
+                )
+                (self.training_timeranges, self.backtesting_timeranges) = self.split_timerange(
+                    self.full_timerange,
+                    config["freqai"]["train_period_days"],
+                    config["freqai"]["backtest_period_days"],
+                )
 
         self.data['extra_returns_per_train'] = self.freqai_config.get('extra_returns_per_train', {})
-        if not self.freqai_config.get("data_kitchen_thread_count", 0):
-            self.thread_count = max(int(psutil.cpu_count() * 2 - 2), 1)
-        else:
-            self.thread_count = self.freqai_config["data_kitchen_thread_count"]
+        self.thread_count = self.freqai_config.get("data_kitchen_thread_count", -1)
         self.train_dates: DataFrame = pd.DataFrame()
         self.unique_classes: Dict[str, list] = {}
         self.unique_class_list: list = []
+        self.backtest_live_models_data: Dict[str, Any] = {}
 
     def set_paths(
         self,
@@ -112,14 +115,10 @@ class FreqaiDataKitchen:
     ) -> None:
         """
         Set the paths to the data for the present coin/botloop
-        :params:
-        metadata: dict = strategy furnished pair metadata
-        trained_timestamp: int = timestamp of most recent training
+        :param metadata: dict = strategy furnished pair metadata
+        :param trained_timestamp: int = timestamp of most recent training
         """
-        self.full_path = Path(
-            self.config["user_data_dir"] / "models" / str(self.freqai_config.get("identifier"))
-        )
-
+        self.full_path = self.get_full_models_path(self.config)
         self.data_path = Path(
             self.full_path
             / f"sub-train-{pair.split('/')[0]}_{trained_timestamp}"
@@ -134,8 +133,8 @@ class FreqaiDataKitchen:
         Given the dataframe for the full history for training, split the data into
         training and test data according to user specified parameters in configuration
         file.
-        :filtered_dataframe: cleaned dataframe ready to be split.
-        :labels: cleaned labels ready to be split.
+        :param filtered_dataframe: cleaned dataframe ready to be split.
+        :param labels: cleaned labels ready to be split.
         """
         feat_dict = self.freqai_config["feature_parameters"]
 
@@ -194,13 +193,14 @@ class FreqaiDataKitchen:
         remove all NaNs. Any row with a NaN is removed from training dataset or replaced with
         0s in the prediction dataset. However, prediction dataset do_predict will reflect any
         row that had a NaN and will shield user from that prediction.
-        :params:
-        :unfiltered_df: the full dataframe for the present training period
-        :training_feature_list: list, the training feature list constructed by
-        self.build_feature_list() according to user specified parameters in the configuration file.
-        :labels: the labels for the dataset
-        :training_filter: boolean which lets the function know if it is training data or
-        prediction data to be filtered.
+
+        :param unfiltered_df: the full dataframe for the present training period
+        :param training_feature_list: list, the training feature list constructed by
+                                      self.build_feature_list() according to user specified
+                                      parameters in the configuration file.
+        :param labels: the labels for the dataset
+        :param training_filter: boolean which lets the function know if it is training data or
+                                prediction data to be filtered.
         :returns:
         :filtered_df: dataframe cleaned of NaNs and only containing the user
         requested feature set.
@@ -215,7 +215,10 @@ class FreqaiDataKitchen:
             const_cols = list((filtered_df.nunique() == 1).loc[lambda x: x].index)
             if const_cols:
                 filtered_df = filtered_df.filter(filtered_df.columns.difference(const_cols))
+                self.data['constant_features_list'] = const_cols
                 logger.warning(f"Removed features {const_cols} with constant values.")
+            else:
+                self.data['constant_features_list'] = []
             # we don't care about total row number (total no. datapoints) in training, we only care
             # about removing any row with NaNs
             # if labels has multiple columns (user wants to train multiple modelEs), we detect here
@@ -246,6 +249,8 @@ class FreqaiDataKitchen:
             self.data["filter_drop_index_training"] = drop_index
 
         else:
+            if 'constant_features_list' in self.data and len(self.data['constant_features_list']):
+                filtered_df = self.check_pred_labels(filtered_df)
             # we are backtesting so we need to preserve row number to send back to strategy,
             # so now we use do_predict to avoid any prediction based on a NaN
             drop_index = pd.isnull(filtered_df).any(axis=1)
@@ -290,8 +295,8 @@ class FreqaiDataKitchen:
     def normalize_data(self, data_dictionary: Dict) -> Dict[Any, Any]:
         """
         Normalize all data in the data_dictionary according to the training dataset
-        :params:
-        :data_dictionary: dictionary containing the cleaned and split training/test data/labels
+        :param data_dictionary: dictionary containing the cleaned and
+                                split training/test data/labels
         :returns:
         :data_dictionary: updated dictionary with standardized values.
         """
@@ -354,13 +359,19 @@ class FreqaiDataKitchen:
         :param df: Dataframe to be standardized
         """
 
-        for item in df.keys():
-            df[item] = (
-                2
-                * (df[item] - self.data[f"{item}_min"])
-                / (self.data[f"{item}_max"] - self.data[f"{item}_min"])
-                - 1
-            )
+        train_max = [None] * len(df.keys())
+        train_min = [None] * len(df.keys())
+
+        for i, item in enumerate(df.keys()):
+            train_max[i] = self.data[f"{item}_max"]
+            train_min[i] = self.data[f"{item}_min"]
+
+        train_max_series = pd.Series(train_max, index=df.keys())
+        train_min_series = pd.Series(train_min, index=df.keys())
+
+        df = (
+            2 * (df - train_min_series) / (train_max_series - train_min_series) - 1
+        )
 
         return df
 
@@ -422,9 +433,7 @@ class FreqaiDataKitchen:
             timerange_train.stopts = timerange_train.startts + train_period_days
 
             first = False
-            start = datetime.fromtimestamp(timerange_train.startts, tz=timezone.utc)
-            stop = datetime.fromtimestamp(timerange_train.stopts, tz=timezone.utc)
-            tr_training_list.append(start.strftime("%Y%m%d") + "-" + stop.strftime("%Y%m%d"))
+            tr_training_list.append(timerange_train.timerange_str)
             tr_training_list_timerange.append(copy.deepcopy(timerange_train))
 
             # associated backtest period
@@ -436,9 +445,7 @@ class FreqaiDataKitchen:
             if timerange_backtest.stopts > config_timerange.stopts:
                 timerange_backtest.stopts = config_timerange.stopts
 
-            start = datetime.fromtimestamp(timerange_backtest.startts, tz=timezone.utc)
-            stop = datetime.fromtimestamp(timerange_backtest.stopts, tz=timezone.utc)
-            tr_backtesting_list.append(start.strftime("%Y%m%d") + "-" + stop.strftime("%Y%m%d"))
+            tr_backtesting_list.append(timerange_backtest.timerange_str)
             tr_backtesting_list_timerange.append(copy.deepcopy(timerange_backtest))
 
             # ensure we are predicting on exactly same amount of data as requested by user defined
@@ -449,6 +456,29 @@ class FreqaiDataKitchen:
         # print(tr_training_list, tr_backtesting_list)
         return tr_training_list_timerange, tr_backtesting_list_timerange
 
+    def split_timerange_live_models(
+        self
+    ) -> Tuple[list, list]:
+
+        tr_backtesting_list_timerange = []
+        asset = self.pair.split("/")[0]
+        if asset not in self.backtest_live_models_data["assets_end_dates"]:
+            raise OperationalException(
+                f"Model not available for pair {self.pair}. "
+                "Please, try again after removing this pair from the configuration file."
+            )
+        asset_data = self.backtest_live_models_data["assets_end_dates"][asset]
+        backtesting_timerange = self.backtest_live_models_data["backtesting_timerange"]
+        model_end_dates = [x for x in asset_data]
+        model_end_dates.append(backtesting_timerange.stopts)
+        model_end_dates.sort()
+        for index, item in enumerate(model_end_dates):
+            if len(model_end_dates) > (index + 1):
+                tr_to_add = TimeRange("date", "date", item, model_end_dates[index + 1])
+                tr_backtesting_list_timerange.append(tr_to_add)
+
+        return tr_backtesting_list_timerange, tr_backtesting_list_timerange
+
     def slice_dataframe(self, timerange: TimeRange, df: DataFrame) -> DataFrame:
         """
         Given a full dataframe, extract the user desired window
@@ -457,14 +487,28 @@ class FreqaiDataKitchen:
                    it is sliced down to just the present training period.
         """
 
-        start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
-        stop = datetime.fromtimestamp(timerange.stopts, tz=timezone.utc)
-        df = df.loc[df["date"] >= start, :]
+        df = df.loc[df["date"] >= timerange.startdt, :]
         if not self.live:
-            df = df.loc[df["date"] < stop, :]
+            df = df.loc[df["date"] < timerange.stopdt, :]
 
         return df
 
+    def check_pred_labels(self, df_predictions: DataFrame) -> DataFrame:
+        """
+        Check that prediction feature labels match training feature labels.
+        :param df_predictions: incoming predictions
+        """
+        constant_labels = self.data['constant_features_list']
+        df_predictions = df_predictions.filter(
+            df_predictions.columns.difference(constant_labels)
+        )
+        logger.warning(
+            f"Removed {len(constant_labels)} features from prediction features, "
+            f"these were considered constant values during most recent training."
+        )
+
+        return df_predictions
+
     def principal_component_analysis(self) -> None:
         """
         Performs Principal Component Analysis on the data for dimensionality reduction
@@ -521,8 +565,7 @@ class FreqaiDataKitchen:
     def pca_transform(self, filtered_dataframe: DataFrame) -> None:
         """
         Use an existing pca transform to transform data into components
-        :params:
-        filtered_dataframe: DataFrame = the cleaned dataframe
+        :param filtered_dataframe: DataFrame = the cleaned dataframe
         """
         pca_components = self.pca.transform(filtered_dataframe)
         self.data_dictionary["prediction_features"] = pd.DataFrame(
@@ -566,11 +609,10 @@ class FreqaiDataKitchen:
         """
         Build/inference a Support Vector Machine to detect outliers
         in training data and prediction
-        :params:
-        predict: bool = If true, inference an existing SVM model, else construct one
+        :param predict: bool = If true, inference an existing SVM model, else construct one
         """
 
-        if self.model_save_type == 'keras':
+        if self.keras:
             logger.warning(
                 "SVM outlier removal not currently supported for Keras based models. "
                 "Skipping user requested function."
@@ -652,11 +694,11 @@ class FreqaiDataKitchen:
         Use DBSCAN to cluster training data and remove "noisy" data (read outliers).
         User controls this via the config param `DBSCAN_outlier_pct` which indicates the
         pct of training data that they want to be considered outliers.
-        :params:
-        predict: bool = If False (training), iterate to find the best hyper parameters to match
-        user requested outlier percent target. If True (prediction), use the parameters
-        determined from the previous training to estimate if the current prediction point
-        is an outlier.
+        :param predict: bool = If False (training), iterate to find the best hyper parameters
+                        to match user requested outlier percent target.
+                        If True (prediction), use the parameters determined from
+                        the previous training to estimate if the current prediction point
+                        is an outlier.
         """
 
         if predict:
@@ -942,8 +984,13 @@ class FreqaiDataKitchen:
             append_df[label] = predictions[label]
             if append_df[label].dtype == object:
                 continue
-            append_df[f"{label}_mean"] = self.data["labels_mean"][label]
-            append_df[f"{label}_std"] = self.data["labels_std"][label]
+            if "labels_mean" in self.data:
+                append_df[f"{label}_mean"] = self.data["labels_mean"][label]
+            if "labels_std" in self.data:
+                append_df[f"{label}_std"] = self.data["labels_std"][label]
+
+        for extra_col in self.data["extra_returns_per_train"]:
+            append_df[f"{extra_col}"] = self.data["extra_returns_per_train"][extra_col]
 
         append_df["do_predict"] = do_predict
         if self.freqai_config["feature_parameters"].get("DI_threshold", 0) > 0:
@@ -1005,14 +1052,7 @@ class FreqaiDataKitchen:
         backtest_timerange.startts = (
             backtest_timerange.startts - backtest_period_days * SECONDS_IN_DAY
         )
-        start = datetime.fromtimestamp(backtest_timerange.startts, tz=timezone.utc)
-        stop = datetime.fromtimestamp(backtest_timerange.stopts, tz=timezone.utc)
-        full_timerange = start.strftime("%Y%m%d") + "-" + stop.strftime("%Y%m%d")
-
-        self.full_path = Path(
-            self.config["user_data_dir"] / "models" / f"{self.freqai_config['identifier']}"
-        )
-
+        full_timerange = backtest_timerange.timerange_str
         config_path = Path(self.config["config_files"][0])
 
         if not self.full_path.is_dir():
@@ -1095,15 +1135,15 @@ class FreqaiDataKitchen:
 
         return retrain, trained_timerange, data_load_timerange
 
-    def set_new_model_names(self, pair: str, trained_timerange: TimeRange):
+    def set_new_model_names(self, pair: str, timestamp_id: int):
 
         coin, _ = pair.split("/")
         self.data_path = Path(
             self.full_path
-            / f"sub-train-{pair.split('/')[0]}_{int(trained_timerange.stopts)}"
+            / f"sub-train-{pair.split('/')[0]}_{timestamp_id}"
         )
 
-        self.model_filename = f"cb_{coin.lower()}_{int(trained_timerange.stopts)}"
+        self.model_filename = f"cb_{coin.lower()}_{timestamp_id}"
 
     def set_all_pairs(self) -> None:
 
@@ -1114,6 +1154,54 @@ class FreqaiDataKitchen:
             if pair not in self.all_pairs:
                 self.all_pairs.append(pair)
 
+    def extract_corr_pair_columns_from_populated_indicators(
+        self,
+        dataframe: DataFrame
+    ) -> Dict[str, DataFrame]:
+        """
+        Find the columns of the dataframe corresponding to the corr_pairlist, save them
+        in a dictionary to be reused and attached to other pairs.
+
+        :param dataframe: fully populated dataframe (current pair + corr_pairs)
+        :return: corr_dataframes, dictionary of dataframes to be attached
+                 to other pairs in same candle.
+        """
+        corr_dataframes: Dict[str, DataFrame] = {}
+        pairs = self.freqai_config["feature_parameters"].get("include_corr_pairlist", [])
+
+        for pair in pairs:
+            pair = pair.replace(':', '')  # lightgbm doesnt like colons
+            valid_strs = [f"%-{pair}", f"%{pair}", f"%_{pair}"]
+            pair_cols = [col for col in dataframe.columns if
+                         any(substr in col for substr in valid_strs)]
+            if pair_cols:
+                pair_cols.insert(0, 'date')
+                corr_dataframes[pair] = dataframe.filter(pair_cols, axis=1)
+
+        return corr_dataframes
+
+    def attach_corr_pair_columns(self, dataframe: DataFrame,
+                                 corr_dataframes: Dict[str, DataFrame],
+                                 current_pair: str) -> DataFrame:
+        """
+        Attach the existing corr_pair dataframes to the current pair dataframe before training
+
+        :param dataframe: current pair strategy dataframe, indicators populated already
+        :param corr_dataframes: dictionary of saved dataframes from earlier in the same candle
+        :param current_pair: current pair to which we will attach corr pair dataframe
+        :return:
+        :dataframe: current pair dataframe of populated indicators, concatenated with corr_pairs
+                    ready for training
+        """
+        pairs = self.freqai_config["feature_parameters"].get("include_corr_pairlist", [])
+        current_pair = current_pair.replace(':', '')
+        for pair in pairs:
+            pair = pair.replace(':', '')  # lightgbm doesnt work with colons
+            if current_pair != pair:
+                dataframe = dataframe.merge(corr_dataframes[pair], how='left', on='date')
+
+        return dataframe
+
     def use_strategy_to_populate_indicators(
         self,
         strategy: IStrategy,
@@ -1121,26 +1209,25 @@ class FreqaiDataKitchen:
         base_dataframes: dict = {},
         pair: str = "",
         prediction_dataframe: DataFrame = pd.DataFrame(),
+        do_corr_pairs: bool = True,
     ) -> DataFrame:
         """
-        Use the user defined strategy for populating indicators during
-        retrain
-        :params:
-        strategy: IStrategy = user defined strategy object
-        corr_dataframes: dict = dict containing the informative pair dataframes
-        (for user defined timeframes)
-        base_dataframes: dict = dict containing the current pair dataframes
-        (for user defined timeframes)
-        metadata: dict = strategy furnished pair metadata
-        :returns:
+        Use the user defined strategy for populating indicators during retrain
+        :param strategy: IStrategy = user defined strategy object
+        :param corr_dataframes: dict = dict containing the informative pair dataframes
+                                (for user defined timeframes)
+        :param base_dataframes: dict = dict containing the current pair dataframes
+                                (for user defined timeframes)
+        :param metadata: dict = strategy furnished pair metadata
+        :return:
         dataframe: DataFrame = dataframe containing populated indicators
         """
 
         # for prediction dataframe creation, we let dataprovider handle everything in the strategy
         # so we create empty dictionaries, which allows us to pass None to
         # `populate_any_indicators()`. Signaling we want the dp to give us the live dataframe.
-        tfs = self.freqai_config["feature_parameters"].get("include_timeframes")
-        pairs = self.freqai_config["feature_parameters"].get("include_corr_pairlist", [])
+        tfs: List[str] = self.freqai_config["feature_parameters"].get("include_timeframes")
+        pairs: List[str] = self.freqai_config["feature_parameters"].get("include_corr_pairlist", [])
         if not prediction_dataframe.empty:
             dataframe = prediction_dataframe.copy()
             for tf in tfs:
@@ -1163,19 +1250,27 @@ class FreqaiDataKitchen:
                 informative=base_dataframes[tf],
                 set_generalized_indicators=sgi
             )
-            if pairs:
-                for i in pairs:
-                    if pair in i:
-                        continue  # dont repeat anything from whitelist
+
+        # ensure corr pairs are always last
+        for corr_pair in pairs:
+            if pair == corr_pair:
+                continue  # dont repeat anything from whitelist
+            for tf in tfs:
+                if pairs and do_corr_pairs:
                     dataframe = strategy.populate_any_indicators(
-                        i,
+                        corr_pair,
                         dataframe.copy(),
                         tf,
-                        informative=corr_dataframes[i][tf]
+                        informative=corr_dataframes[corr_pair][tf]
                     )
 
         self.get_unique_classes_from_labels(dataframe)
 
+        dataframe = self.remove_special_chars_from_feature_names(dataframe)
+
+        if self.config.get('reduce_df_footprint', False):
+            dataframe = reduce_dataframe_footprint(dataframe)
+
         return dataframe
 
     def fit_labels(self) -> None:
@@ -1242,14 +1337,16 @@ class FreqaiDataKitchen:
         append_df = pd.read_hdf(self.backtesting_results_path)
         return append_df
 
-    def check_if_backtest_prediction_exists(
-        self
+    def check_if_backtest_prediction_is_valid(
+        self,
+        len_backtest_df: int
     ) -> bool:
         """
-        Check if a backtesting prediction already exists
-        :param dk: FreqaiDataKitchen
+        Check if a backtesting prediction already exists and if the predictions
+        to append have the same size as the backtesting dataframe slice
+        :param length_backtesting_dataframe: Length of backtesting dataframe slice
         :return:
-        :boolean: whether the prediction file exists or not.
+        :boolean: whether the prediction file is valid.
         """
         path_to_predictionfile = Path(self.full_path /
                                       self.backtest_predictions_folder /
@@ -1257,10 +1354,134 @@ class FreqaiDataKitchen:
         self.backtesting_results_path = path_to_predictionfile
 
         file_exists = path_to_predictionfile.is_file()
+
         if file_exists:
-            logger.info(f"Found backtesting prediction file at {path_to_predictionfile}")
+            append_df = self.get_backtesting_prediction()
+            if len(append_df) == len_backtest_df:
+                logger.info(f"Found backtesting prediction file at {path_to_predictionfile}")
+                return True
+            else:
+                logger.info("A new backtesting prediction file is required. "
+                            "(Number of predictions is different from dataframe length).")
+                return False
         else:
             logger.info(
                 f"Could not find backtesting prediction file at {path_to_predictionfile}"
             )
-        return file_exists
+            return False
+
+    def set_timerange_from_ready_models(self):
+        backtesting_timerange, \
+            assets_end_dates = (
+                self.get_timerange_and_assets_end_dates_from_ready_models(self.full_path))
+
+        self.backtest_live_models_data = {
+            "backtesting_timerange": backtesting_timerange,
+            "assets_end_dates": assets_end_dates
+            }
+        return
+
+    def get_full_models_path(self, config: Config) -> Path:
+        """
+        Returns default FreqAI model path
+        :param config: Configuration dictionary
+        """
+        freqai_config: Dict[str, Any] = config["freqai"]
+        return Path(
+            config["user_data_dir"] / "models" / str(freqai_config.get("identifier"))
+        )
+
+    def get_timerange_and_assets_end_dates_from_ready_models(
+            self, models_path: Path) -> Tuple[TimeRange, Dict[str, Any]]:
+        """
+        Returns timerange information based on a FreqAI model directory
+        :param models_path: FreqAI model path
+
+        :return: a Tuple with (Timerange calculated from directory and
+        a Dict with pair and model end training dates info)
+        """
+        all_models_end_dates = []
+        assets_end_dates: Dict[str, Any] = self.get_assets_timestamps_training_from_ready_models(
+                                           models_path)
+        for key in assets_end_dates:
+            for model_end_date in assets_end_dates[key]:
+                if model_end_date not in all_models_end_dates:
+                    all_models_end_dates.append(model_end_date)
+
+        if len(all_models_end_dates) == 0:
+            raise OperationalException(
+                'At least 1 saved model is required to '
+                'run backtest with the freqai-backtest-live-models option'
+            )
+
+        if len(all_models_end_dates) == 1:
+            logger.warning(
+                "Only 1 model was found. Backtesting will run with the "
+                "timerange from the end of the training date to the current date"
+            )
+
+        finish_timestamp = int(datetime.now(tz=timezone.utc).timestamp())
+        if len(all_models_end_dates) > 1:
+            # After last model end date, use the same period from previous model
+            # to finish the backtest
+            all_models_end_dates.sort(reverse=True)
+            finish_timestamp = all_models_end_dates[0] + \
+                (all_models_end_dates[0] - all_models_end_dates[1])
+
+        all_models_end_dates.append(finish_timestamp)
+        all_models_end_dates.sort()
+        start_date = (datetime(*datetime.fromtimestamp(min(all_models_end_dates),
+                      timezone.utc).timetuple()[:3], tzinfo=timezone.utc))
+        end_date = (datetime(*datetime.fromtimestamp(max(all_models_end_dates),
+                    timezone.utc).timetuple()[:3], tzinfo=timezone.utc))
+
+        # add 1 day to string timerange to ensure BT module will load all dataframe data
+        end_date = end_date + timedelta(days=1)
+        backtesting_timerange = TimeRange(
+            'date', 'date', int(start_date.timestamp()), int(end_date.timestamp())
+        )
+        return backtesting_timerange, assets_end_dates
+
+    def get_assets_timestamps_training_from_ready_models(
+            self, models_path: Path) -> Dict[str, Any]:
+        """
+        Scan the models path and returns all assets end training dates (timestamp)
+        :param models_path: FreqAI model path
+
+        :return: a Dict with asset and model end training dates info
+        """
+        assets_end_dates: Dict[str, Any] = {}
+        if not models_path.is_dir():
+            raise OperationalException(
+                'Model folders not found. Saved models are required '
+                'to run backtest with the freqai-backtest-live-models option'
+            )
+        for model_dir in models_path.iterdir():
+            if str(model_dir.name).startswith("sub-train"):
+                model_end_date = int(model_dir.name.split("_")[1])
+                asset = model_dir.name.split("_")[0].replace("sub-train-", "")
+                model_file_name = (
+                    f"cb_{str(model_dir.name).replace('sub-train-', '').lower()}"
+                    "_model.joblib"
+                )
+
+                model_path_file = Path(model_dir / model_file_name)
+                if model_path_file.is_file():
+                    if asset not in assets_end_dates:
+                        assets_end_dates[asset] = []
+                    assets_end_dates[asset].append(model_end_date)
+
+        return assets_end_dates
+
+    def remove_special_chars_from_feature_names(self, dataframe: pd.DataFrame) -> pd.DataFrame:
+        """
+        Remove all special characters from feature strings (:)
+        :param dataframe: the dataframe that just finished indicator population. (unfiltered)
+        :return: dataframe with cleaned featrue names
+        """
+
+        spec_chars = [':']
+        for c in spec_chars:
+            dataframe.columns = dataframe.columns.str.replace(c, "")
+
+        return dataframe

freqtrade/freqai/freqai_interface.py

@@ -1,28 +1,25 @@
 import logging
-import shutil
 import threading
 import time
 from abc import ABC, abstractmethod
 from collections import deque
 from datetime import datetime, timezone
 from pathlib import Path
-from threading import Lock
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Literal, Tuple
 
 import numpy as np
 import pandas as pd
-import psutil
 from numpy.typing import NDArray
 from pandas import DataFrame
 
 from freqtrade.configuration import TimeRange
-from freqtrade.constants import DATETIME_PRINT_FORMAT, Config
+from freqtrade.constants import Config
 from freqtrade.enums import RunMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_seconds
 from freqtrade.freqai.data_drawer import FreqaiDataDrawer
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-from freqtrade.freqai.utils import plot_feature_importance
+from freqtrade.freqai.utils import plot_feature_importance, record_params
 from freqtrade.strategy.interface import IStrategy
 
 
@@ -62,6 +59,7 @@ class IFreqaiModel(ABC):
             "data_split_parameters", {})
         self.model_training_parameters: Dict[str, Any] = config.get("freqai", {}).get(
             "model_training_parameters", {})
+        self.identifier: str = self.freqai_info.get("identifier", "no_id_provided")
         self.retrain = False
         self.first = True
         self.set_full_path()
@@ -70,23 +68,23 @@ class IFreqaiModel(ABC):
         if self.save_backtest_models:
             logger.info('Backtesting module configured to save all models.')
         self.dd = FreqaiDataDrawer(Path(self.full_path), self.config, self.follow_mode)
-        self.identifier: str = self.freqai_info.get("identifier", "no_id_provided")
+        # set current candle to arbitrary historical date
+        self.current_candle: datetime = datetime.fromtimestamp(637887600, tz=timezone.utc)
+        self.dd.current_candle = self.current_candle
         self.scanning = False
         self.ft_params = self.freqai_info["feature_parameters"]
-        # self.keras: bool = self.freqai_info.get("keras", False)
-        # if self.keras and self.ft_params.get("DI_threshold", 0):
-        #     self.ft_params["DI_threshold"] = 0
-        #     logger.warning("DI threshold is not configured for Keras models yet. Deactivating.")
-        self.CONV_WIDTH = self.freqai_info.get("conv_width", 2)
+        self.corr_pairlist: List[str] = self.ft_params.get("include_corr_pairlist", [])
+        self.keras: bool = self.freqai_info.get("keras", False)
+        if self.keras and self.ft_params.get("DI_threshold", 0):
+            self.ft_params["DI_threshold"] = 0
+            logger.warning("DI threshold is not configured for Keras models yet. Deactivating.")
+        self.CONV_WIDTH = self.freqai_info.get('conv_width', 1)
         if self.ft_params.get("inlier_metric_window", 0):
             self.CONV_WIDTH = self.ft_params.get("inlier_metric_window", 0) * 2
         self.pair_it = 0
         self.pair_it_train = 0
         self.total_pairs = len(self.config.get("exchange", {}).get("pair_whitelist"))
         self.train_queue = self._set_train_queue()
-        self.last_trade_database_summary: DataFrame = {}
-        self.current_trade_database_summary: DataFrame = {}
-        self.analysis_lock = Lock()
         self.inference_time: float = 0
         self.train_time: float = 0
         self.begin_time: float = 0
@@ -94,18 +92,20 @@ class IFreqaiModel(ABC):
         self.base_tf_seconds = timeframe_to_seconds(self.config['timeframe'])
         self.continual_learning = self.freqai_info.get('continual_learning', False)
         self.plot_features = self.ft_params.get("plot_feature_importances", 0)
-
+        self.corr_dataframes: Dict[str, DataFrame] = {}
+        # get_corr_dataframes is controlling the caching of corr_dataframes
+        # for improved performance. Careful with this boolean.
+        self.get_corr_dataframes: bool = True
         self._threads: List[threading.Thread] = []
         self._stop_event = threading.Event()
-        self.strategy: Optional[IStrategy] = None
-        self.max_system_threads = max(int(psutil.cpu_count() * 2 - 2), 1)
+
+        record_params(config, self.full_path)
 
     def __getstate__(self):
         """
         Return an empty state to be pickled in hyperopt
         """
         return ({})
-        self.strategy: Optional[IStrategy] = None
 
     def assert_config(self, config: Config) -> None:
 
@@ -126,7 +126,6 @@ class IFreqaiModel(ABC):
 
         self.live = strategy.dp.runmode in (RunMode.DRY_RUN, RunMode.LIVE)
         self.dd.set_pair_dict_info(metadata)
-        self.strategy = strategy
 
         if self.live:
             self.inference_timer('start')
@@ -140,7 +139,11 @@ class IFreqaiModel(ABC):
         # the concatenated results for the full backtesting period back to the strategy.
         elif not self.follow_mode:
             self.dk = FreqaiDataKitchen(self.config, self.live, metadata["pair"])
-            logger.info(f"Training {len(self.dk.training_timeranges)} timeranges")
+            if self.dk.backtest_live_models:
+                logger.info(
+                    f"Backtesting {len(self.dk.backtesting_timeranges)} timeranges (live models)")
+            else:
+                logger.info(f"Training {len(self.dk.training_timeranges)} timeranges")
             dataframe = self.dk.use_strategy_to_populate_indicators(
                 strategy, prediction_dataframe=dataframe, pair=metadata["pair"]
             )
@@ -149,7 +152,7 @@ class IFreqaiModel(ABC):
         dataframe = dk.remove_features_from_df(dk.return_dataframe)
         self.clean_up()
         if self.live:
-            self.inference_timer('stop')
+            self.inference_timer('stop', metadata["pair"])
         return dataframe
 
     def clean_up(self):
@@ -161,13 +164,6 @@ class IFreqaiModel(ABC):
         self.model = None
         self.dk = None
 
-    def _on_stop(self):
-        """
-        Callback for Subclasses to override to include logic for shutting down resources
-        when SIGINT is sent.
-        """
-        return
-
     def shutdown(self):
         """
         Cleans up threads on Shutdown, set stop event. Join threads to wait
@@ -176,8 +172,6 @@ class IFreqaiModel(ABC):
         logger.info("Stopping FreqAI")
         self._stop_event.set()
 
-        self._on_stop()
-
         logger.info("Waiting on Training iteration")
         for _thread in self._threads:
             _thread.join()
@@ -210,29 +204,31 @@ class IFreqaiModel(ABC):
             (_, trained_timestamp, _) = self.dd.get_pair_dict_info(pair)
 
             dk = FreqaiDataKitchen(self.config, self.live, pair)
-            dk.set_paths(pair, trained_timestamp)
             (
                 retrain,
                 new_trained_timerange,
                 data_load_timerange,
             ) = dk.check_if_new_training_required(trained_timestamp)
-            dk.set_paths(pair, new_trained_timerange.stopts)
 
             if retrain:
                 self.train_timer('start')
+                dk.set_paths(pair, new_trained_timerange.stopts)
                 try:
                     self.extract_data_and_train_model(
                         new_trained_timerange, pair, strategy, dk, data_load_timerange
                     )
                 except Exception as msg:
-                    logger.warning(f'Training {pair} raised exception {msg}, skipping.')
+                    logger.warning(f"Training {pair} raised exception {msg.__class__.__name__}. "
+                                   f"Message: {msg}, skipping.")
 
-                self.train_timer('stop')
+                self.train_timer('stop', pair)
 
                 # only rotate the queue after the first has been trained.
                 self.train_queue.rotate(-1)
 
                 self.dd.save_historic_predictions_to_disk()
+                if self.freqai_info.get('write_metrics_to_disk', False):
+                    self.dd.save_metric_tracker_to_disk()
 
     def start_backtesting(
         self, dataframe: DataFrame, metadata: dict, dk: FreqaiDataKitchen
@@ -267,27 +263,20 @@ class IFreqaiModel(ABC):
             dataframe_train = dk.slice_dataframe(tr_train, dataframe)
             dataframe_backtest = dk.slice_dataframe(tr_backtest, dataframe)
 
-            trained_timestamp = tr_train
-            tr_train_startts_str = datetime.fromtimestamp(
-                                                tr_train.startts,
-                                                tz=timezone.utc).strftime(DATETIME_PRINT_FORMAT)
-            tr_train_stopts_str = datetime.fromtimestamp(
-                                                tr_train.stopts,
-                                                tz=timezone.utc).strftime(DATETIME_PRINT_FORMAT)
-            logger.info(
-                f"Training {pair}, {self.pair_it}/{self.total_pairs} pairs"
-                f" from {tr_train_startts_str} to {tr_train_stopts_str}, {train_it}/{total_trains} "
-                "trains"
-            )
+            if not self.ensure_data_exists(dataframe_backtest, tr_backtest, pair):
+                continue
 
-            trained_timestamp_int = int(trained_timestamp.stopts)
-            dk.data_path = Path(
-                dk.full_path / f"sub-train-{pair.split('/')[0]}_{trained_timestamp_int}"
-                )
+            self.log_backtesting_progress(tr_train, pair, train_it, total_trains)
 
-            dk.set_new_model_names(pair, trained_timestamp)
+            timestamp_model_id = int(tr_train.stopts)
+            if dk.backtest_live_models:
+                timestamp_model_id = int(tr_backtest.startts)
 
-            if dk.check_if_backtest_prediction_exists():
+            dk.set_paths(pair, timestamp_model_id)
+
+            dk.set_new_model_names(pair, timestamp_model_id)
+
+            if dk.check_if_backtest_prediction_is_valid(len(dataframe_backtest)):
                 self.dd.load_metadata(dk)
                 dk.find_features(dataframe_train)
                 self.check_if_feature_list_matches_strategy(dk)
@@ -299,7 +288,7 @@ class IFreqaiModel(ABC):
                     dk.find_labels(dataframe_train)
                     self.model = self.train(dataframe_train, pair, dk)
                     self.dd.pair_dict[pair]["trained_timestamp"] = int(
-                        trained_timestamp.stopts)
+                        tr_train.stopts)
                     if self.plot_features:
                         plot_feature_importance(self.model, pair, dk, self.plot_features)
                     if self.save_backtest_models:
@@ -351,6 +340,7 @@ class IFreqaiModel(ABC):
         if self.dd.historic_data:
             self.dd.update_historic_data(strategy, dk)
             logger.debug(f'Updating historic data on pair {metadata["pair"]}')
+            self.track_current_candle()
 
         if not self.follow_mode:
 
@@ -377,10 +367,10 @@ class IFreqaiModel(ABC):
         # load the model and associated data into the data kitchen
         self.model = self.dd.load_data(metadata["pair"], dk)
 
-        with self.analysis_lock:
-            dataframe = self.dk.use_strategy_to_populate_indicators(
-                strategy, prediction_dataframe=dataframe, pair=metadata["pair"]
-            )
+        dataframe = dk.use_strategy_to_populate_indicators(
+            strategy, prediction_dataframe=dataframe, pair=metadata["pair"],
+            do_corr_pairs=self.get_corr_dataframes
+        )
 
         if not self.model:
             logger.warning(
@@ -389,6 +379,9 @@ class IFreqaiModel(ABC):
             self.dd.return_null_values_to_strategy(dataframe, dk)
             return dk
 
+        if self.corr_pairlist:
+            dataframe = self.cache_corr_pairlist_dfs(dataframe, dk)
+
         dk.find_labels(dataframe)
 
         self.build_strategy_return_arrays(dataframe, dk, metadata["pair"], trained_timestamp)
@@ -540,14 +533,13 @@ class IFreqaiModel(ABC):
         return file_exists
 
     def set_full_path(self) -> None:
+        """
+        Creates and sets the full path for the identifier
+        """
         self.full_path = Path(
-            self.config["user_data_dir"] / "models" / f"{self.freqai_info['identifier']}"
+            self.config["user_data_dir"] / "models" / f"{self.identifier}"
         )
         self.full_path.mkdir(parents=True, exist_ok=True)
-        shutil.copy(
-            self.config["config_files"][0],
-            Path(self.full_path, Path(self.config["config_files"][0]).name),
-        )
 
     def extract_data_and_train_model(
         self,
@@ -573,10 +565,9 @@ class IFreqaiModel(ABC):
             data_load_timerange, pair, dk
         )
 
-        with self.analysis_lock:
-            unfiltered_dataframe = dk.use_strategy_to_populate_indicators(
-                strategy, corr_dataframes, base_dataframes, pair
-            )
+        unfiltered_dataframe = dk.use_strategy_to_populate_indicators(
+            strategy, corr_dataframes, base_dataframes, pair
+        )
 
         unfiltered_dataframe = dk.slice_dataframe(new_trained_timerange, unfiltered_dataframe)
 
@@ -587,7 +578,7 @@ class IFreqaiModel(ABC):
         model = self.train(unfiltered_dataframe, pair, dk)
 
         self.dd.pair_dict[pair]["trained_timestamp"] = new_trained_timerange.stopts
-        dk.set_new_model_names(pair, new_trained_timerange)
+        dk.set_new_model_names(pair, new_trained_timerange.stopts)
         self.dd.save_data(model, pair, dk)
 
         if self.plot_features:
@@ -616,11 +607,11 @@ class IFreqaiModel(ABC):
         If the user reuses an identifier on a subsequent instance,
         this function will not be called. In that case, "real" predictions
         will be appended to the loaded set of historic predictions.
-        :param: df: DataFrame = the dataframe containing the training feature data
-        :param: model: Any = A model which was `fit` using a common library such as
-        catboost or lightgbm
-        :param: dk: FreqaiDataKitchen = object containing methods for data analysis
-        :param: pair: str = current pair
+        :param df: DataFrame = the dataframe containing the training feature data
+        :param model: Any = A model which was `fit` using a common library such as
+                      catboost or lightgbm
+        :param dk: FreqaiDataKitchen = object containing methods for data analysis
+        :param pair: str = current pair
         """
 
         self.dd.historic_predictions[pair] = pred_df
@@ -638,15 +629,14 @@ class IFreqaiModel(ABC):
             hist_preds_df['DI_values'] = 0
 
         for return_str in dk.data['extra_returns_per_train']:
-            hist_preds_df[return_str] = 0
+            hist_preds_df[return_str] = dk.data['extra_returns_per_train'][return_str]
 
         hist_preds_df['close_price'] = strat_df['close']
         hist_preds_df['date_pred'] = strat_df['date']
 
         # # for keras type models, the conv_window needs to be prepended so
         # # viewing is correct in frequi
-        if (not self.freqai_info.get('model_save_type', 'joblib') or
-                self.ft_params.get('inlier_metric_window', 0)):
+        if self.freqai_info.get('keras', False) or self.ft_params.get('inlier_metric_window', 0):
             n_lost_points = self.freqai_info.get('conv_width', 2)
             zeros_df = DataFrame(np.zeros((n_lost_points, len(hist_preds_df.columns))),
                                  columns=hist_preds_df.columns)
@@ -672,7 +662,7 @@ class IFreqaiModel(ABC):
 
         return
 
-    def inference_timer(self, do='start'):
+    def inference_timer(self, do: Literal['start', 'stop'] = 'start', pair: str = ''):
         """
         Timer designed to track the cumulative time spent in FreqAI for one pass through
         the whitelist. This will check if the time spent is more than 1/4 the time
@@ -683,7 +673,10 @@ class IFreqaiModel(ABC):
             self.begin_time = time.time()
         elif do == 'stop':
             end = time.time()
-            self.inference_time += (end - self.begin_time)
+            time_spent = (end - self.begin_time)
+            if self.freqai_info.get('write_metrics_to_disk', False):
+                self.dd.update_metric_tracker('inference_time', time_spent, pair)
+            self.inference_time += time_spent
             if self.pair_it == self.total_pairs:
                 logger.info(
                     f'Total time spent inferencing pairlist {self.inference_time:.2f} seconds')
@@ -694,7 +687,7 @@ class IFreqaiModel(ABC):
                 self.inference_time = 0
         return
 
-    def train_timer(self, do='start'):
+    def train_timer(self, do: Literal['start', 'stop'] = 'start', pair: str = ''):
         """
         Timer designed to track the cumulative time spent training the full pairlist in
         FreqAI.
@@ -704,7 +697,11 @@ class IFreqaiModel(ABC):
             self.begin_time_train = time.time()
         elif do == 'stop':
             end = time.time()
-            self.train_time += (end - self.begin_time_train)
+            time_spent = (end - self.begin_time_train)
+            if self.freqai_info.get('write_metrics_to_disk', False):
+                self.dd.collect_metrics(time_spent, pair)
+
+            self.train_time += time_spent
             if self.pair_it_train == self.total_pairs:
                 logger.info(
                     f'Total time spent training pairlist {self.train_time:.2f} seconds')
@@ -746,6 +743,74 @@ class IFreqaiModel(ABC):
                     f'Best approximation queue: {best_queue}')
         return best_queue
 
+    def cache_corr_pairlist_dfs(self, dataframe: DataFrame, dk: FreqaiDataKitchen) -> DataFrame:
+        """
+        Cache the corr_pairlist dfs to speed up performance for subsequent pairs during the
+        current candle.
+        :param dataframe: strategy fed dataframe
+        :param dk: datakitchen object for current asset
+        :return: dataframe to attach/extract cached corr_pair dfs to/from.
+        """
+
+        if self.get_corr_dataframes:
+            self.corr_dataframes = dk.extract_corr_pair_columns_from_populated_indicators(dataframe)
+            if not self.corr_dataframes:
+                logger.warning("Couldn't cache corr_pair dataframes for improved performance. "
+                               "Consider ensuring that the full coin/stake, e.g. XYZ/USD, "
+                               "is included in the column names when you are creating features "
+                               "in `populate_any_indicators()`.")
+            self.get_corr_dataframes = not bool(self.corr_dataframes)
+        elif self.corr_dataframes:
+            dataframe = dk.attach_corr_pair_columns(
+                dataframe, self.corr_dataframes, dk.pair)
+
+        return dataframe
+
+    def track_current_candle(self):
+        """
+        Checks if the latest candle appended by the datadrawer is
+        equivalent to the latest candle seen by FreqAI. If not, it
+        asks to refresh the cached corr_dfs, and resets the pair
+        counter.
+        """
+        if self.dd.current_candle > self.current_candle:
+            self.get_corr_dataframes = True
+            self.pair_it = 1
+            self.current_candle = self.dd.current_candle
+
+    def ensure_data_exists(self, dataframe_backtest: DataFrame,
+                           tr_backtest: TimeRange, pair: str) -> bool:
+        """
+        Check if the dataframe is empty, if not, report useful information to user.
+        :param dataframe_backtest: the backtesting dataframe, maybe empty.
+        :param tr_backtest: current backtesting timerange.
+        :param pair: current pair
+        :return: if the data exists or not
+        """
+        if self.config.get("freqai_backtest_live_models", False) and len(dataframe_backtest) == 0:
+            logger.info(f"No data found for pair {pair} from "
+                        f"from { tr_backtest.start_fmt} to {tr_backtest.stop_fmt}. "
+                        "Probably more than one training within the same candle period.")
+            return False
+        return True
+
+    def log_backtesting_progress(self, tr_train: TimeRange, pair: str,
+                                 train_it: int, total_trains: int):
+        """
+        Log the backtesting progress so user knows how many pairs have been trained and
+        how many more pairs/trains remain.
+        :param tr_train: the training timerange
+        :param train_it: the train iteration for the current pair (the sliding window progress)
+        :param pair: the current pair
+        :param total_trains: total trains (total number of slides for the sliding window)
+        """
+        if not self.config.get("freqai_backtest_live_models", False):
+            logger.info(
+                f"Training {pair}, {self.pair_it}/{self.total_pairs} pairs"
+                f" from {tr_train.start_fmt} "
+                f"to {tr_train.stop_fmt}, {train_it}/{total_trains} "
+                "trains"
+            )
     # Following methods which are overridden by user made prediction models.
     # See freqai/prediction_models/CatboostPredictionModel.py for an example.
 

freqtrade/freqai/prediction_models/CNNPredictionModel.py

@@ -1,144 +0,0 @@
-import logging
-from typing import Any, Dict, Tuple
-
-from pandas import DataFrame
-from freqtrade.exceptions import OperationalException
-from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-import tensorflow as tf
-from freqtrade.freqai.base_models.BaseTensorFlowModel import BaseTensorFlowModel, WindowGenerator
-from tensorflow.keras.layers import Input, Conv1D, Dense
-from tensorflow.keras.models import Model
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-# tf.config.run_functions_eagerly(True)
-# tf.data.experimental.enable_debug_mode()
-
-MAX_EPOCHS = 10
-
-
-class CNNPredictionModel(BaseTensorFlowModel):
-    """
-    User created prediction model. The class needs to override three necessary
-    functions, predict(), fit().
-    """
-
-    def fit(self, data_dictionary: Dict[str, Any], dk: FreqaiDataKitchen) -> Any:
-        """
-        User sets up the training and test data to fit their desired model here
-        :params:
-        :data_dictionary: the dictionary constructed by DataHandler to hold
-        all the training and test data/labels.
-        """
-        train_df = data_dictionary["train_features"]
-        train_labels = data_dictionary["train_labels"]
-        test_df = data_dictionary["test_features"]
-        test_labels = data_dictionary["test_labels"]
-        n_labels = len(train_labels.columns)
-        if n_labels > 1:
-            raise OperationalException(
-                "Neural Net not yet configured for multi-targets. Please "
-                " reduce number of targets to 1 in strategy."
-            )
-
-        n_features = len(data_dictionary["train_features"].columns)
-        BATCH_SIZE = self.freqai_info.get("batch_size", 64)
-        input_dims = [BATCH_SIZE, self.CONV_WIDTH, n_features]
-
-        w1 = WindowGenerator(
-            input_width=self.CONV_WIDTH,
-            label_width=1,
-            shift=1,
-            train_df=train_df,
-            val_df=test_df,
-            train_labels=train_labels,
-            val_labels=test_labels,
-            batch_size=BATCH_SIZE,
-        )
-
-        model = self.create_model(input_dims, n_labels)
-
-        steps_per_epoch = np.ceil(len(test_df) / BATCH_SIZE)
-        lr_schedule = tf.keras.optimizers.schedules.InverseTimeDecay(
-            0.001, decay_steps=steps_per_epoch * 1000, decay_rate=1, staircase=False
-        )
-
-        early_stopping = tf.keras.callbacks.EarlyStopping(
-            monitor="loss", patience=3, mode="min", min_delta=0.0001
-        )
-
-        model.compile(
-            loss=tf.losses.MeanSquaredError(),
-            optimizer=tf.optimizers.Adam(lr_schedule),
-            metrics=[tf.metrics.MeanAbsoluteError()],
-        )
-
-        model.fit(
-            w1.train,
-            epochs=MAX_EPOCHS,
-            shuffle=False,
-            validation_data=w1.val,
-            callbacks=[early_stopping],
-            verbose=1,
-        )
-
-        return model
-
-    def predict(
-        self, unfiltered_dataframe: DataFrame, dk: FreqaiDataKitchen, first=True
-    ) -> Tuple[DataFrame, DataFrame]:
-        """
-        Filter the prediction features data and predict with it.
-        :param: unfiltered_dataframe: Full dataframe for the current backtest period.
-        :return:
-        :predictions: np.array of predictions
-        :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove
-        data (NaNs) or felt uncertain about data (PCA and DI index)
-        """
-
-        dk.find_features(unfiltered_dataframe)
-        filtered_dataframe, _ = dk.filter_features(
-            unfiltered_dataframe, dk.training_features_list, training_filter=False
-        )
-        filtered_dataframe = dk.normalize_data_from_metadata(filtered_dataframe)
-        dk.data_dictionary["prediction_features"] = filtered_dataframe
-
-        # optional additional data cleaning/analysis
-        self.data_cleaning_predict(dk, filtered_dataframe)
-
-        if first:
-            full_df = dk.data_dictionary["prediction_features"]
-
-            w1 = WindowGenerator(
-                input_width=self.CONV_WIDTH,
-                label_width=1,
-                shift=1,
-                test_df=full_df,
-                batch_size=len(full_df),
-            )
-
-            predictions = self.model.predict(w1.inference)
-            len_diff = len(dk.do_predict) - len(predictions)
-            if len_diff > 0:
-                dk.do_predict = dk.do_predict[len_diff:]
-
-        else:
-            data = dk.data_dictionary["prediction_features"]
-            data = tf.expand_dims(data, axis=0)
-            predictions = self.model(data, training=False)
-
-        predictions = predictions[:, 0, 0]
-        pred_df = DataFrame(predictions, columns=dk.label_list)
-
-        pred_df = dk.denormalize_labels_from_metadata(pred_df)
-
-        return (pred_df, np.ones(len(pred_df)))
-
-    def create_model(self, input_dims, n_labels) -> Any:
-
-        input_layer = Input(shape=(input_dims[1], input_dims[2]))
-        Layer_1 = Conv1D(filters=32, kernel_size=(self.CONV_WIDTH,), activation="relu")(input_layer)
-        Layer_3 = Dense(units=32, activation="relu")(Layer_1)
-        output_layer = Dense(units=n_labels)(Layer_3)
-        return Model(inputs=input_layer, outputs=output_layer)

freqtrade/freqai/prediction_models/CatboostClassifier.py

@@ -1,4 +1,6 @@
 import logging
+import sys
+from pathlib import Path
 from typing import Any, Dict
 
 from catboost import CatBoostClassifier, Pool
@@ -20,9 +22,8 @@ class CatboostClassifier(BaseClassifierModel):
     def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
         """
         User sets up the training and test data to fit their desired model here
-        :params:
-        :data_dictionary: the dictionary constructed by DataHandler to hold
-        all the training and test data/labels.
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
         """
 
         train_data = Pool(
@@ -30,15 +31,25 @@ class CatboostClassifier(BaseClassifierModel):
             label=data_dictionary["train_labels"],
             weight=data_dictionary["train_weights"],
         )
+        if self.freqai_info.get("data_split_parameters", {}).get("test_size", 0.1) == 0:
+            test_data = None
+        else:
+            test_data = Pool(
+                data=data_dictionary["test_features"],
+                label=data_dictionary["test_labels"],
+                weight=data_dictionary["test_weights"],
+            )
 
         cbr = CatBoostClassifier(
-            allow_writing_files=False,
+            allow_writing_files=True,
             loss_function='MultiClass',
+            train_dir=Path(dk.data_path),
             **self.model_training_parameters,
         )
 
         init_model = self.get_init_model(dk.pair)
 
-        cbr.fit(train_data, init_model=init_model)
+        cbr.fit(X=train_data, eval_set=test_data, init_model=init_model,
+                log_cout=sys.stdout, log_cerr=sys.stderr)
 
         return cbr

freqtrade/freqai/prediction_models/CatboostClassifierMultiTarget.py

@@ -0,0 +1,74 @@
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+from catboost import CatBoostClassifier, Pool
+
+from freqtrade.freqai.base_models.BaseClassifierModel import BaseClassifierModel
+from freqtrade.freqai.base_models.FreqaiMultiOutputClassifier import FreqaiMultiOutputClassifier
+from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+
+
+logger = logging.getLogger(__name__)
+
+
+class CatboostClassifierMultiTarget(BaseClassifierModel):
+    """
+    User created prediction model. The class needs to override three necessary
+    functions, predict(), train(), fit(). The class inherits ModelHandler which
+    has its own DataHandler where data is held, saved, loaded, and managed.
+    """
+
+    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
+        """
+        User sets up the training and test data to fit their desired model here
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
+        """
+
+        cbc = CatBoostClassifier(
+            allow_writing_files=True,
+            loss_function='MultiClass',
+            train_dir=Path(dk.data_path),
+            **self.model_training_parameters,
+        )
+
+        X = data_dictionary["train_features"]
+        y = data_dictionary["train_labels"]
+
+        sample_weight = data_dictionary["train_weights"]
+
+        eval_sets = [None] * y.shape[1]
+
+        if self.freqai_info.get('data_split_parameters', {}).get('test_size', 0.1) != 0:
+            eval_sets = [None] * data_dictionary['test_labels'].shape[1]
+
+            for i in range(data_dictionary['test_labels'].shape[1]):
+                eval_sets[i] = Pool(
+                    data=data_dictionary["test_features"],
+                    label=data_dictionary["test_labels"].iloc[:, i],
+                    weight=data_dictionary["test_weights"],
+                )
+
+        init_model = self.get_init_model(dk.pair)
+
+        if init_model:
+            init_models = init_model.estimators_
+        else:
+            init_models = [None] * y.shape[1]
+
+        fit_params = []
+        for i in range(len(eval_sets)):
+            fit_params.append({
+                'eval_set': eval_sets[i], 'init_model': init_models[i],
+                'log_cout': sys.stdout, 'log_cerr': sys.stderr,
+            })
+
+        model = FreqaiMultiOutputClassifier(estimator=cbc)
+        thread_training = self.freqai_info.get('multitarget_parallel_training', False)
+        if thread_training:
+            model.n_jobs = y.shape[1]
+        model.fit(X=X, y=y, sample_weight=sample_weight, fit_params=fit_params)
+
+        return model

freqtrade/freqai/prediction_models/CatboostRegressor.py

@@ -1,4 +1,6 @@
 import logging
+import sys
+from pathlib import Path
 from typing import Any, Dict
 
 from catboost import CatBoostRegressor, Pool
@@ -41,10 +43,12 @@ class CatboostRegressor(BaseRegressionModel):
         init_model = self.get_init_model(dk.pair)
 
         model = CatBoostRegressor(
-            allow_writing_files=False,
+            allow_writing_files=True,
+            train_dir=Path(dk.data_path),
             **self.model_training_parameters,
         )
 
-        model.fit(X=train_data, eval_set=test_data, init_model=init_model)
+        model.fit(X=train_data, eval_set=test_data, init_model=init_model,
+                  log_cout=sys.stdout, log_cerr=sys.stderr)
 
         return model

freqtrade/freqai/prediction_models/CatboostRegressorMultiTarget.py

@@ -1,4 +1,6 @@
 import logging
+import sys
+from pathlib import Path
 from typing import Any, Dict
 
 from catboost import CatBoostRegressor, Pool
@@ -26,7 +28,8 @@ class CatboostRegressorMultiTarget(BaseRegressionModel):
         """
 
         cbr = CatBoostRegressor(
-            allow_writing_files=False,
+            allow_writing_files=True,
+            train_dir=Path(dk.data_path),
             **self.model_training_parameters,
         )
 
@@ -56,8 +59,10 @@ class CatboostRegressorMultiTarget(BaseRegressionModel):
 
         fit_params = []
         for i in range(len(eval_sets)):
-            fit_params.append(
-                {'eval_set': eval_sets[i],  'init_model': init_models[i]})
+            fit_params.append({
+                    'eval_set': eval_sets[i],  'init_model': init_models[i],
+                    'log_cout': sys.stdout, 'log_cerr': sys.stderr,
+                 })
 
         model = FreqaiMultiOutputRegressor(estimator=cbr)
         thread_training = self.freqai_info.get('multitarget_parallel_training', False)

freqtrade/freqai/prediction_models/LightGBMClassifier.py

@@ -20,9 +20,8 @@ class LightGBMClassifier(BaseClassifierModel):
     def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
         """
         User sets up the training and test data to fit their desired model here
-        :params:
-        :data_dictionary: the dictionary constructed by DataHandler to hold
-        all the training and test data/labels.
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
         """
 
         if self.freqai_info.get('data_split_parameters', {}).get('test_size', 0.1) == 0:

freqtrade/freqai/prediction_models/LightGBMClassifierMultiTarget.py

@@ -0,0 +1,64 @@
+import logging
+from typing import Any, Dict
+
+from lightgbm import LGBMClassifier
+
+from freqtrade.freqai.base_models.BaseClassifierModel import BaseClassifierModel
+from freqtrade.freqai.base_models.FreqaiMultiOutputClassifier import FreqaiMultiOutputClassifier
+from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+
+
+logger = logging.getLogger(__name__)
+
+
+class LightGBMClassifierMultiTarget(BaseClassifierModel):
+    """
+    User created prediction model. The class needs to override three necessary
+    functions, predict(), train(), fit(). The class inherits ModelHandler which
+    has its own DataHandler where data is held, saved, loaded, and managed.
+    """
+
+    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
+        """
+        User sets up the training and test data to fit their desired model here
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
+        """
+
+        lgb = LGBMClassifier(**self.model_training_parameters)
+
+        X = data_dictionary["train_features"]
+        y = data_dictionary["train_labels"]
+        sample_weight = data_dictionary["train_weights"]
+
+        eval_weights = None
+        eval_sets = [None] * y.shape[1]
+
+        if self.freqai_info.get('data_split_parameters', {}).get('test_size', 0.1) != 0:
+            eval_weights = [data_dictionary["test_weights"]]
+            eval_sets = [(None, None)] * data_dictionary['test_labels'].shape[1]  # type: ignore
+            for i in range(data_dictionary['test_labels'].shape[1]):
+                eval_sets[i] = (  # type: ignore
+                    data_dictionary["test_features"],
+                    data_dictionary["test_labels"].iloc[:, i]
+                )
+
+        init_model = self.get_init_model(dk.pair)
+        if init_model:
+            init_models = init_model.estimators_
+        else:
+            init_models = [None] * y.shape[1]
+
+        fit_params = []
+        for i in range(len(eval_sets)):
+            fit_params.append(
+                {'eval_set': eval_sets[i], 'eval_sample_weight': eval_weights,
+                 'init_model': init_models[i]})
+
+        model = FreqaiMultiOutputClassifier(estimator=lgb)
+        thread_training = self.freqai_info.get('multitarget_parallel_training', False)
+        if thread_training:
+            model.n_jobs = y.shape[1]
+        model.fit(X=X, y=y, sample_weight=sample_weight, fit_params=fit_params)
+
+        return model

freqtrade/freqai/prediction_models/ReinforcementLearner.py

@@ -1,118 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Any, Dict
-
-import torch as th
-
-from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
-from freqtrade.freqai.RL.BaseReinforcementLearningModel import BaseReinforcementLearningModel
-
-
-logger = logging.getLogger(__name__)
-
-
-class ReinforcementLearner(BaseReinforcementLearningModel):
-    """
-    User created Reinforcement Learning Model prediction model.
-    """
-
-    def fit(self, data_dictionary: Dict[str, Any], dk: FreqaiDataKitchen, **kwargs):
-        """
-        User customizable fit method
-        :params:
-        data_dictionary: dict = common data dictionary containing all train/test
-            features/labels/weights.
-        dk: FreqaiDatakitchen = data kitchen for current pair.
-        :returns:
-        model: Any = trained model to be used for inference in dry/live/backtesting
-        """
-        train_df = data_dictionary["train_features"]
-        total_timesteps = self.freqai_info["rl_config"]["train_cycles"] * len(train_df)
-
-        policy_kwargs = dict(activation_fn=th.nn.ReLU,
-                             net_arch=[128, 128])
-
-        if dk.pair not in self.dd.model_dictionary or not self.continual_learning:
-            model = self.MODELCLASS(self.policy_type, self.train_env, policy_kwargs=policy_kwargs,
-                                    tensorboard_log=Path(
-                                        dk.full_path / "tensorboard" / dk.pair.split('/')[0]),
-                                    **self.freqai_info['model_training_parameters']
-                                    )
-        else:
-            logger.info('Continual training activated - starting training from previously '
-                        'trained agent.')
-            model = self.dd.model_dictionary[dk.pair]
-            model.set_env(self.train_env)
-
-        model.learn(
-            total_timesteps=int(total_timesteps),
-            callback=self.eval_callback
-        )
-
-        if Path(dk.data_path / "best_model.zip").is_file():
-            logger.info('Callback found a best model.')
-            best_model = self.MODELCLASS.load(dk.data_path / "best_model")
-            return best_model
-
-        logger.info('Couldnt find best model, using final model instead.')
-
-        return model
-
-    class MyRLEnv(Base5ActionRLEnv):
-        """
-        User can override any function in BaseRLEnv and gym.Env. Here the user
-        sets a custom reward based on profit and trade duration.
-        """
-
-        def calculate_reward(self, action):
-            """
-            An example reward function. This is the one function that users will likely
-            wish to inject their own creativity into.
-            :params:
-            action: int = The action made by the agent for the current candle.
-            :returns:
-            float = the reward to give to the agent for current step (used for optimization
-                of weights in NN)
-            """
-            # first, penalize if the action is not valid
-            if not self._is_valid(action):
-                return -2
-
-            pnl = self.get_unrealized_profit()
-            factor = 100
-
-            # reward agent for entering trades
-            if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
-                    and self._position == Positions.Neutral):
-                return 25
-            # discourage agent from not entering trades
-            if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                return -1
-
-            max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-            trade_duration = self._current_tick - self._last_trade_tick
-
-            if trade_duration <= max_trade_duration:
-                factor *= 1.5
-            elif trade_duration > max_trade_duration:
-                factor *= 0.5
-
-            # discourage sitting in position
-            if (self._position in (Positions.Short, Positions.Long) and
-                    action == Actions.Neutral.value):
-                return -1 * trade_duration / max_trade_duration
-
-            # close long
-            if action == Actions.Long_exit.value and self._position == Positions.Long:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(pnl * factor)
-
-            # close short
-            if action == Actions.Short_exit.value and self._position == Positions.Short:
-                if pnl > self.profit_aim * self.rr:
-                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                return float(pnl * factor)
-
-            return 0.

freqtrade/freqai/prediction_models/ReinforcementLearner_multiproc.py

@@ -1,100 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Any, Dict  # , Tuple
-
-# import numpy.typing as npt
-import torch as th
-from pandas import DataFrame
-from stable_baselines3.common.callbacks import EvalCallback
-from stable_baselines3.common.vec_env import SubprocVecEnv
-
-from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-from freqtrade.freqai.RL.BaseReinforcementLearningModel import (BaseReinforcementLearningModel,
-                                                                make_env)
-
-
-logger = logging.getLogger(__name__)
-
-
-class ReinforcementLearner_multiproc(BaseReinforcementLearningModel):
-    """
-    User created Reinforcement Learning Model prediction model.
-    """
-
-    def fit(self, data_dictionary: Dict[str, Any], dk: FreqaiDataKitchen, **kwargs):
-
-        train_df = data_dictionary["train_features"]
-        total_timesteps = self.freqai_info["rl_config"]["train_cycles"] * len(train_df)
-
-        # model arch
-        policy_kwargs = dict(activation_fn=th.nn.ReLU,
-                             net_arch=[128, 128])
-
-        if dk.pair not in self.dd.model_dictionary or not self.continual_learning:
-            model = self.MODELCLASS(self.policy_type, self.train_env, policy_kwargs=policy_kwargs,
-                                    tensorboard_log=Path(
-                                        dk.full_path / "tensorboard" / dk.pair.split('/')[0]),
-                                    **self.freqai_info['model_training_parameters']
-                                    )
-        else:
-            logger.info('Continual learning activated - starting training from previously '
-                        'trained agent.')
-            model = self.dd.model_dictionary[dk.pair]
-            model.set_env(self.train_env)
-
-        model.learn(
-            total_timesteps=int(total_timesteps),
-            callback=self.eval_callback
-        )
-
-        if Path(dk.data_path / "best_model.zip").is_file():
-            logger.info('Callback found a best model.')
-            best_model = self.MODELCLASS.load(dk.data_path / "best_model")
-            return best_model
-
-        logger.info('Couldnt find best model, using final model instead.')
-
-        return model
-
-    def set_train_and_eval_environments(self, data_dictionary: Dict[str, Any],
-                                        prices_train: DataFrame, prices_test: DataFrame,
-                                        dk: FreqaiDataKitchen):
-        """
-        User can override this if they are using a custom MyRLEnv
-        :params:
-        data_dictionary: dict = common data dictionary containing train and test
-            features/labels/weights.
-        prices_train/test: DataFrame = dataframe comprised of the prices to be used in
-            the environment during training
-        or testing
-        dk: FreqaiDataKitchen = the datakitchen for the current pair
-        """
-        train_df = data_dictionary["train_features"]
-        test_df = data_dictionary["test_features"]
-
-        env_id = "train_env"
-        self.train_env = SubprocVecEnv([make_env(self.MyRLEnv, env_id, i, 1, train_df, prices_train,
-                                        self.reward_params, self.CONV_WIDTH, monitor=True,
-                                        config=self.config) for i
-                                        in range(self.max_threads)])
-
-        eval_env_id = 'eval_env'
-        self.eval_env = SubprocVecEnv([make_env(self.MyRLEnv, eval_env_id, i, 1,
-                                                test_df, prices_test,
-                                                self.reward_params, self.CONV_WIDTH, monitor=True,
-                                                config=self.config) for i
-                                       in range(self.max_threads)])
-        self.eval_callback = EvalCallback(self.eval_env, deterministic=True,
-                                          render=False, eval_freq=len(train_df),
-                                          best_model_save_path=str(dk.data_path))
-
-    def _on_stop(self):
-        """
-        Hook called on bot shutdown. Close SubprocVecEnv subprocesses for clean shutdown.
-        """
-
-        if self.train_env:
-            self.train_env.close()
-
-        if self.eval_env:
-            self.eval_env.close()

freqtrade/freqai/prediction_models/XGBoostClassifier.py

@@ -26,9 +26,8 @@ class XGBoostClassifier(BaseClassifierModel):
     def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
         """
         User sets up the training and test data to fit their desired model here
-        :params:
-        :data_dictionary: the dictionary constructed by DataHandler to hold
-        all the training and test data/labels.
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
         """
 
         X = data_dictionary["train_features"].to_numpy()
@@ -65,7 +64,7 @@ class XGBoostClassifier(BaseClassifierModel):
     ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
         """
         Filter the prediction features data and predict with it.
-        :param: unfiltered_df: Full dataframe for the current backtest period.
+        :param unfiltered_df: Full dataframe for the current backtest period.
         :return:
         :pred_df: dataframe containing the predictions
         :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove

freqtrade/freqai/prediction_models/XGBoostRFClassifier.py

@@ -0,0 +1,84 @@
+import logging
+from typing import Any, Dict, Tuple
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+from pandas import DataFrame
+from pandas.api.types import is_integer_dtype
+from sklearn.preprocessing import LabelEncoder
+from xgboost import XGBRFClassifier
+
+from freqtrade.freqai.base_models.BaseClassifierModel import BaseClassifierModel
+from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+
+
+logger = logging.getLogger(__name__)
+
+
+class XGBoostRFClassifier(BaseClassifierModel):
+    """
+    User created prediction model. The class needs to override three necessary
+    functions, predict(), train(), fit(). The class inherits ModelHandler which
+    has its own DataHandler where data is held, saved, loaded, and managed.
+    """
+
+    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
+        """
+        User sets up the training and test data to fit their desired model here
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+            all the training and test data/labels.
+        """
+
+        X = data_dictionary["train_features"].to_numpy()
+        y = data_dictionary["train_labels"].to_numpy()[:, 0]
+
+        le = LabelEncoder()
+        if not is_integer_dtype(y):
+            y = pd.Series(le.fit_transform(y), dtype="int64")
+
+        if self.freqai_info.get('data_split_parameters', {}).get('test_size', 0.1) == 0:
+            eval_set = None
+        else:
+            test_features = data_dictionary["test_features"].to_numpy()
+            test_labels = data_dictionary["test_labels"].to_numpy()[:, 0]
+
+            if not is_integer_dtype(test_labels):
+                test_labels = pd.Series(le.transform(test_labels), dtype="int64")
+
+            eval_set = [(test_features, test_labels)]
+
+        train_weights = data_dictionary["train_weights"]
+
+        init_model = self.get_init_model(dk.pair)
+
+        model = XGBRFClassifier(**self.model_training_parameters)
+
+        model.fit(X=X, y=y, eval_set=eval_set, sample_weight=train_weights,
+                  xgb_model=init_model)
+
+        return model
+
+    def predict(
+        self, unfiltered_df: DataFrame, dk: FreqaiDataKitchen, **kwargs
+    ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
+        """
+        Filter the prediction features data and predict with it.
+        :param  unfiltered_df: Full dataframe for the current backtest period.
+        :return:
+        :pred_df: dataframe containing the predictions
+        :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove
+        data (NaNs) or felt uncertain about data (PCA and DI index)
+        """
+
+        (pred_df, dk.do_predict) = super().predict(unfiltered_df, dk, **kwargs)
+
+        le = LabelEncoder()
+        label = dk.label_list[0]
+        labels_before = list(dk.data['labels_std'].keys())
+        labels_after = le.fit_transform(labels_before).tolist()
+        pred_df[label] = le.inverse_transform(pred_df[label])
+        pred_df = pred_df.rename(
+            columns={labels_after[i]: labels_before[i] for i in range(len(labels_before))})
+
+        return (pred_df, dk.do_predict)

freqtrade/freqai/prediction_models/XGBoostRFRegressor.py

@@ -0,0 +1,46 @@
+import logging
+from typing import Any, Dict
+
+from xgboost import XGBRFRegressor
+
+from freqtrade.freqai.base_models.BaseRegressionModel import BaseRegressionModel
+from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+
+
+logger = logging.getLogger(__name__)
+
+
+class XGBoostRFRegressor(BaseRegressionModel):
+    """
+    User created prediction model. The class needs to override three necessary
+    functions, predict(), train(), fit(). The class inherits ModelHandler which
+    has its own DataHandler where data is held, saved, loaded, and managed.
+    """
+
+    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
+        """
+        User sets up the training and test data to fit their desired model here
+        :param data_dictionary: the dictionary constructed by DataHandler to hold
+                                all the training and test data/labels.
+        """
+
+        X = data_dictionary["train_features"]
+        y = data_dictionary["train_labels"]
+
+        if self.freqai_info.get("data_split_parameters", {}).get("test_size", 0.1) == 0:
+            eval_set = None
+            eval_weights = None
+        else:
+            eval_set = [(data_dictionary["test_features"], data_dictionary["test_labels"])]
+            eval_weights = [data_dictionary['test_weights']]
+
+        sample_weight = data_dictionary["train_weights"]
+
+        xgb_model = self.get_init_model(dk.pair)
+
+        model = XGBRFRegressor(**self.model_training_parameters)
+
+        model.fit(X=X, y=y, sample_weight=sample_weight, eval_set=eval_set,
+                  sample_weight_eval_set=eval_weights, xgb_model=xgb_model)
+
+        return model

freqtrade/freqai/prediction_models/XGBoostRegressor.py

@@ -29,6 +29,7 @@ class XGBoostRegressor(BaseRegressionModel):
 
         if self.freqai_info.get("data_split_parameters", {}).get("test_size", 0.1) == 0:
             eval_set = None
+            eval_weights = None
         else:
             eval_set = [(data_dictionary["test_features"], data_dictionary["test_labels"])]
             eval_weights = [data_dictionary['test_weights']]

freqtrade/freqai/utils.py

@@ -1,9 +1,11 @@
 import logging
 from datetime import datetime, timezone
-from typing import Any
+from pathlib import Path
+from typing import Any, Dict
 
 import numpy as np
 import pandas as pd
+import rapidjson
 
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import Config
@@ -191,3 +193,41 @@ def plot_feature_importance(model: Any, pair: str, dk: FreqaiDataKitchen,
         fig.update_layout(title_text=f"Best and worst features by importance {pair}")
         label = label.replace('&', '').replace('%', '')  # escape two FreqAI specific characters
         store_plot_file(fig, f"{dk.model_filename}-{label}.html", dk.data_path)
+
+
+def record_params(config: Dict[str, Any], full_path: Path) -> None:
+    """
+    Records run params in the full path for reproducibility
+    """
+    params_record_path = full_path / "run_params.json"
+
+    run_params = {
+        "freqai": config.get('freqai', {}),
+        "timeframe": config.get('timeframe'),
+        "stake_amount": config.get('stake_amount'),
+        "stake_currency": config.get('stake_currency'),
+        "max_open_trades": config.get('max_open_trades'),
+        "pairs": config.get('exchange', {}).get('pair_whitelist')
+    }
+
+    with open(params_record_path, "w") as handle:
+        rapidjson.dump(
+            run_params,
+            handle,
+            indent=4,
+            default=str,
+            number_mode=rapidjson.NM_NATIVE | rapidjson.NM_NAN
+        )
+
+
+def get_timerange_backtest_live_models(config: Config) -> str:
+    """
+    Returns a formated timerange for backtest live/ready models
+    :param config: Configuration dictionary
+
+    :return: a string timerange (format example: '20220801-20220822')
+    """
+    dk = FreqaiDataKitchen(config)
+    models_path = dk.get_full_models_path(config)
+    timerange, _ = dk.get_timerange_and_assets_end_dates_from_ready_models(models_path)
+    return timerange.timerange_str