From 6fc10484d26f8f96854863048b1f0a108517bc5f Mon Sep 17 00:00:00 2001 From: aszerW Date: Sat, 11 Oct 2025 19:05:42 +0800 Subject: [PATCH] init --- docker-compose-trade.yml | 13 + docker-compose.yml | 12 + macd_fit.py | 286 +++++++++++ user_data/config.json | 78 +++ user_data/hyperopts/sample_hyperopt_loss.py | 57 +++ .../notebooks/strategy_analysis_example.ipynb | 480 ++++++++++++++++++ user_data/strategies/MACDStrategy.py | 116 +++++ .../strategies/SimpleRSIStrategy_Fixed.py | 331 ++++++++++++ user_data/strategies/TD.py | 426 ++++++++++++++++ user_data/strategies/cci_multi_tf_strategy.py | 134 +++++ user_data/strategies/sample_strategy.py | 426 ++++++++++++++++ 11 files changed, 2359 insertions(+) create mode 100644 docker-compose-trade.yml create mode 100644 docker-compose.yml create mode 100644 macd_fit.py create mode 100644 user_data/config.json create mode 100644 user_data/hyperopts/sample_hyperopt_loss.py create mode 100644 user_data/notebooks/strategy_analysis_example.ipynb create mode 100644 user_data/strategies/MACDStrategy.py create mode 100644 user_data/strategies/SimpleRSIStrategy_Fixed.py create mode 100644 user_data/strategies/TD.py create mode 100644 user_data/strategies/cci_multi_tf_strategy.py create mode 100644 user_data/strategies/sample_strategy.py diff --git a/docker-compose-trade.yml b/docker-compose-trade.yml new file mode 100644 index 0000000..b8a8585 --- /dev/null +++ b/docker-compose-trade.yml @@ -0,0 +1,13 @@ +services: + freqtrade_trade: + image: freqtradeorg/freqtrade:stable + container_name: freqtrade_trade + restart: unless-stopped + volumes: + - "./user_data:/freqtrade/user_data" + ports: + - "8099:8077" + command: > + trade + --config ./user_data/config.json + --strategy MACDStrategy \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..add8b63 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,12 @@ +services: + freqtrade: + image: freqtradeorg/freqtrade:stable + container_name: freqtrade_web + restart: unless-stopped + volumes: + - "./user_data:/freqtrade/user_data" + ports: + - "8077:8077" + command: > + webserver + --config ./user_data/config.json \ No newline at end of file diff --git a/macd_fit.py b/macd_fit.py new file mode 100644 index 0000000..da72739 --- /dev/null +++ b/macd_fit.py @@ -0,0 +1,286 @@ +#!/usr/bin/env python3 +""" +Standalone script to: +- Load OHLCV feather data +- Compute MACD (12, 26, 9 by default) +- Fit MACD histogram with a simple trigonometric model + +Usage examples: + python macd_fit.py \ + --feather "/Users/aszer/Documents/vscode/cta/user_data/data/okx/ADA_USDT-1d.feather" + +Optional arguments (see -h): + --fast 12 --slow 26 --signal 9 + --min-period 5 --max-period 500 + --recent 1000 # only use most recent N points for fitting + --plot # show a quick plot (if matplotlib is available) +""" + +import argparse +import math +import sys +from dataclasses import dataclass +from typing import Callable, Optional, Tuple + +import numpy as np +import pandas as pd + + +# ---------------------------- +# Data structures +# ---------------------------- + +@dataclass +class MacdResult: + macd: np.ndarray + signal: np.ndarray + hist: np.ndarray + + +# ---------------------------- +# MACD computation +# ---------------------------- + +def compute_ema(values: pd.Series, span: int) -> pd.Series: + """Compute EMA with pandas ewm for numerical stability. + + The adjust=False setting produces the standard EMA used in trading. + """ + return values.ewm(span=span, adjust=False).mean() + + +def compute_macd(close_prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> MacdResult: + if slow <= fast: + raise ValueError("'slow' period must be greater than 'fast' period") + ema_fast = compute_ema(close_prices, span=fast) + ema_slow = compute_ema(close_prices, span=slow) + macd_line = ema_fast - ema_slow + signal_line = compute_ema(macd_line, span=signal) + hist = macd_line - signal_line + return MacdResult(macd=macd_line.to_numpy(), signal=signal_line.to_numpy(), hist=hist.to_numpy()) + + +# ---------------------------- +# Trigonometric fitting +# ---------------------------- + +def trig_model(t: np.ndarray, a: float, b: float, c: float, omega: float) -> np.ndarray: + """a*sin(omega*t) + b*cos(omega*t) + c""" + return a * np.sin(omega * t) + b * np.cos(omega * t) + c + + +def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: + ss_res = float(np.sum((y_true - y_pred) ** 2)) + ss_tot = float(np.sum((y_true - np.mean(y_true)) ** 2)) + return 1.0 - ss_res / ss_tot if ss_tot > 0 else 0.0 + + +def fit_with_scipy( + t: np.ndarray, + y: np.ndarray, + omega_bounds: Tuple[float, float], + initial_period_guess: int, +) -> Optional[Tuple[np.ndarray, np.ndarray]]: + """Try using SciPy's curve_fit if available. Returns (params, cov) or None if SciPy is missing.""" + try: + from scipy.optimize import curve_fit # type: ignore + except Exception: + return None + + # Initial guesses + y_std = float(np.std(y)) + y_mean = float(np.mean(y)) + omega0 = 2.0 * math.pi / float(max(initial_period_guess, 1)) + p0 = np.array([0.7 * y_std if y_std > 0 else 0.0, 0.0, y_mean, omega0], dtype=float) + + bounds = ( + np.array([-np.inf, -np.inf, -np.inf, omega_bounds[0]], dtype=float), + np.array([np.inf, np.inf, np.inf, omega_bounds[1]], dtype=float), + ) + + params, cov = curve_fit(trig_model, t, y, p0=p0, bounds=bounds, maxfev=20000) + return params, cov + + +def fit_without_scipy( + t: np.ndarray, + y: np.ndarray, + min_period: int, + max_period: int, + num_omegas: int = 200, +) -> Tuple[np.ndarray, float]: + """Fallback: grid-search omega, solve a,b,c by linear least squares for each omega. + + For each omega, we solve y ~ a*sin(omega*t) + b*cos(omega*t) + c. + Returns best_params([a,b,c,omega]), best_r2. + """ + if min_period < 2: + min_period = 2 + if max_period <= min_period: + max_period = min_period + 1 + + candidate_periods = np.linspace(min_period, max_period, num=num_omegas) + best_r2 = -np.inf + best_params = np.array([0.0, 0.0, float(np.mean(y)), 2.0 * math.pi / float(max_period)], dtype=float) + + # Precompute vectors that do not depend on omega (only t does) + ones = np.ones_like(t) + + for period in candidate_periods: + omega = 2.0 * math.pi / float(period) + # Design matrix: [sin(ωt), cos(ωt), 1] + X = np.column_stack((np.sin(omega * t), np.cos(omega * t), ones)) + # Solve least squares for [a,b,c] + coeffs, *_ = np.linalg.lstsq(X, y, rcond=None) + y_hat = X @ coeffs + score = r2_score(y, y_hat) + if score > best_r2: + best_r2 = score + best_params = np.array([coeffs[0], coeffs[1], coeffs[2], omega], dtype=float) + + return best_params, float(best_r2) + + +def fit_histogram( + hist: np.ndarray, + min_period: int, + max_period: int, + initial_period_guess: int, +) -> Tuple[np.ndarray, float]: + """Fit histogram with trig model. Returns (best_params, best_r2). + + The time axis t uses uniform steps (index-based). This is sufficient because + MACD is sampled at regular intervals (1d here); absolute timestamps are not required. + """ + n = hist.shape[0] + t = np.arange(n, dtype=float) + + # Reasonable omega bounds from period range + omega_min = 2.0 * math.pi / float(max_period) + omega_max = 2.0 * math.pi / float(max(min_period, 2)) + + scipy_fit = fit_with_scipy(t, hist, (omega_min, omega_max), initial_period_guess) + if scipy_fit is not None: + params, _ = scipy_fit + y_hat = trig_model(t, *params) + return params, float(r2_score(hist, y_hat)) + + # Fallback path without SciPy + return fit_without_scipy(t, hist, min_period=min_period, max_period=max_period) + + +# ---------------------------- +# I/O and CLI +# ---------------------------- + +def read_feather_ohlcv(feather_path: str) -> pd.DataFrame: + df = pd.read_feather(feather_path) + # Normalize columns + expected = {"date", "open", "high", "low", "close", "volume"} + lower_map = {col.lower(): col for col in df.columns} + if not expected.issubset(lower_map.keys()): + raise ValueError(f"Feather file is missing required columns. Found: {list(df.columns)}") + + # Ensure correct ordering and types + df = df[[lower_map[c] for c in ["date", "open", "high", "low", "close", "volume"]]].copy() + # Convert date to pandas datetime (timezone-aware handled by pandas) + df[lower_map["date"]] = pd.to_datetime(df[lower_map["date"]], utc=True, errors="coerce") + df = df.rename(columns={ + lower_map["date"]: "date", + lower_map["open"]: "open", + lower_map["high"]: "high", + lower_map["low"]: "low", + lower_map["close"]: "close", + lower_map["volume"]: "volume", + }) + df = df.sort_values("date").reset_index(drop=True) + return df + + +def try_plot(df: pd.DataFrame, hist: np.ndarray, y_hat: np.ndarray) -> None: + try: + import matplotlib.pyplot as plt # type: ignore + except Exception: + print("[info] matplotlib not available; skipping plot.") + return + + fig, ax = plt.subplots(2, 1, figsize=(10, 6), sharex=True) + ax[0].plot(df["date"], df["close"], label="Close", color="#1976D2") + ax[0].set_title("Close") + ax[0].grid(True, alpha=0.3) + ax[0].legend() + + ax[1].plot(df["date"], hist, label="MACD Hist", color="#D32F2F", linewidth=1) + ax[1].plot(df["date"], y_hat, label="Trig Fit", color="#388E3C", linewidth=1.2) + ax[1].set_title("MACD Histogram and Trig Fit") + ax[1].grid(True, alpha=0.3) + ax[1].legend() + + fig.tight_layout() + plt.show() + + +def main() -> int: + parser = argparse.ArgumentParser(description="Compute MACD and fit histogram with trigonometric model.") + parser.add_argument( + "--feather", + type=str, + default="/Users/aszer/Documents/vscode/cta/user_data/data/okx/ADA_USDT-1d.feather", + help="Path to feather OHLCV file", + ) + parser.add_argument("--fast", type=int, default=12, help="MACD fast EMA period") + parser.add_argument("--slow", type=int, default=26, help="MACD slow EMA period") + parser.add_argument("--signal", type=int, default=9, help="MACD signal EMA period") + parser.add_argument("--recent", type=int, default=0, help="Use only most recent N rows for fitting (0 = all)") + parser.add_argument("--min-period", type=int, default=5, help="Minimum oscillation period (in bars) for fit") + parser.add_argument("--max-period", type=int, default=500, help="Maximum oscillation period (in bars) for fit") + parser.add_argument("--period-guess", type=int, default=50, help="Initial period guess (in bars)") + parser.add_argument("--plot", action="store_true", help="Show a quick matplotlib plot (if available)") + + args = parser.parse_args() + + df = read_feather_ohlcv(args.feather) + macd_res = compute_macd(df["close"], fast=args.fast, slow=args.slow, signal=args.signal) + + hist = macd_res.hist + if args.recent and args.recent > 0: + hist = hist[-args.recent :] + df_for_fit = df.tail(hist.shape[0]).reset_index(drop=True) + else: + df_for_fit = df.copy() + + params, score = fit_histogram( + hist=hist, + min_period=args.min_period, + max_period=args.max_period, + initial_period_guess=args.period_guess, + ) + + a, b, c, omega = map(float, params) + period = 2.0 * math.pi / omega if omega != 0 else float("inf") + y_hat = trig_model(np.arange(hist.shape[0], dtype=float), a, b, c, omega) + + # Console summary + print("=== MACD Histogram Trigonometric Fit ===") + print(f"Rows used: {hist.shape[0]}") + print(f"Parameters: a={a:.6g}, b={b:.6g}, c={c:.6g}, omega={omega:.6g}") + print(f"Implied period (bars): {period:.3f}") + print(f"R^2: {score:.6f}") + + # Show last few comparisons + tail_n = min(10, hist.shape[0]) + print("\nLast samples (date, hist, fit):") + for i in range(-tail_n, 0): + date_str = df_for_fit["date"].iloc[i].strftime("%Y-%m-%d") + print(f" {date_str} hist={hist[i]: .6g} fit={y_hat[i]: .6g}") + + if args.plot: + try_plot(df_for_fit, hist, y_hat) + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) + + diff --git a/user_data/config.json b/user_data/config.json new file mode 100644 index 0000000..06193ed --- /dev/null +++ b/user_data/config.json @@ -0,0 +1,78 @@ + +{ + "$schema": "https://schema.freqtrade.io/schema.json", + "max_open_trades": 1, + "stake_currency": "USDT", + "stake_amount": "unlimited", + "tradable_balance_ratio": 0.99, + "fiat_display_currency": "USD", + "dry_run": false, + "dry_run_wallet": 100, + "cancel_open_orders_on_exit": false, + "trading_mode": "spot", + "candle_type_def": "spot", + "margin_mode": "isolated", + "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": "okx", + "key": "204d1314-483e-46fa-8c0e-00b789a590f1", + "secret": "AB6B77BB06CC852AA9557FEED66D42ED", + "password": "WAng12345?", + "ccxt_config": {}, + "ccxt_async_config": {}, + "pair_whitelist": [ + "ETH/USDT" + ], + "pair_blacklist": [ + ] + }, + "pairlists": [ + { + "method": "StaticPairList" + } + ], + "telegram": { + "enabled": false, + "token": "", + "chat_id": "" + }, + "api_server": { + "enabled": true, + "listen_ip_address": "0.0.0.0", + "listen_port": 8077, + "verbosity": "error", + "enable_openapi": false, + "jwt_secret_key": "98d28a61889840784b27d992637896b8d3a899daf81883f6afc05b06e7de1bcc", + "ws_token": "GkpwqTvsGZPWplrU5eqgaV8KLUoKltH5Nw", + "CORS_origins": [], + "username": "freqtrader", + "password": "12345" + }, + "bot_name": "freqtrade", + "initial_state": "running", + "force_entry_enable": false, + "internals": { + "process_throttle_secs": 5 + } + +} \ No newline at end of file diff --git a/user_data/hyperopts/sample_hyperopt_loss.py b/user_data/hyperopts/sample_hyperopt_loss.py new file mode 100644 index 0000000..20a348f --- /dev/null +++ b/user_data/hyperopts/sample_hyperopt_loss.py @@ -0,0 +1,57 @@ +from datetime import datetime +from math import exp + +from pandas import DataFrame + +from freqtrade.constants import Config +from freqtrade.optimize.hyperopt import IHyperOptLoss + + +# Define some constants: + +# set TARGET_TRADES to suit your number concurrent trades so its realistic +# to the number of days +TARGET_TRADES = 600 +# This is assumed to be expected avg profit * expected trade count. +# For example, for 0.35% avg per trade (or 0.0035 as ratio) and 1100 trades, +# self.expected_max_profit = 3.85 +# Check that the reported Σ% values do not exceed this! +# Note, this is ratio. 3.85 stated above means 385Σ%. +EXPECTED_MAX_PROFIT = 3.0 + +# max average trade duration in minutes +# if eval ends with higher value, we consider it a failed eval +MAX_ACCEPTED_TRADE_DURATION = 300 + + +class SampleHyperOptLoss(IHyperOptLoss): + """ + Defines the default loss function for hyperopt + This is intended to give you some inspiration for your own loss function. + + The Function needs to return a number (float) - which becomes smaller for better backtest + results. + """ + + @staticmethod + def hyperopt_loss_function( + results: DataFrame, + trade_count: int, + min_date: datetime, + max_date: datetime, + config: Config, + processed: dict[str, DataFrame], + *args, + **kwargs, + ) -> float: + """ + Objective function, returns smaller number for better results + """ + total_profit = results["profit_ratio"].sum() + trade_duration = results["trade_duration"].mean() + + trade_loss = 1 - 0.25 * exp(-((trade_count - TARGET_TRADES) ** 2) / 10**5.8) + profit_loss = max(0, 1 - total_profit / EXPECTED_MAX_PROFIT) + duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1) + result = trade_loss + profit_loss + duration_loss + return result diff --git a/user_data/notebooks/strategy_analysis_example.ipynb b/user_data/notebooks/strategy_analysis_example.ipynb new file mode 100644 index 0000000..c81a76f --- /dev/null +++ b/user_data/notebooks/strategy_analysis_example.ipynb @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Strategy analysis example\n", + "\n", + "Debugging a strategy can be time-consuming. Freqtrade offers helper functions to visualize raw data.\n", + "The following assumes you work with SampleStrategy, data for 5m timeframe from Binance and have downloaded them into the data directory in the default location.\n", + "Please follow the [documentation](https://www.freqtrade.io/en/stable/data-download/) for more details." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "### Change Working directory to repository root" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "\n", + "# Change directory\n", + "# Modify this cell to insure that the output shows the correct path.\n", + "# Define all paths relative to the project root shown in the cell output\n", + "project_root = \"somedir/freqtrade\"\n", + "i = 0\n", + "try:\n", + " os.chdir(project_root)\n", + " if not Path(\"LICENSE\").is_file():\n", + " i = 0\n", + " while i < 4 and (not Path(\"LICENSE\").is_file()):\n", + " os.chdir(Path(Path.cwd(), \"../\"))\n", + " i += 1\n", + " project_root = Path.cwd()\n", + "except FileNotFoundError:\n", + " print(\"Please define the project root relative to the current directory\")\n", + "print(Path.cwd())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configure Freqtrade environment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from freqtrade.configuration import Configuration\n", + "\n", + "\n", + "# Customize these according to your needs.\n", + "\n", + "# Initialize empty configuration object\n", + "config = Configuration.from_files([])\n", + "# Optionally (recommended), use existing configuration file\n", + "# config = Configuration.from_files([\"user_data/config.json\"])\n", + "\n", + "# Define some constants\n", + "config[\"timeframe\"] = \"5m\"\n", + "# Name of the strategy class\n", + "config[\"strategy\"] = \"SampleStrategy\"\n", + "# Location of the data\n", + "data_location = config[\"datadir\"]\n", + "# Pair to analyze - Only use one pair here\n", + "pair = \"BTC/USDT\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data using values set above\n", + "from freqtrade.data.history import load_pair_history\n", + "from freqtrade.enums import CandleType\n", + "\n", + "\n", + "candles = load_pair_history(\n", + " datadir=data_location,\n", + " timeframe=config[\"timeframe\"],\n", + " pair=pair,\n", + " data_format=\"json\", # Make sure to update this to your data\n", + " candle_type=CandleType.SPOT,\n", + ")\n", + "\n", + "# Confirm success\n", + "print(f\"Loaded {len(candles)} rows of data for {pair} from {data_location}\")\n", + "candles.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load and run strategy\n", + "* Rerun each time the strategy file is changed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load strategy using values set above\n", + "from freqtrade.data.dataprovider import DataProvider\n", + "from freqtrade.resolvers import StrategyResolver\n", + "\n", + "\n", + "strategy = StrategyResolver.load_strategy(config)\n", + "strategy.dp = DataProvider(config, None, None)\n", + "strategy.ft_bot_start()\n", + "\n", + "# Generate buy/sell signals using strategy\n", + "df = strategy.analyze_ticker(candles, {\"pair\": pair})\n", + "df.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Display the trade details\n", + "\n", + "* Note that using `data.head()` would also work, however most indicators have some \"startup\" data at the top of the dataframe.\n", + "* Some possible problems\n", + " * Columns with NaN values at the end of the dataframe\n", + " * Columns used in `crossed*()` functions with completely different units\n", + "* Comparison with full backtest\n", + " * having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting.\n", + " * Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple \"buy\" signals for each pair in sequence (until rsi returns > 29). The bot will only buy on the first of these signals (and also only if a trade-slot (\"max_open_trades\") is still available), or on one of the middle signals, as soon as a \"slot\" becomes available. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Report results\n", + "print(f\"Generated {df['enter_long'].sum()} entry signals\")\n", + "data = df.set_index(\"date\", drop=False)\n", + "data.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load existing objects into a Jupyter notebook\n", + "\n", + "The following cells assume that you have already generated data using the cli. \n", + "They will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load backtest results to pandas dataframe\n", + "\n", + "Analyze a trades dataframe (also used below for plotting)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from freqtrade.data.btanalysis import load_backtest_data, load_backtest_stats\n", + "\n", + "\n", + "# if backtest_dir points to a directory, it'll automatically load the last backtest file.\n", + "backtest_dir = config[\"user_data_dir\"] / \"backtest_results\"\n", + "# backtest_dir can also point to a specific file\n", + "# backtest_dir = (\n", + "# config[\"user_data_dir\"] / \"backtest_results/backtest-result-2020-07-01_20-04-22.json\"\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# You can get the full backtest statistics by using the following command.\n", + "# This contains all information used to generate the backtest result.\n", + "stats = load_backtest_stats(backtest_dir)\n", + "\n", + "strategy = \"SampleStrategy\"\n", + "# All statistics are available per strategy, so if `--strategy-list` was used during backtest,\n", + "# this will be reflected here as well.\n", + "# Example usages:\n", + "print(stats[\"strategy\"][strategy][\"results_per_pair\"])\n", + "# Get pairlist used for this backtest\n", + "print(stats[\"strategy\"][strategy][\"pairlist\"])\n", + "# Get market change (average change of all pairs from start to end of the backtest period)\n", + "print(stats[\"strategy\"][strategy][\"market_change\"])\n", + "# Maximum drawdown ()\n", + "print(stats[\"strategy\"][strategy][\"max_drawdown_abs\"])\n", + "# Maximum drawdown start and end\n", + "print(stats[\"strategy\"][strategy][\"drawdown_start\"])\n", + "print(stats[\"strategy\"][strategy][\"drawdown_end\"])\n", + "\n", + "\n", + "# Get strategy comparison (only relevant if multiple strategies were compared)\n", + "print(stats[\"strategy_comparison\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load backtested trades as dataframe\n", + "trades = load_backtest_data(backtest_dir)\n", + "\n", + "# Show value-counts per pair\n", + "trades.groupby(\"pair\")[\"exit_reason\"].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting daily profit / equity line" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plotting equity line (starting with 0 on day 1 and adding daily profit for each backtested day)\n", + "\n", + "import pandas as pd\n", + "import plotly.express as px\n", + "\n", + "from freqtrade.configuration import Configuration\n", + "from freqtrade.data.btanalysis import load_backtest_stats\n", + "\n", + "\n", + "# strategy = 'SampleStrategy'\n", + "# config = Configuration.from_files([\"user_data/config.json\"])\n", + "# backtest_dir = config[\"user_data_dir\"] / \"backtest_results\"\n", + "\n", + "stats = load_backtest_stats(backtest_dir)\n", + "strategy_stats = stats[\"strategy\"][strategy]\n", + "\n", + "df = pd.DataFrame(columns=[\"dates\", \"equity\"], data=strategy_stats[\"daily_profit\"])\n", + "df[\"equity_daily\"] = df[\"equity\"].cumsum()\n", + "\n", + "fig = px.line(df, x=\"dates\", y=\"equity_daily\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load live trading results into a pandas dataframe\n", + "\n", + "In case you did already some trading and want to analyze your performance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from freqtrade.data.btanalysis import load_trades_from_db\n", + "\n", + "\n", + "# Fetch trades from database\n", + "trades = load_trades_from_db(\"sqlite:///tradesv3.sqlite\")\n", + "\n", + "# Display results\n", + "trades.groupby(\"pair\")[\"exit_reason\"].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyze the loaded trades for trade parallelism\n", + "This can be useful to find the best `max_open_trades` parameter, when used with backtesting in conjunction with a very high `max_open_trades` setting.\n", + "\n", + "`analyze_trade_parallelism()` returns a timeseries dataframe with an \"open_trades\" column, specifying the number of open trades for each candle." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from freqtrade.data.btanalysis import analyze_trade_parallelism\n", + "\n", + "\n", + "# Analyze the above\n", + "parallel_trades = analyze_trade_parallelism(trades, \"5m\")\n", + "\n", + "parallel_trades.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot results\n", + "\n", + "Freqtrade offers interactive plotting capabilities based on plotly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from freqtrade.plot.plotting import generate_candlestick_graph\n", + "\n", + "\n", + "# Limit graph period to keep plotly quick and reactive\n", + "\n", + "# Filter trades to one pair\n", + "trades_red = trades.loc[trades[\"pair\"] == pair]\n", + "\n", + "data_red = data[\"2019-06-01\":\"2019-06-10\"]\n", + "# Generate candlestick graph\n", + "graph = generate_candlestick_graph(\n", + " pair=pair,\n", + " data=data_red,\n", + " trades=trades_red,\n", + " indicators1=[\"sma20\", \"ema50\", \"ema55\"],\n", + " indicators2=[\"rsi\", \"macd\", \"macdsignal\", \"macdhist\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Show graph inline\n", + "# graph.show()\n", + "\n", + "# Render graph in a separate window\n", + "graph.show(renderer=\"browser\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot average profit per trade as distribution graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import plotly.figure_factory as ff\n", + "\n", + "\n", + "hist_data = [trades.profit_ratio]\n", + "group_labels = [\"profit_ratio\"] # name of the dataset\n", + "\n", + "fig = ff.create_distplot(hist_data, group_labels, bin_size=0.01)\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data." + ] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "Python 3.9.7 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, + "version": 3, + "vscode": { + "interpreter": { + "hash": "675f32a300d6d26767470181ad0b11dd4676bcce7ed1dd2ffe2fbc370c95fc7c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/user_data/strategies/MACDStrategy.py b/user_data/strategies/MACDStrategy.py new file mode 100644 index 0000000..843a711 --- /dev/null +++ b/user_data/strategies/MACDStrategy.py @@ -0,0 +1,116 @@ +# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement +# flake8: noqa: F401 +# isort: skip_file +# --- Do not remove these imports --- +import numpy as np +import pandas as pd +from datetime import datetime, timedelta, timezone +from pandas import DataFrame +from typing import Optional, Union +from freqtrade.strategy import ( + IStrategy, + Trade, + Order, + PairLocks, + informative, # @informative decorator + # Hyperopt Parameters + BooleanParameter, + CategoricalParameter, + DecimalParameter, + IntParameter, + RealParameter, + # timeframe helpers + timeframe_to_minutes, + timeframe_to_next_date, + timeframe_to_prev_date, + # Strategy helper functions + merge_informative_pair, + stoploss_from_absolute, + stoploss_from_open, +) +import logging + +logger = logging.getLogger(__name__) +# -------------------------------- +# Add your lib to import here +import talib.abstract as ta +from technical import qtpylib + + +class MACDStrategy(IStrategy): + # 策略参数 + INTERFACE_VERSION = 3 + + minimal_roi = {"0": 100} + stoploss = -1 + trailing_stop = False + timeframe = '15m' + + use_exit_signal = True + exit_profit_only = False + ignore_roi_if_entry_signal = False + + def TD(self, dataframe:DataFrame): + close = dataframe['close'].to_list() + td = [0,0,0,0] + up = 0 + down = 0 + for i in range(4, len(close)): + if close[i] > close[i-4]: + up += 1 + down = 0 + td.append(up) + else: + down -= 1 + up = 0 + td.append(down) + return td + + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + + macd = ta.MACD(dataframe, fastperiod=12, slowperiod=26, signalperiod=9,) + dataframe["macd"] = macd["macd"] + dataframe["macdsignal"] = macd["macdsignal"] + dataframe["macdhist"] = macd["macdhist"] + dataframe['cci'] = ta.CCI(dataframe, 26) + dataframe['TD'] = self.TD(dataframe) + return dataframe + + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # 入场：1d与4h CCI < -100，且4h CCI上升（当前 > 前一根） + dataframe.loc[ + ( + # (dataframe['macdhist'] < 0) & + # (dataframe['macdhist'] > dataframe['macdhist'].shift(1)) & + # (dataframe['macdsignal'] < 0) & + # (dataframe['macd'] < dataframe['macdsignal']) & + # (dataframe['cci'] < -100) & + # (dataframe['cci'].shift(1) < dataframe['cci']) & + # (dataframe['macdhist'] < 0) & + (dataframe['TD'] == 1) & + (dataframe['volume'] > 0) + ), + 'enter_long', + ] = 1 + + return dataframe + + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # 离场：1d与4h CCI > 100，且4h CCI下降（当前 < 前一根） + dataframe.loc[ + ( + # (dataframe['macdhist'] > 0) & + # (dataframe['macdhist'] < dataframe['macdhist'].shift(1)) & + # (dataframe['macdsignal'] > 0) & + # (dataframe['macd'] > dataframe['macdsignal']) & + # (dataframe['cci'] > 100 )& + # (dataframe['cci'].shift(1) > dataframe['cci']) & + # (dataframe['macdhist'] > 0) & + (dataframe['TD'] == -1) & + (dataframe['volume'] > 0) + ), + 'exit_long', + ] = 1 + + return dataframe + diff --git a/user_data/strategies/SimpleRSIStrategy_Fixed.py b/user_data/strategies/SimpleRSIStrategy_Fixed.py new file mode 100644 index 0000000..8d1e5d3 --- /dev/null +++ b/user_data/strategies/SimpleRSIStrategy_Fixed.py @@ -0,0 +1,331 @@ +# strategies/SimpleRSIStrategy_Fixed.py + +import talib.abstract as ta +import pandas as pd +import numpy as np +from freqtrade.strategy import IStrategy +from freqtrade.persistence import Trade +from typing import Dict, List, Optional +from functools import reduce +import logging + +logger = logging.getLogger(__name__) + + +class SimpleRSIStrategyFixed(IStrategy): + """ + 修复版简化 RSI 策略：结合 EMA 交叉 + RSI 超卖 + 上升趋势 + + 修复内容： + 1. 添加缺失的导入语句 + 2. 修复除零错误 + 3. 优化性能 + 4. 改进代码可读性 + 5. 添加数据验证 + """ + INTERFACE_VERSION = 3 + + # Can this strategy go short? + can_short: bool = False + + # Minimal ROI designed for the strategy. + # 基于x.py策略，使用更保守的ROI设置 + # minimal_roi = { + # "30": 0.3, # 20% 目标收益 + # # "" + # } + + # Optimal stoploss designed for the strategy. + # 基于x.py策略的卖出条件：跌破MA60且跌幅超过10% + stoploss = -0.05 + + # 超参数定义 + minimal_roi = { + "0": 100 + } + + timeframe = '1d' + + # 策略参数 + rsi_period_short = 6 + rsi_period_long = 12 + ema_period_short = 10 + ema_period_long = 20 + rsi_oversold_threshold = 20 + rsi_oversold_tolerance = 1.05 + ema_trend_threshold = 0.01 + ema_breakout_threshold = 0.02 + ema_separation_threshold = 0.02 + + def populate_indicators(self, dataframe: pd.DataFrame, metadata: Dict) -> pd.DataFrame: + """ + 添加技术指标到数据框 + """ + try: + # RSI 指标 (6, 12) 及位移 + dataframe['rsi_6'] = ta.RSI(dataframe['close'], timeperiod=6) + dataframe['rsi_12'] = ta.RSI(dataframe['close'], timeperiod=12) + for i in range(1, 6): + dataframe[f'rsi_6_shift{i}'] = dataframe['rsi_6'].shift(i) + dataframe[f'rsi_12_shift{i}'] = dataframe['rsi_12'].shift(i) + + # EMA 指标 (10, 20, 30) 及位移 + dataframe['ema_10'] = ta.EMA(dataframe['close'], timeperiod=10) + dataframe['ema_20'] = ta.EMA(dataframe['close'], timeperiod=20) + dataframe['ema_30'] = ta.EMA(dataframe['close'], timeperiod=30) + for i in range(1, 6): + dataframe[f'ema_10_shift{i}'] = dataframe['ema_10'].shift(i) + dataframe[f'ema_20_shift{i}'] = dataframe['ema_20'].shift(i) + dataframe[f'ema_30_shift{i}'] = dataframe['ema_30'].shift(i) + + # 方便条件判断的差值与比率（带除零保护） + dataframe['ema_10_20_diff'] = dataframe['ema_10'] - dataframe['ema_20'] + dataframe['ema_10_20_ratio'] = np.where( + dataframe['ema_20'] != 0, + dataframe['ema_10_20_diff'] / dataframe['ema_20'], + 0 + ) + for i in range(1, 6): + dataframe[f'ema_10_20_diff_shift{i}'] = dataframe['ema_10_20_diff'].shift(i) + dataframe[f'ema_10_20_ratio_shift{i}'] = np.where( + dataframe[f'ema_20_shift{i}'] != 0, + dataframe[f'ema_10_20_diff_shift{i}'] / dataframe[f'ema_20_shift{i}'], + 0 + ) + dataframe.to_csv("rsi_eth2.csv", index=False, encoding='utf-8-sig') + logger.debug(f"Indicators populated successfully for {metadata.get('pair', 'unknown')}") + return dataframe + + except Exception as e: + logger.error(f"Error populating indicators: {e}") + return dataframe + + def populate_entry_trend(self, dataframe: pd.DataFrame, metadata: Dict) -> pd.DataFrame: + """ + 生成买入信号 + """ + try: + # 初始化信号列 + dataframe.loc[:, 'enter_long'] = 0 + + # 数据验证 + required_columns = [ + 'ema_10', 'ema_20', 'ema_30', + 'rsi_6', 'rsi_12', + 'ema_10_shift1', 'ema_10_shift2', 'ema_10_shift3', 'ema_10_shift4', 'ema_10_shift5', + 'ema_20_shift1', 'ema_20_shift2', 'ema_20_shift3', 'ema_20_shift4', 'ema_20_shift5', + 'rsi_6_shift1', 'rsi_6_shift2', 'rsi_6_shift3', + 'rsi_12_shift1', 'rsi_12_shift2', 'rsi_12_shift3', + 'ema_10_20_ratio', 'ema_10_20_ratio_shift5', + 'ema_10_20_diff', 'ema_10_20_diff_shift1', 'ema_10_20_diff_shift2', 'ema_10_20_diff_shift3', 'ema_10_20_diff_shift4', 'ema_10_20_diff_shift5', + 'close' + ] + if not all(col in dataframe.columns for col in required_columns): + logger.warning(f"Missing required columns: {required_columns}") + return dataframe + + # 按给定逻辑实现买入条件 + ema_10 = dataframe['ema_10'] + ema_20 = dataframe['ema_20'] + ema_10_s1 = dataframe['ema_10_shift1'] + ema_10_s2 = dataframe['ema_10_shift2'] + ema_10_s3 = dataframe['ema_10_shift3'] + ema_10_s4 = dataframe['ema_10_shift4'] + ema_10_s5 = dataframe['ema_10_shift5'] + ema_20_s1 = dataframe['ema_20_shift1'] + ema_20_s2 = dataframe['ema_20_shift2'] + ema_20_s3 = dataframe['ema_20_shift3'] + ema_20_s4 = dataframe['ema_20_shift4'] + ema_20_s5 = dataframe['ema_20_shift5'] + rsi_6 = dataframe['rsi_6'] + rsi_12 = dataframe['rsi_12'] + rsi_6_s1 = dataframe['rsi_6_shift1'] + rsi_6_s2 = dataframe['rsi_6_shift2'] + rsi_6_s3 = dataframe['rsi_6_shift3'] + rsi_12_s1 = dataframe['rsi_12_shift1'] + rsi_12_s2 = dataframe['rsi_12_shift2'] + rsi_12_s3 = dataframe['rsi_12_shift3'] + close = dataframe['close'] + + # 比率与安全除法 + ratio_now = np.where(ema_20 != 0, (ema_10 - ema_20) / ema_20, 0) + ratio_s5 = np.where(ema_20_s5 != 0, (ema_10_s5 - ema_20_s5) / ema_20_s5, 0) + ratio_pos_and_small = (ratio_s5 != 0) & ((ratio_now / ratio_s5) > 0) & ((ratio_now / ratio_s5) < 0.2) + + cond_1 = ( + ( + (ema_10 > ema_20) + & (ema_10_s1 > ema_20_s1) + & (ema_10_s1 > ema_10_s2) + & (ema_10 > ema_10_s1) + & (ratio_now > 0.01) + ) + | + ( + (ema_10 > 1.02 * ema_10_s1) + & (ema_10_s1 > ema_10_s2) + & (ema_10 > ema_20) + ) + | + ( + ratio_pos_and_small + & ((ema_20 - ema_10) < (ema_20_s1 - ema_10_s1)) + & ((ema_20 - ema_10) < (ema_20_s2 - ema_10_s2)) + & ((ema_20 - ema_10) < (ema_20_s3 - ema_10_s3)) + & ((ema_20 - ema_10) < (ema_20_s4 - ema_10_s4)) + & ((ema_20 - ema_10) < (ema_20_s5 - ema_10_s5)) + & (ema_20_s5 > ema_10_s5) + & (ema_10 < close) + ) + ) + + cond_rsi = ( + (rsi_6 > 1.5 * rsi_6_s1) + & (rsi_6 > 0.95 * rsi_12) + & (rsi_6_s1 < 20 * 1.05) + & (rsi_6_s2 < 20 * 1.05) + & (rsi_6_s3 < 20 * 1.05) + & (rsi_12_s1 < 25 * 1.05) + & (rsi_12_s2 < 25 * 1.05) + & (rsi_12_s3 < 25 * 1.05) + ) + + buy_condition = cond_1 | cond_rsi + + dataframe.loc[buy_condition, 'enter_long'] = 1 + + # 记录信号统计 + signal_count = buy_condition.sum() + if signal_count > 0: + logger.info(f"Generated {signal_count} buy signals for {metadata.get('pair', 'unknown')}") + + return dataframe + + except Exception as e: + logger.error(f"Error in populate_entry_trend: {e}") + return dataframe + + def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: Dict) -> pd.DataFrame: + """ + 生成卖出信号 + """ + try: + dataframe.loc[:, 'exit_long'] = 0 + + # 数据验证 + required_columns = [ + 'ema_10', 'ema_20', + 'ema_10_shift1', 'ema_10_shift2', 'ema_10_shift3', 'ema_10_shift4', 'ema_10_shift5', + 'ema_20_shift1', 'ema_20_shift2', 'ema_20_shift3', 'ema_20_shift4', 'ema_20_shift5', + 'ema_10_20_ratio', 'ema_10_20_ratio_shift4', + ] + if not all(col in dataframe.columns for col in required_columns): + logger.warning(f"Missing required columns: {required_columns}") + return dataframe + + ema_10 = dataframe['ema_10'] + ema_20 = dataframe['ema_20'] + ema_10_s1 = dataframe['ema_10_shift1'] + ema_10_s2 = dataframe['ema_10_shift2'] + ema_10_s3 = dataframe['ema_10_shift3'] + ema_10_s4 = dataframe['ema_10_shift4'] + ema_10_s5 = dataframe['ema_10_shift5'] + ema_20_s1 = dataframe['ema_20_shift1'] + ema_20_s2 = dataframe['ema_20_shift2'] + ema_20_s3 = dataframe['ema_20_shift3'] + ema_20_s4 = dataframe['ema_20_shift4'] + ema_20_s5 = dataframe['ema_20_shift5'] + + ratio_now = np.where(ema_20 != 0, (ema_10 - ema_20) / ema_20, 0) + ratio_s4 = np.where(ema_20_s4 != 0, (ema_10_s4 - ema_20_s4) / ema_20_s4, 0) + ratio_pos_and_lt03 = (ratio_s4 != 0) & ((ratio_now / ratio_s4) > 0) & ((ratio_now / ratio_s4) < 0.3) + + cond_block_1 = ( + ( + (ema_10 < ema_20) + & (ema_10_s1 < ema_20_s1) + & (ema_10_s2 < ema_20_s2) + & (ema_10_s5 > ema_20_s5) + ) + | + ( + (ema_10 < 0.995 * ema_10_s1) + & (ema_10_s1 < ema_10_s2) + & (ema_10 < ema_20) + ) + ) + + cond_block_2 = ( + (ratio_now < 0.02) + & ratio_pos_and_lt03 + & (ema_10_s4 > ema_20_s4) + & (ema_10 < ema_10_s1) + & (ema_10 < ema_10_s2) + & (ema_10 < ema_10_s3) + & (ema_10 < ema_10_s4) + ) + + widening_now_vs_history = ( + ((ema_20 - ema_10) > (ema_20_s1 - ema_10_s1)) + & ((ema_20 - ema_10) > (ema_20_s2 - ema_10_s2)) + & ((ema_20 - ema_10) > (ema_20_s3 - ema_10_s3)) + & ((ema_20 - ema_10) > (ema_20_s4 - ema_10_s4)) + & ((ema_20 - ema_10) > (ema_20_s5 - ema_10_s5)) + ) + + sell_condition = ( + ( + cond_block_1 + & (ema_10 < ema_10_s1) + & (ema_10 < ema_10_s2) + & (ema_10 < ema_10_s3) + & (ema_10 < ema_10_s4) + & (ema_10 < ema_10_s5) + & widening_now_vs_history + ) + | + ( + cond_block_2 + & ((ema_20 - ema_10) > (ema_20_s1 - ema_10_s1)) + & ((ema_20 - ema_10) > (ema_20_s2 - ema_10_s2)) + & ((ema_20 - ema_10) > (ema_20_s3 - ema_10_s3)) + & ((ema_20 - ema_10) > (ema_20_s4 - ema_10_s4)) + ) + ) + + dataframe.loc[sell_condition, 'exit_long'] = 1 + + # 记录信号统计 + signal_count = sell_condition.sum() + if signal_count > 0: + logger.info(f"Generated {signal_count} sell signals for {metadata.get('pair', 'unknown')}") + + return dataframe + + except Exception as e: + logger.error(f"Error in populate_exit_trend: {e}") + return dataframe + + # def custom_stoploss(self, pair: str, trade: Trade, current_time, current_rate, current_profit, **kwargs) -> float: + # """ + # 自定义止损逻辑 + # """ + # try: + # # 动态止损：根据RSI调整止损点 + # dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) + # if len(dataframe) > 0: + # last_candle = dataframe.iloc[-1] + # rsi_short = last_candle.get('rsi_6', 50) + + # # RSI越高，止损越宽松 + # if rsi_short > 70: + # return -0.15 # 更宽松的止损 + # elif rsi_short < 30: + # return -0.05 # 更严格的止损 + # else: + # return self.stoploss # 默认止损 + # else: + # return self.stoploss + # except Exception as e: + # logger.error(f"Error in custom_stoploss: {e}") + # return self.stoploss diff --git a/user_data/strategies/TD.py b/user_data/strategies/TD.py new file mode 100644 index 0000000..1edb058 --- /dev/null +++ b/user_data/strategies/TD.py @@ -0,0 +1,426 @@ +# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement +# flake8: noqa: F401 +# isort: skip_file +# --- Do not remove these imports --- +import numpy as np +import pandas as pd +from datetime import datetime, timedelta, timezone +from pandas import DataFrame, date_range +from typing import Optional, Union + +from freqtrade.strategy import ( + IStrategy, + Trade, + Order, + PairLocks, + informative, # @informative decorator + # Hyperopt Parameters + BooleanParameter, + CategoricalParameter, + DecimalParameter, + IntParameter, + RealParameter, + # timeframe helpers + timeframe_to_minutes, + timeframe_to_next_date, + timeframe_to_prev_date, + # Strategy helper functions + merge_informative_pair, + stoploss_from_absolute, + stoploss_from_open, +) + +# -------------------------------- +# Add your lib to import here +import talib.abstract as ta +from technical import qtpylib + + +# This class is a sample. Feel free to customize it. +class TD(IStrategy): + """ + This is a sample strategy to inspire you. + More information in https://www.freqtrade.io/en/latest/strategy-customization/ + + You can: + :return: a Dataframe with all mandatory indicators for the strategies + - Rename the class name (Do not forget to update class_name) + - Add any methods you want to build your strategy + - Add any lib you need to build your strategy + + You must keep: + - the lib in the section "Do not remove these libs" + - the methods: populate_indicators, populate_entry_trend, populate_exit_trend + You should keep: + - timeframe, minimal_roi, stoploss, trailing_* + """ + + # Strategy interface version - allow new iterations of the strategy interface. + # Check the documentation or the Sample strategy to get the latest version. + INTERFACE_VERSION = 3 + + # Can this strategy go short? + can_short: bool = False + + # Minimal ROI designed for the strategy. + # This attribute will be overridden if the config file contains "minimal_roi". + # minimal_roi = { + # # "120": 0.0, # exit after 120 minutes at break even + # "60": 0.1, + # "30": 0.2, + # "0": 0.4, + # } + + # Optimal stoploss designed for the strategy. + # This attribute will be overridden if the config file contains "stoploss". + stoploss = -1 + + # Trailing stoploss + trailing_stop = False + # trailing_only_offset_is_reached = False + # trailing_stop_positive = 0.01 + # trailing_stop_positive_offset = 0.0 # Disabled / not configured + + # Optimal timeframe for the strategy. + timeframe = "5m" + + # Run "populate_indicators()" only for new candle. + process_only_new_candles = True + + # These values can be overridden in the config. + use_exit_signal = True + exit_profit_only = False + ignore_roi_if_entry_signal = False + + # Hyperoptable parameters + buy_rsi = IntParameter(low=1, high=50, default=30, space="buy", optimize=True, load=True) + sell_rsi = IntParameter(low=50, high=100, default=70, space="sell", optimize=True, load=True) + short_rsi = IntParameter(low=51, high=100, default=70, space="sell", optimize=True, load=True) + exit_short_rsi = IntParameter(low=1, high=50, default=30, space="buy", optimize=True, load=True) + + # Number of candles the strategy requires before producing valid signals + startup_candle_count: int = 200 + + # Optional order type mapping. + order_types = { + "entry": "limit", + "exit": "limit", + "stoploss": "market", + "stoploss_on_exchange": False, + } + + # Optional order time in force. + order_time_in_force = {"entry": "GTC", "exit": "GTC"} + + plot_config = { + "main_plot": { + "tema": {}, + "sar": {"color": "white"} + }, + "subplots": { + "MACD": { + "macd": {"color": "blue"}, + "macdsignal": {"color": "orange"}, + }, + "RSI": { + "rsi": {"color": "red"}, + } + }, + } + + def TD(self, dataframe:DataFrame): + close = dataframe['close'].to_list() + td = [0,0,0,0] + up = 0 + down = 0 + for i in range(4, len(close)): + if close[i] > close[i-4]: + up += 1 + down = 0 + td.append(up) + else: + down -= 1 + up = 0 + td.append(down) + return td + + def informative_pairs(self): + """ + Define additional, informative pair/interval combinations to be cached from the exchange. + These pair/interval combinations are non-tradeable, unless they are part + of the whitelist as well. + For more information, please consult the documentation + :return: List of tuples in the format (pair, interval) + Sample: return [("ETH/USDT", "5m"), + ("BTC/USDT", "15m"), + ] + """ + return [] + + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Adds several different TA indicators to the given DataFrame + + Performance Note: For the best performance be frugal on the number of indicators + you are using. Let uncomment only the indicator you are using in your strategies + or your hyperopt configuration, otherwise you will waste your memory and CPU usage. + :param dataframe: Dataframe with data from the exchange + :param metadata: Additional information, like the currently traded pair + :return: a Dataframe with all mandatory indicators for the strategies + """ + + # Momentum Indicators + # ------------------------------------ + + # ADX + dataframe["adx"] = ta.ADX(dataframe) + + # # Plus Directional Indicator / Movement + # dataframe['plus_dm'] = ta.PLUS_DM(dataframe) + # dataframe['plus_di'] = ta.PLUS_DI(dataframe) + + # # Minus Directional Indicator / Movement + # dataframe['minus_dm'] = ta.MINUS_DM(dataframe) + # dataframe['minus_di'] = ta.MINUS_DI(dataframe) + + # # Aroon, Aroon Oscillator + # aroon = ta.AROON(dataframe) + # dataframe['aroonup'] = aroon['aroonup'] + # dataframe['aroondown'] = aroon['aroondown'] + # dataframe['aroonosc'] = ta.AROONOSC(dataframe) + + # # Awesome Oscillator + # dataframe['ao'] = qtpylib.awesome_oscillator(dataframe) + + # # Keltner Channel + # keltner = qtpylib.keltner_channel(dataframe) + # dataframe["kc_upperband"] = keltner["upper"] + # dataframe["kc_lowerband"] = keltner["lower"] + # dataframe["kc_middleband"] = keltner["mid"] + # dataframe["kc_percent"] = ( + # (dataframe["close"] - dataframe["kc_lowerband"]) / + # (dataframe["kc_upperband"] - dataframe["kc_lowerband"]) + # ) + # dataframe["kc_width"] = ( + # (dataframe["kc_upperband"] - dataframe["kc_lowerband"]) / dataframe["kc_middleband"] + # ) + + # # Ultimate Oscillator + # dataframe['uo'] = ta.ULTOSC(dataframe) + + # # Commodity Channel Index: values [Oversold:-100, Overbought:100] + # dataframe['cci'] = ta.CCI(dataframe) + + # RSI + dataframe["rsi"] = ta.RSI(dataframe) + + # # Inverse Fisher transform on RSI: values [-1.0, 1.0] (https://goo.gl/2JGGoy) + # rsi = 0.1 * (dataframe['rsi'] - 50) + # dataframe['fisher_rsi'] = (np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1) + + # # Inverse Fisher transform on RSI normalized: values [0.0, 100.0] (https://goo.gl/2JGGoy) + # dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1) + + # # Stochastic Slow + # stoch = ta.STOCH(dataframe) + # dataframe['slowd'] = stoch['slowd'] + # dataframe['slowk'] = stoch['slowk'] + + # Stochastic Fast + stoch_fast = ta.STOCHF(dataframe) + dataframe["fastd"] = stoch_fast["fastd"] + dataframe["fastk"] = stoch_fast["fastk"] + + # # Stochastic RSI + # Please read https://github.com/freqtrade/freqtrade/issues/2961 before using this. + # STOCHRSI is NOT aligned with tradingview, which may result in non-expected results. + # stoch_rsi = ta.STOCHRSI(dataframe) + # dataframe['fastd_rsi'] = stoch_rsi['fastd'] + # dataframe['fastk_rsi'] = stoch_rsi['fastk'] + + # MACD + macd = ta.MACD(dataframe) + dataframe["macd"] = macd["macd"] + dataframe["macdsignal"] = macd["macdsignal"] + dataframe["macdhist"] = macd["macdhist"] + + # MFI + dataframe["mfi"] = ta.MFI(dataframe) + + # # ROC + # dataframe['roc'] = ta.ROC(dataframe) + + # Overlap Studies + # ------------------------------------ + + # Bollinger Bands + bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) + dataframe["bb_lowerband"] = bollinger["lower"] + dataframe["bb_middleband"] = bollinger["mid"] + dataframe["bb_upperband"] = bollinger["upper"] + dataframe["bb_percent"] = (dataframe["close"] - dataframe["bb_lowerband"]) / ( + dataframe["bb_upperband"] - dataframe["bb_lowerband"] + ) + dataframe["bb_width"] = (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe[ + "bb_middleband" + ] + + # Bollinger Bands - Weighted (EMA based instead of SMA) + # weighted_bollinger = qtpylib.weighted_bollinger_bands( + # qtpylib.typical_price(dataframe), window=20, stds=2 + # ) + # dataframe["wbb_upperband"] = weighted_bollinger["upper"] + # dataframe["wbb_lowerband"] = weighted_bollinger["lower"] + # dataframe["wbb_middleband"] = weighted_bollinger["mid"] + # dataframe["wbb_percent"] = ( + # (dataframe["close"] - dataframe["wbb_lowerband"]) / + # (dataframe["wbb_upperband"] - dataframe["wbb_lowerband"]) + # ) + # dataframe["wbb_width"] = ( + # (dataframe["wbb_upperband"] - dataframe["wbb_lowerband"]) / + # dataframe["wbb_middleband"] + # ) + + # # EMA - Exponential Moving Average + # dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3) + # dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5) + # dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10) + # dataframe['ema21'] = ta.EMA(dataframe, timeperiod=21) + # dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50) + # dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100) + + # # SMA - Simple Moving Average + dataframe['sma12'] = ta.SMA(dataframe, timeperiod=12) + dataframe['sma26'] = ta.SMA(dataframe, timeperiod=26) + # dataframe['sma10'] = ta.SMA(dataframe, timeperiod=10) + # dataframe['sma21'] = ta.SMA(dataframe, timeperiod=21) + # dataframe['sma50'] = ta.SMA(dataframe, timeperiod=50) + # dataframe['sma100'] = ta.SMA(dataframe, timeperiod=100) + + # CCI + dataframe['cci'] = ta.CCI(dataframe, timeperiod=12) + + # Parabolic SAR + dataframe["sar"] = ta.SAR(dataframe) + + # TEMA - Triple Exponential Moving Average + dataframe["tema"] = ta.TEMA(dataframe, timeperiod=9) + + # Cycle Indicator + # ------------------------------------ + # Hilbert Transform Indicator - SineWave + hilbert = ta.HT_SINE(dataframe) + dataframe["htsine"] = hilbert["sine"] + dataframe["htleadsine"] = hilbert["leadsine"] + + # Pattern Recognition - Bullish candlestick patterns + # ------------------------------------ + # # Hammer: values [0, 100] + # dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe) + # # Inverted Hammer: values [0, 100] + # dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe) + # # Dragonfly Doji: values [0, 100] + # dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe) + # # Piercing Line: values [0, 100] + # dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100] + # # Morningstar: values [0, 100] + # dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100] + # # Three White Soldiers: values [0, 100] + # dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100] + + # Pattern Recognition - Bearish candlestick patterns + # ------------------------------------ + # # Hanging Man: values [0, 100] + # dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe) + # # Shooting Star: values [0, 100] + # dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe) + # # Gravestone Doji: values [0, 100] + # dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe) + # # Dark Cloud Cover: values [0, 100] + # dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe) + # # Evening Doji Star: values [0, 100] + # dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe) + # # Evening Star: values [0, 100] + # dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe) + + # Pattern Recognition - Bullish/Bearish candlestick patterns + # ------------------------------------ + # # Three Line Strike: values [0, -100, 100] + # dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe) + # # Spinning Top: values [0, -100, 100] + # dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100] + # # Engulfing: values [0, -100, 100] + # dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100] + # # Harami: values [0, -100, 100] + # dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100] + # # Three Outside Up/Down: values [0, -100, 100] + # dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100] + # # Three Inside Up/Down: values [0, -100, 100] + # dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100] + + # # Chart type + # # ------------------------------------ + # # Heikin Ashi Strategy + # heikinashi = qtpylib.heikinashi(dataframe) + # dataframe['ha_open'] = heikinashi['open'] + # dataframe['ha_close'] = heikinashi['close'] + # dataframe['ha_high'] = heikinashi['high'] + # dataframe['ha_low'] = heikinashi['low'] + + # Retrieve best bid and best ask from the orderbook + # ------------------------------------ + """ + # first check if dataprovider is available + if self.dp: + if self.dp.runmode.value in ('live', 'dry_run'): + ob = self.dp.orderbook(metadata['pair'], 1) + dataframe['best_bid'] = ob['bids'][0][0] + dataframe['best_ask'] = ob['asks'][0][0] + """ + dataframe['TD'] = self.TD(dataframe) + + return dataframe + + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Based on TA indicators, populates the entry signal for the given dataframe + :param dataframe: DataFrame + :param metadata: Additional information, like the currently traded pair + :return: DataFrame with entry columns populated + """ + dataframe.loc[ + ( + # (qtpylib.crossed_above(dataframe['sma10'], dataframe['sma30'])) & + # (dataframe['sma5'] > dataframe['sma10']) & + # (dataframe['low'] > dataframe['sma5']) + (dataframe['TD'] == 1) + # & + # (dataframe['macd'] > dataframe['macdsignal']) & + # (dataframe['sma12'] > dataframe['sma26']) & + # (dataframe['cci'] < -100) + # (dataframe['low'] <= dataframe['low'].shift(4)) + # (dataframe['sma7'] < dataframe['sma30'])& + # (dataframe['sma30'] < dataframe['sma60']) + ), + 'enter_long'] = 1 + + return dataframe + + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Based on TA indicators, populates the exit signal for the given dataframe + :param dataframe: DataFrame + :param metadata: Additional information, like the currently traded pair + :return: DataFrame with exit columns populated + """ + dataframe.loc[ + ( + # (qtpylib.crossed_below(dataframe['sma10'], dataframe['sma30'])) + (dataframe['TD'] == -1) + # & + # (dataframe['high'] >= dataframe['high'].shift(4)) + ), + 'exit_long'] = 1 + + return dataframe + diff --git a/user_data/strategies/cci_multi_tf_strategy.py b/user_data/strategies/cci_multi_tf_strategy.py new file mode 100644 index 0000000..1ab3db6 --- /dev/null +++ b/user_data/strategies/cci_multi_tf_strategy.py @@ -0,0 +1,134 @@ +# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement +# flake8: noqa: F401 +# isort: skip_file +# --- Do not remove these imports --- +import numpy as np +import pandas as pd +from datetime import datetime, timedelta, timezone +from pandas import DataFrame +from typing import Optional, Union +from freqtrade.strategy import ( + IStrategy, + Trade, + Order, + PairLocks, + informative, # @informative decorator + # Hyperopt Parameters + BooleanParameter, + CategoricalParameter, + DecimalParameter, + IntParameter, + RealParameter, + # timeframe helpers + timeframe_to_minutes, + timeframe_to_next_date, + timeframe_to_prev_date, + # Strategy helper functions + merge_informative_pair, + stoploss_from_absolute, + stoploss_from_open, +) +import logging + +logger = logging.getLogger(__name__) +# -------------------------------- +# Add your lib to import here +import talib.abstract as ta +from technical import qtpylib + + +class CCIMultiTimeframeSpotStrategy(IStrategy): + # 策略参数 + INTERFACE_VERSION = 3 + + minimal_roi = {"0": 100} + stoploss = -1 + trailing_stop = False + timeframe = '4h' + + use_exit_signal = True + exit_profit_only = False + ignore_roi_if_entry_signal = False + + def TD(self, dataframe:DataFrame): + close = dataframe['close'].to_list() + td = [0,0,0,0] + up = 0 + down = 0 + for i in range(4, len(close)): + if close[i] > close[i-4]: + up += 1 + down = 0 + td.append(up) + else: + down -= 1 + up = 0 + td.append(down) + return td + + @informative('1d') + def populate_indicators_1d(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe['cci'] = ta.CCI(dataframe, timeperiod=26) + dataframe["adx"] = ta.ADX(dataframe) + macd = ta.MACD(dataframe, fastperiod=12, slowperiod=26, signalperiod=9,) + dataframe["macd"] = macd["macd"] + dataframe["macdsignal"] = macd["macdsignal"] + dataframe["macdhist"] = macd["macdhist"] + logger.info(dataframe.tail()) + return dataframe + + @informative('1w') + def populate_indicators_1w(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe['cci'] = ta.CCI(dataframe, timeperiod=26) + logger.info(dataframe.tail()) + return dataframe + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # 计算4h CCI + dataframe['cci_4h'] = ta.CCI(dataframe, timeperiod=26) + dataframe['sma12_4h'] = ta.SMA(dataframe, timeperiod=12) + dataframe['sma26_4h'] = ta.SMA(dataframe, timeperiod=26) + dataframe["adx_4h"] = ta.ADX(dataframe) + + macd = ta.MACD(dataframe, fastperiod=12, slowperiod=26, signalperiod=9,) + dataframe["macd_4h"] = macd["macd"] + dataframe["macdsignal_4h"] = macd["macdsignal"] + dataframe["macdhist_4h"] = macd["macdhist"] + + dataframe['cci_hist_4h'] = ta.CCI(dataframe['macdhist_1d'], dataframe['macdhist_1d'], dataframe['macdhist_1d'], timeperiod=26) + + # dataframe['adx_hist_4h'] = ta.ADX(dataframe['macdhist_4h']) + dataframe['TD'] = self.TD(dataframe) + + logger.info(dataframe.tail()) + return dataframe + + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # 入场：1d与4h CCI < -100，且4h CCI上升（当前 > 前一根） + dataframe.loc[ + ( + (dataframe['cci_4h'] < -100) & + (dataframe['cci_1d'] < -100) & + (dataframe['cci_4h'] > dataframe['cci_4h'].shift(1)) & + # (dataframe['macdhist_1d'] < dataframe['macdhist_1d'].shift(1)) & + (dataframe['volume'] > 0) + ), + 'enter_long', + ] = 1 + + return dataframe + + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # 离场：1d与4h CCI > 100，且4h CCI下降（当前 < 前一根） + dataframe.loc[ + ( + (dataframe['cci_4h'] > 100) & + (dataframe['cci_1d'] > 100) & + (dataframe['cci_4h'] < dataframe['cci_4h'].shift(1)) & + # (dataframe['macdhist_1d'] > dataframe['macdhist_1d'].shift(1)) & + (dataframe['volume'] > 0) + ), + 'exit_long', + ] = 1 + + return dataframe + diff --git a/user_data/strategies/sample_strategy.py b/user_data/strategies/sample_strategy.py new file mode 100644 index 0000000..75a0fe3 --- /dev/null +++ b/user_data/strategies/sample_strategy.py @@ -0,0 +1,426 @@ +# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement +# flake8: noqa: F401 +# isort: skip_file +# --- Do not remove these imports --- +import numpy as np +import pandas as pd +from datetime import datetime, timedelta, timezone +from pandas import DataFrame +from typing import Optional, Union + +from freqtrade.strategy import ( + IStrategy, + Trade, + Order, + PairLocks, + informative, # @informative decorator + # Hyperopt Parameters + BooleanParameter, + CategoricalParameter, + DecimalParameter, + IntParameter, + RealParameter, + # timeframe helpers + timeframe_to_minutes, + timeframe_to_next_date, + timeframe_to_prev_date, + # Strategy helper functions + merge_informative_pair, + stoploss_from_absolute, + stoploss_from_open, +) + +# -------------------------------- +# Add your lib to import here +import talib.abstract as ta +from technical import qtpylib + + +# This class is a sample. Feel free to customize it. +class SampleStrategy(IStrategy): + """ + This is a sample strategy to inspire you. + More information in https://www.freqtrade.io/en/latest/strategy-customization/ + + You can: + :return: a Dataframe with all mandatory indicators for the strategies + - Rename the class name (Do not forget to update class_name) + - Add any methods you want to build your strategy + - Add any lib you need to build your strategy + + You must keep: + - the lib in the section "Do not remove these libs" + - the methods: populate_indicators, populate_entry_trend, populate_exit_trend + You should keep: + - timeframe, minimal_roi, stoploss, trailing_* + """ + + # Strategy interface version - allow new iterations of the strategy interface. + # Check the documentation or the Sample strategy to get the latest version. + INTERFACE_VERSION = 3 + + # Can this strategy go short? + can_short: bool = False + + # Minimal ROI designed for the strategy. + # This attribute will be overridden if the config file contains "minimal_roi". + minimal_roi = { + # "120": 0.0, # exit after 120 minutes at break even + "60": 0.01, + "30": 0.02, + "0": 0.04, + } + + # Optimal stoploss designed for the strategy. + # This attribute will be overridden if the config file contains "stoploss". + stoploss = -0.10 + + # Trailing stoploss + trailing_stop = False + # trailing_only_offset_is_reached = False + # trailing_stop_positive = 0.01 + # trailing_stop_positive_offset = 0.0 # Disabled / not configured + + # Optimal timeframe for the strategy. + timeframe = "5m" + + # Run "populate_indicators()" only for new candle. + process_only_new_candles = True + + # These values can be overridden in the config. + use_exit_signal = True + exit_profit_only = False + ignore_roi_if_entry_signal = False + + # Hyperoptable parameters + buy_rsi = IntParameter(low=1, high=50, default=30, space="buy", optimize=True, load=True) + sell_rsi = IntParameter(low=50, high=100, default=70, space="sell", optimize=True, load=True) + short_rsi = IntParameter(low=51, high=100, default=70, space="sell", optimize=True, load=True) + exit_short_rsi = IntParameter(low=1, high=50, default=30, space="buy", optimize=True, load=True) + + # Number of candles the strategy requires before producing valid signals + startup_candle_count: int = 200 + + # Optional order type mapping. + order_types = { + "entry": "limit", + "exit": "limit", + "stoploss": "market", + "stoploss_on_exchange": False, + } + + # Optional order time in force. + order_time_in_force = {"entry": "GTC", "exit": "GTC"} + + plot_config = { + "main_plot": { + "tema": {}, + "sar": {"color": "white"}, + }, + "subplots": { + "MACD": { + "macd": {"color": "blue"}, + "macdsignal": {"color": "orange"}, + }, + "RSI": { + "rsi": {"color": "red"}, + }, + }, + } + + def informative_pairs(self): + """ + Define additional, informative pair/interval combinations to be cached from the exchange. + These pair/interval combinations are non-tradeable, unless they are part + of the whitelist as well. + For more information, please consult the documentation + :return: List of tuples in the format (pair, interval) + Sample: return [("ETH/USDT", "5m"), + ("BTC/USDT", "15m"), + ] + """ + return [] + + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Adds several different TA indicators to the given DataFrame + + Performance Note: For the best performance be frugal on the number of indicators + you are using. Let uncomment only the indicator you are using in your strategies + or your hyperopt configuration, otherwise you will waste your memory and CPU usage. + :param dataframe: Dataframe with data from the exchange + :param metadata: Additional information, like the currently traded pair + :return: a Dataframe with all mandatory indicators for the strategies + """ + + # Momentum Indicators + # ------------------------------------ + + # ADX + dataframe["adx"] = ta.ADX(dataframe) + + # # Plus Directional Indicator / Movement + # dataframe['plus_dm'] = ta.PLUS_DM(dataframe) + # dataframe['plus_di'] = ta.PLUS_DI(dataframe) + + # # Minus Directional Indicator / Movement + # dataframe['minus_dm'] = ta.MINUS_DM(dataframe) + # dataframe['minus_di'] = ta.MINUS_DI(dataframe) + + # # Aroon, Aroon Oscillator + # aroon = ta.AROON(dataframe) + # dataframe['aroonup'] = aroon['aroonup'] + # dataframe['aroondown'] = aroon['aroondown'] + # dataframe['aroonosc'] = ta.AROONOSC(dataframe) + + # # Awesome Oscillator + # dataframe['ao'] = qtpylib.awesome_oscillator(dataframe) + + # # Keltner Channel + # keltner = qtpylib.keltner_channel(dataframe) + # dataframe["kc_upperband"] = keltner["upper"] + # dataframe["kc_lowerband"] = keltner["lower"] + # dataframe["kc_middleband"] = keltner["mid"] + # dataframe["kc_percent"] = ( + # (dataframe["close"] - dataframe["kc_lowerband"]) / + # (dataframe["kc_upperband"] - dataframe["kc_lowerband"]) + # ) + # dataframe["kc_width"] = ( + # (dataframe["kc_upperband"] - dataframe["kc_lowerband"]) / dataframe["kc_middleband"] + # ) + + # # Ultimate Oscillator + # dataframe['uo'] = ta.ULTOSC(dataframe) + + # # Commodity Channel Index: values [Oversold:-100, Overbought:100] + # dataframe['cci'] = ta.CCI(dataframe) + + # RSI + dataframe["rsi"] = ta.RSI(dataframe) + + # # Inverse Fisher transform on RSI: values [-1.0, 1.0] (https://goo.gl/2JGGoy) + # rsi = 0.1 * (dataframe['rsi'] - 50) + # dataframe['fisher_rsi'] = (np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1) + + # # Inverse Fisher transform on RSI normalized: values [0.0, 100.0] (https://goo.gl/2JGGoy) + # dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1) + + # # Stochastic Slow + # stoch = ta.STOCH(dataframe) + # dataframe['slowd'] = stoch['slowd'] + # dataframe['slowk'] = stoch['slowk'] + + # Stochastic Fast + stoch_fast = ta.STOCHF(dataframe) + dataframe["fastd"] = stoch_fast["fastd"] + dataframe["fastk"] = stoch_fast["fastk"] + + # # Stochastic RSI + # Please read https://github.com/freqtrade/freqtrade/issues/2961 before using this. + # STOCHRSI is NOT aligned with tradingview, which may result in non-expected results. + # stoch_rsi = ta.STOCHRSI(dataframe) + # dataframe['fastd_rsi'] = stoch_rsi['fastd'] + # dataframe['fastk_rsi'] = stoch_rsi['fastk'] + + # MACD + macd = ta.MACD(dataframe) + dataframe["macd"] = macd["macd"] + dataframe["macdsignal"] = macd["macdsignal"] + dataframe["macdhist"] = macd["macdhist"] + + # MFI + dataframe["mfi"] = ta.MFI(dataframe) + + # # ROC + # dataframe['roc'] = ta.ROC(dataframe) + + # Overlap Studies + # ------------------------------------ + + # Bollinger Bands + bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) + dataframe["bb_lowerband"] = bollinger["lower"] + dataframe["bb_middleband"] = bollinger["mid"] + dataframe["bb_upperband"] = bollinger["upper"] + dataframe["bb_percent"] = (dataframe["close"] - dataframe["bb_lowerband"]) / ( + dataframe["bb_upperband"] - dataframe["bb_lowerband"] + ) + dataframe["bb_width"] = (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe[ + "bb_middleband" + ] + + # Bollinger Bands - Weighted (EMA based instead of SMA) + # weighted_bollinger = qtpylib.weighted_bollinger_bands( + # qtpylib.typical_price(dataframe), window=20, stds=2 + # ) + # dataframe["wbb_upperband"] = weighted_bollinger["upper"] + # dataframe["wbb_lowerband"] = weighted_bollinger["lower"] + # dataframe["wbb_middleband"] = weighted_bollinger["mid"] + # dataframe["wbb_percent"] = ( + # (dataframe["close"] - dataframe["wbb_lowerband"]) / + # (dataframe["wbb_upperband"] - dataframe["wbb_lowerband"]) + # ) + # dataframe["wbb_width"] = ( + # (dataframe["wbb_upperband"] - dataframe["wbb_lowerband"]) / + # dataframe["wbb_middleband"] + # ) + + # # EMA - Exponential Moving Average + # dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3) + # dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5) + # dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10) + # dataframe['ema21'] = ta.EMA(dataframe, timeperiod=21) + # dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50) + # dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100) + + # # SMA - Simple Moving Average + # dataframe['sma3'] = ta.SMA(dataframe, timeperiod=3) + # dataframe['sma5'] = ta.SMA(dataframe, timeperiod=5) + # dataframe['sma10'] = ta.SMA(dataframe, timeperiod=10) + # dataframe['sma21'] = ta.SMA(dataframe, timeperiod=21) + # dataframe['sma50'] = ta.SMA(dataframe, timeperiod=50) + # dataframe['sma100'] = ta.SMA(dataframe, timeperiod=100) + + # Parabolic SAR + dataframe["sar"] = ta.SAR(dataframe) + + # TEMA - Triple Exponential Moving Average + dataframe["tema"] = ta.TEMA(dataframe, timeperiod=9) + + # Cycle Indicator + # ------------------------------------ + # Hilbert Transform Indicator - SineWave + hilbert = ta.HT_SINE(dataframe) + dataframe["htsine"] = hilbert["sine"] + dataframe["htleadsine"] = hilbert["leadsine"] + + # Pattern Recognition - Bullish candlestick patterns + # ------------------------------------ + # # Hammer: values [0, 100] + # dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe) + # # Inverted Hammer: values [0, 100] + # dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe) + # # Dragonfly Doji: values [0, 100] + # dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe) + # # Piercing Line: values [0, 100] + # dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100] + # # Morningstar: values [0, 100] + # dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100] + # # Three White Soldiers: values [0, 100] + # dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100] + + # Pattern Recognition - Bearish candlestick patterns + # ------------------------------------ + # # Hanging Man: values [0, 100] + # dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe) + # # Shooting Star: values [0, 100] + # dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe) + # # Gravestone Doji: values [0, 100] + # dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe) + # # Dark Cloud Cover: values [0, 100] + # dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe) + # # Evening Doji Star: values [0, 100] + # dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe) + # # Evening Star: values [0, 100] + # dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe) + + # Pattern Recognition - Bullish/Bearish candlestick patterns + # ------------------------------------ + # # Three Line Strike: values [0, -100, 100] + # dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe) + # # Spinning Top: values [0, -100, 100] + # dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100] + # # Engulfing: values [0, -100, 100] + # dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100] + # # Harami: values [0, -100, 100] + # dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100] + # # Three Outside Up/Down: values [0, -100, 100] + # dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100] + # # Three Inside Up/Down: values [0, -100, 100] + # dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100] + + # # Chart type + # # ------------------------------------ + # # Heikin Ashi Strategy + # heikinashi = qtpylib.heikinashi(dataframe) + # dataframe['ha_open'] = heikinashi['open'] + # dataframe['ha_close'] = heikinashi['close'] + # dataframe['ha_high'] = heikinashi['high'] + # dataframe['ha_low'] = heikinashi['low'] + + # Retrieve best bid and best ask from the orderbook + # ------------------------------------ + """ + # first check if dataprovider is available + if self.dp: + if self.dp.runmode.value in ('live', 'dry_run'): + ob = self.dp.orderbook(metadata['pair'], 1) + dataframe['best_bid'] = ob['bids'][0][0] + dataframe['best_ask'] = ob['asks'][0][0] + """ + + return dataframe + + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Based on TA indicators, populates the entry signal for the given dataframe + :param dataframe: DataFrame + :param metadata: Additional information, like the currently traded pair + :return: DataFrame with entry columns populated + """ + dataframe.loc[ + ( + # Signal: RSI crosses above 30 + (qtpylib.crossed_above(dataframe["rsi"], self.buy_rsi.value)) + & (dataframe["tema"] <= dataframe["bb_middleband"]) # Guard: tema below BB middle + & (dataframe["tema"] > dataframe["tema"].shift(1)) # Guard: tema is raising + & (dataframe["volume"] > 0) # Make sure Volume is not 0 + ), + "enter_long", + ] = 1 + + dataframe.loc[ + ( + # Signal: RSI crosses above 70 + (qtpylib.crossed_above(dataframe["rsi"], self.short_rsi.value)) + & (dataframe["tema"] > dataframe["bb_middleband"]) # Guard: tema above BB middle + & (dataframe["tema"] < dataframe["tema"].shift(1)) # Guard: tema is falling + & (dataframe["volume"] > 0) # Make sure Volume is not 0 + ), + "enter_short", + ] = 1 + + return dataframe + + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + """ + Based on TA indicators, populates the exit signal for the given dataframe + :param dataframe: DataFrame + :param metadata: Additional information, like the currently traded pair + :return: DataFrame with exit columns populated + """ + dataframe.loc[ + ( + # Signal: RSI crosses above 70 + (qtpylib.crossed_above(dataframe["rsi"], self.sell_rsi.value)) + & (dataframe["tema"] > dataframe["bb_middleband"]) # Guard: tema above BB middle + & (dataframe["tema"] < dataframe["tema"].shift(1)) # Guard: tema is falling + & (dataframe["volume"] > 0) # Make sure Volume is not 0 + ), + "exit_long", + ] = 1 + + dataframe.loc[ + ( + # Signal: RSI crosses above 30 + (qtpylib.crossed_above(dataframe["rsi"], self.exit_short_rsi.value)) + & + # Guard: tema below BB middle + (dataframe["tema"] <= dataframe["bb_middleband"]) + & (dataframe["tema"] > dataframe["tema"].shift(1)) # Guard: tema is raising + & (dataframe["volume"] > 0) # Make sure Volume is not 0 + ), + "exit_short", + ] = 1 + + return dataframe