init

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

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

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())
+
+

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
+    }
+
+}

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

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
+}

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
+

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

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
+

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
+

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