aszer/cta
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
aszerW
2025-10-11 19:05:42 +08:00
commit 6fc10484d2
11 changed files with 2359 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
user_data/config.json Normal file
View File

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

57
user_data/hyperopts/sample_hyperopt_loss.py Normal file
View File

@@ -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

480
user_data/notebooks/strategy_analysis_example.ipynb Normal file
View File

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

116
user_data/strategies/MACDStrategy.py Normal file
View File

@@ -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

331
user_data/strategies/SimpleRSIStrategy_Fixed.py Normal file
View File

@@ -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

426
user_data/strategies/TD.py Normal file
View File

@@ -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

134
user_data/strategies/cci_multi_tf_strategy.py Normal file
View File

@@ -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

426
user_data/strategies/sample_strategy.py Normal file
View File

@@ -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