TIANHE
2868 lines
146 KiB
Python
2868 lines
146 KiB
Python
"""
|
||
回测服务
|
||
"""
|
||
import math
|
||
import traceback
|
||
from datetime import datetime, timedelta
|
||
from typing import Dict, List, Any, Optional
|
||
|
||
import pandas as pd
|
||
import numpy as np
|
||
|
||
from app.data_sources import DataSourceFactory
|
||
from app.utils.logger import get_logger
|
||
|
||
logger = get_logger(__name__)
|
||
|
||
|
||
class BacktestService:
|
||
"""回测服务"""
|
||
|
||
# 时间周期秒数
|
||
TIMEFRAME_SECONDS = {
|
||
'1m': 60, '5m': 300, '15m': 900, '30m': 1800,
|
||
'1H': 3600, '4H': 14400, '1D': 86400, '1W': 604800
|
||
}
|
||
|
||
def run_code_strategy(
|
||
self,
|
||
code: str,
|
||
symbol: str,
|
||
timeframe: str,
|
||
limit: int = 1000
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
运行策略代码并返回代码中定义的 'output' 变量。
|
||
用于信号机器人的预览功能。
|
||
"""
|
||
# 1. 计算时间范围
|
||
end_date = datetime.now()
|
||
tf_seconds = self.TIMEFRAME_SECONDS.get(timeframe, 3600)
|
||
start_date = end_date - timedelta(seconds=tf_seconds * limit)
|
||
|
||
# 2. 获取数据 (假设 market='crypto'，后续可优化)
|
||
df = self._fetch_kline_data('crypto', symbol, timeframe, start_date, end_date)
|
||
|
||
if df.empty:
|
||
return {"error": "No data found"}
|
||
|
||
# 3. 准备执行环境
|
||
local_vars = {
|
||
'df': df.copy(),
|
||
'np': np,
|
||
'pd': pd,
|
||
'output': {} # 默认空输出
|
||
}
|
||
|
||
# 4. 执行代码
|
||
try:
|
||
import builtins
|
||
def safe_import(name, *args, **kwargs):
|
||
allowed = ['numpy', 'pandas', 'math', 'json', 'datetime', 'time']
|
||
if name in allowed or name.split('.')[0] in allowed:
|
||
return builtins.__import__(name, *args, **kwargs)
|
||
raise ImportError(f"Import not allowed: {name}")
|
||
|
||
safe_builtins = {k: getattr(builtins, k) for k in dir(builtins)
|
||
if not k.startswith('_') and k not in ['eval', 'exec', 'compile', 'open', 'input', 'exit']}
|
||
safe_builtins['__import__'] = safe_import
|
||
|
||
exec_env = local_vars.copy()
|
||
exec_env['__builtins__'] = safe_builtins
|
||
|
||
exec(code, exec_env)
|
||
|
||
return exec_env.get('output', {})
|
||
|
||
except Exception as e:
|
||
logger.error(f"Strategy execution failed: {e}")
|
||
logger.error(traceback.format_exc())
|
||
return {"error": str(e)}
|
||
|
||
def run(
|
||
self,
|
||
indicator_code: str,
|
||
market: str,
|
||
symbol: str,
|
||
timeframe: str,
|
||
start_date: datetime,
|
||
end_date: datetime,
|
||
initial_capital: float = 10000.0,
|
||
commission: float = 0.001,
|
||
slippage: float = 0.0, # 理想回测环境，不考虑滑点
|
||
leverage: int = 1,
|
||
trade_direction: str = 'long',
|
||
strategy_config: Optional[Dict[str, Any]] = None
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
运行回测
|
||
|
||
Args:
|
||
indicator_code: 指标代码
|
||
market: 市场类型
|
||
symbol: 交易标的
|
||
timeframe: 时间周期
|
||
start_date: 开始日期
|
||
end_date: 结束日期
|
||
initial_capital: 初始资金
|
||
commission: 手续费率
|
||
slippage: 滑点
|
||
|
||
Returns:
|
||
回测结果
|
||
"""
|
||
|
||
# 1. 获取K线数据
|
||
df = self._fetch_kline_data(market, symbol, timeframe, start_date, end_date)
|
||
if df.empty:
|
||
raise ValueError("回测日期范围内没有K线数据")
|
||
|
||
|
||
# 2. 执行指标代码获取信号（传入回测参数）
|
||
backtest_params = {
|
||
'leverage': leverage,
|
||
'initial_capital': initial_capital,
|
||
'commission': commission,
|
||
'trade_direction': trade_direction
|
||
}
|
||
signals = self._execute_indicator(indicator_code, df, backtest_params)
|
||
|
||
# 3. 模拟交易
|
||
equity_curve, trades, total_commission = self._simulate_trading(
|
||
df, signals, initial_capital, commission, slippage, leverage, trade_direction, strategy_config
|
||
)
|
||
|
||
# 4. 计算指标
|
||
metrics = self._calculate_metrics(equity_curve, trades, initial_capital, timeframe, start_date, end_date, total_commission)
|
||
|
||
# 5. 格式化结果
|
||
return self._format_result(metrics, equity_curve, trades)
|
||
|
||
def _fetch_kline_data(
|
||
self,
|
||
market: str,
|
||
symbol: str,
|
||
timeframe: str,
|
||
start_date: datetime,
|
||
end_date: datetime
|
||
) -> pd.DataFrame:
|
||
"""获取K线数据并转换为DataFrame"""
|
||
# 计算需要的K线数量
|
||
total_seconds = (end_date - start_date).total_seconds()
|
||
tf_seconds = self.TIMEFRAME_SECONDS.get(timeframe, 86400)
|
||
limit = math.ceil(total_seconds / tf_seconds) + 200
|
||
|
||
# 计算before_time（结束日期+1天）
|
||
before_time = int((end_date + timedelta(days=1)).timestamp())
|
||
|
||
|
||
# 获取数据
|
||
kline_data = DataSourceFactory.get_kline(
|
||
market=market,
|
||
symbol=symbol,
|
||
timeframe=timeframe,
|
||
limit=limit,
|
||
before_time=before_time
|
||
)
|
||
|
||
if not kline_data:
|
||
logger.warning("未获取到K线数据")
|
||
return pd.DataFrame()
|
||
|
||
if kline_data:
|
||
first_time = datetime.fromtimestamp(kline_data[0]['time'])
|
||
last_time = datetime.fromtimestamp(kline_data[-1]['time'])
|
||
|
||
# 转换为DataFrame
|
||
df = pd.DataFrame(kline_data)
|
||
df['time'] = pd.to_datetime(df['time'], unit='s')
|
||
df = df.set_index('time')
|
||
|
||
if len(df) > 0:
|
||
pass
|
||
|
||
# 过滤日期范围
|
||
df = df[(df.index >= start_date) & (df.index <= end_date)].copy()
|
||
|
||
if len(df) > 0:
|
||
pass
|
||
|
||
return df
|
||
|
||
def _execute_indicator(self, code: str, df: pd.DataFrame, backtest_params: dict = None):
|
||
"""执行指标代码获取信号
|
||
|
||
Args:
|
||
code: 指标代码
|
||
df: K线数据
|
||
backtest_params: 回测参数字典（leverage, initial_capital, commission, trade_direction）
|
||
"""
|
||
# Supported indicator signal formats:
|
||
# - Preferred (simple): df['buy'], df['sell'] as boolean
|
||
# - Backtest/internal (4-way): df['open_long'], df['close_long'], df['open_short'], df['close_short'] as boolean
|
||
signals = pd.Series(0, index=df.index)
|
||
|
||
try:
|
||
# 准备执行环境
|
||
local_vars = {
|
||
'df': df.copy(),
|
||
'open': df['open'],
|
||
'high': df['high'],
|
||
'low': df['low'],
|
||
'close': df['close'],
|
||
'volume': df['volume'],
|
||
'signals': signals,
|
||
'np': np,
|
||
'pd': pd,
|
||
}
|
||
|
||
# 添加回测参数到执行环境（如果提供了）
|
||
if backtest_params:
|
||
local_vars['backtest_params'] = backtest_params
|
||
local_vars['leverage'] = backtest_params.get('leverage', 1)
|
||
local_vars['initial_capital'] = backtest_params.get('initial_capital', 10000)
|
||
local_vars['commission'] = backtest_params.get('commission', 0.0002)
|
||
local_vars['trade_direction'] = backtest_params.get('trade_direction', 'both')
|
||
|
||
# 添加技术指标函数
|
||
local_vars.update(self._get_indicator_functions())
|
||
|
||
# 添加安全的内置函数（保留完整的 builtins 以支持 lambda 等语法）
|
||
# 但移除危险的函数如 eval, exec, open 等
|
||
import builtins
|
||
|
||
# 创建受限的 __import__ 函数，只允许导入已经加载的安全模块
|
||
def safe_import(name, *args, **kwargs):
|
||
"""只允许导入 numpy, pandas, math, json 等安全模块"""
|
||
allowed_modules = ['numpy', 'pandas', 'math', 'json', 'datetime', 'time']
|
||
if name in allowed_modules or name.split('.')[0] in allowed_modules:
|
||
return builtins.__import__(name, *args, **kwargs)
|
||
raise ImportError(f"不允许导入模块: {name}")
|
||
|
||
safe_builtins = {k: getattr(builtins, k) for k in dir(builtins)
|
||
if not k.startswith('_') and k not in [
|
||
'eval', 'exec', 'compile', 'open', 'input',
|
||
'help', 'exit', 'quit',
|
||
'copyright', 'credits', 'license'
|
||
]}
|
||
|
||
# 添加受限的 __import__
|
||
safe_builtins['__import__'] = safe_import
|
||
|
||
# 创建统一的执行环境（globals 和 locals 使用同一个字典）
|
||
# 这样函数内部才能访问到 np, pd 等变量
|
||
exec_env = local_vars.copy()
|
||
exec_env['__builtins__'] = safe_builtins
|
||
|
||
# 预执行 import 语句，确保 np 和 pd 可用
|
||
pre_import_code = """
|
||
import numpy as np
|
||
import pandas as pd
|
||
"""
|
||
exec(pre_import_code, exec_env)
|
||
|
||
# 安全检查：验证代码不包含危险操作
|
||
from app.utils.safe_exec import validate_code_safety
|
||
is_safe, error_msg = validate_code_safety(code)
|
||
if not is_safe:
|
||
logger.error(f"回测代码安全检查失败: {error_msg}")
|
||
raise ValueError(f"代码包含不安全操作: {error_msg}")
|
||
|
||
# 安全执行用户代码（带超时）
|
||
from app.utils.safe_exec import safe_exec_code
|
||
exec_result = safe_exec_code(
|
||
code=code,
|
||
exec_globals=exec_env,
|
||
exec_locals=exec_env,
|
||
timeout=60 # 回测允许更长时间（60秒）
|
||
)
|
||
|
||
if not exec_result['success']:
|
||
raise RuntimeError(f"代码执行失败: {exec_result['error']}")
|
||
|
||
# Get the executed df
|
||
executed_df = exec_env.get('df', df)
|
||
|
||
# Validation: if chart signals are provided, df['buy']/df['sell'] must exist for backtest normalization.
|
||
# This keeps indicator scripts simple and consistent (chart=buy/sell, execution=normalized in backend).
|
||
output_obj = exec_env.get('output')
|
||
has_output_signals = isinstance(output_obj, dict) and isinstance(output_obj.get('signals'), list) and len(output_obj.get('signals')) > 0
|
||
if has_output_signals and not all(col in executed_df.columns for col in ['buy', 'sell']):
|
||
raise ValueError(
|
||
"Invalid indicator script: output['signals'] is provided, but df['buy'] and df['sell'] are missing. "
|
||
"Please set df['buy'] and df['sell'] as boolean columns (len == len(df))."
|
||
)
|
||
|
||
# Extract signals from executed df
|
||
if all(col in executed_df.columns for col in ['open_long', 'close_long', 'open_short', 'close_short']):
|
||
|
||
signals = {
|
||
'open_long': executed_df['open_long'].fillna(False).astype(bool),
|
||
'close_long': executed_df['close_long'].fillna(False).astype(bool),
|
||
'open_short': executed_df['open_short'].fillna(False).astype(bool),
|
||
'close_short': executed_df['close_short'].fillna(False).astype(bool)
|
||
}
|
||
|
||
# Convention: backtest uses 4-way signals only.
|
||
# Position sizing, TP/SL, trailing, etc must be handled by strategy_config / strategy logic.
|
||
elif all(col in executed_df.columns for col in ['buy', 'sell']):
|
||
# Simple buy/sell signals (recommended for indicator authors)
|
||
signals = {
|
||
'buy': executed_df['buy'].fillna(False).astype(bool),
|
||
'sell': executed_df['sell'].fillna(False).astype(bool)
|
||
}
|
||
|
||
else:
|
||
raise ValueError(
|
||
"Indicator must define either 4-way columns "
|
||
"(df['open_long'], df['close_long'], df['open_short'], df['close_short']) "
|
||
"or simple columns (df['buy'], df['sell'])."
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.error(f"指标代码执行错误: {e}")
|
||
logger.error(traceback.format_exc())
|
||
|
||
return signals
|
||
|
||
def _get_indicator_functions(self) -> Dict:
|
||
"""获取技术指标函数"""
|
||
def SMA(series, period):
|
||
return series.rolling(window=period).mean()
|
||
|
||
def EMA(series, period):
|
||
return series.ewm(span=period, adjust=False).mean()
|
||
|
||
def RSI(series, period=14):
|
||
delta = series.diff()
|
||
gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
|
||
loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
|
||
rs = gain / loss
|
||
return 100 - (100 / (1 + rs))
|
||
|
||
def MACD(series, fast=12, slow=26, signal=9):
|
||
exp1 = series.ewm(span=fast, adjust=False).mean()
|
||
exp2 = series.ewm(span=slow, adjust=False).mean()
|
||
macd = exp1 - exp2
|
||
macd_signal = macd.ewm(span=signal, adjust=False).mean()
|
||
macd_hist = macd - macd_signal
|
||
return macd, macd_signal, macd_hist
|
||
|
||
def BOLL(series, period=20, std_dev=2):
|
||
middle = series.rolling(window=period).mean()
|
||
std = series.rolling(window=period).std()
|
||
upper = middle + std_dev * std
|
||
lower = middle - std_dev * std
|
||
return upper, middle, lower
|
||
|
||
def ATR(high, low, close, period=14):
|
||
tr1 = high - low
|
||
tr2 = abs(high - close.shift())
|
||
tr3 = abs(low - close.shift())
|
||
tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
|
||
return tr.rolling(window=period).mean()
|
||
|
||
def CROSSOVER(series1, series2):
|
||
return (series1 > series2) & (series1.shift(1) <= series2.shift(1))
|
||
|
||
def CROSSUNDER(series1, series2):
|
||
return (series1 < series2) & (series1.shift(1) >= series2.shift(1))
|
||
|
||
return {
|
||
'SMA': SMA,
|
||
'EMA': EMA,
|
||
'RSI': RSI,
|
||
'MACD': MACD,
|
||
'BOLL': BOLL,
|
||
'ATR': ATR,
|
||
'CROSSOVER': CROSSOVER,
|
||
'CROSSUNDER': CROSSUNDER,
|
||
}
|
||
|
||
def _simulate_trading(
|
||
self,
|
||
df: pd.DataFrame,
|
||
signals,
|
||
initial_capital: float,
|
||
commission: float,
|
||
slippage: float,
|
||
leverage: int = 1,
|
||
trade_direction: str = 'long',
|
||
strategy_config: Optional[Dict[str, Any]] = None
|
||
) -> tuple:
|
||
"""
|
||
模拟交易
|
||
|
||
Args:
|
||
signals: 信号，可以是 pd.Series (旧格式) 或 dict (新格式四种信号)
|
||
trade_direction: 交易方向
|
||
- 'long': 只做多 (buy->sell)
|
||
- 'short': 只做空 (sell->buy, 收益反向)
|
||
- 'both': 双向 (buy->sell做多 + sell->buy做空)
|
||
"""
|
||
# Normalize supported signal formats into 4-way signals.
|
||
if not isinstance(signals, dict):
|
||
raise ValueError("signals must be a dict (either 4-way or buy/sell).")
|
||
|
||
if all(k in signals for k in ['open_long', 'close_long', 'open_short', 'close_short']):
|
||
norm = signals
|
||
elif all(k in signals for k in ['buy', 'sell']):
|
||
buy = signals['buy'].fillna(False).astype(bool)
|
||
sell = signals['sell'].fillna(False).astype(bool)
|
||
|
||
td = (trade_direction or 'both')
|
||
td = str(td).lower()
|
||
if td not in ['long', 'short', 'both']:
|
||
td = 'both'
|
||
|
||
# Mapping rules:
|
||
# - long: buy=open_long, sell=close_long
|
||
# - short: sell=open_short, buy=close_short
|
||
# - both: buy=open_long+close_short, sell=open_short+close_long
|
||
if td == 'long':
|
||
norm = {
|
||
'open_long': buy,
|
||
'close_long': sell,
|
||
'open_short': pd.Series([False] * len(df), index=df.index),
|
||
'close_short': pd.Series([False] * len(df), index=df.index),
|
||
}
|
||
elif td == 'short':
|
||
norm = {
|
||
'open_long': pd.Series([False] * len(df), index=df.index),
|
||
'close_long': pd.Series([False] * len(df), index=df.index),
|
||
'open_short': sell,
|
||
'close_short': buy,
|
||
}
|
||
else:
|
||
norm = {
|
||
'open_long': buy,
|
||
'close_long': sell,
|
||
'open_short': sell,
|
||
'close_short': buy,
|
||
}
|
||
else:
|
||
raise ValueError("signals dict must contain either 4-way keys or buy/sell keys.")
|
||
|
||
return self._simulate_trading_new_format(df, norm, initial_capital, commission, slippage, leverage, trade_direction, strategy_config)
|
||
|
||
def _simulate_trading_new_format(
|
||
self,
|
||
df: pd.DataFrame,
|
||
signals: dict,
|
||
initial_capital: float,
|
||
commission: float,
|
||
slippage: float,
|
||
leverage: int = 1,
|
||
trade_direction: str = 'both',
|
||
strategy_config: Optional[Dict[str, Any]] = None
|
||
) -> tuple:
|
||
"""
|
||
使用新格式四种信号进行交易模拟（支持仓位管理和加仓）
|
||
|
||
Args:
|
||
trade_direction: 交易方向 ('long', 'short', 'both')
|
||
"""
|
||
equity_curve = []
|
||
trades = []
|
||
total_commission_paid = 0
|
||
is_liquidated = False
|
||
liquidation_price = 0
|
||
min_capital_to_trade = 1.0 # 余额低于该值则视为赔光，不再开新单
|
||
|
||
capital = initial_capital
|
||
position = 0 # 正数=多头持仓，负数=空头持仓
|
||
entry_price = 0 # 平均开仓价格
|
||
position_type = None # 'long' or 'short'
|
||
|
||
# 仓位管理相关
|
||
has_position_management = 'add_long' in signals and 'add_short' in signals
|
||
position_batches = [] # 存储每批持仓：[{'price': xxx, 'amount': xxx}, ...]
|
||
|
||
# --- Strategy config: signals + parameters = strategy (sent from BacktestModal as strategyConfig) ---
|
||
cfg = strategy_config or {}
|
||
exec_cfg = cfg.get('execution') or {}
|
||
# Signal confirmation / execution timing:
|
||
# - bar_close: execute on the same bar close (more aggressive)
|
||
# - next_bar_open: execute on next bar open after signal is confirmed on bar close (recommended, closer to live)
|
||
signal_timing = str(exec_cfg.get('signalTiming') or 'next_bar_open').strip().lower()
|
||
risk_cfg = cfg.get('risk') or {}
|
||
stop_loss_pct = float(risk_cfg.get('stopLossPct') or 0.0)
|
||
take_profit_pct = float(risk_cfg.get('takeProfitPct') or 0.0)
|
||
trailing_cfg = risk_cfg.get('trailing') or {}
|
||
trailing_enabled = bool(trailing_cfg.get('enabled'))
|
||
trailing_pct = float(trailing_cfg.get('pct') or 0.0)
|
||
trailing_activation_pct = float(trailing_cfg.get('activationPct') or 0.0)
|
||
|
||
# Risk percentages are defined on margin PnL; convert to price move thresholds by leverage.
|
||
lev = max(int(leverage or 1), 1)
|
||
stop_loss_pct_eff = stop_loss_pct / lev
|
||
take_profit_pct_eff = take_profit_pct / lev
|
||
trailing_pct_eff = trailing_pct / lev
|
||
trailing_activation_pct_eff = trailing_activation_pct / lev
|
||
|
||
# Conflict rule (TP vs trailing):
|
||
# - If trailing is enabled, it takes precedence.
|
||
# - If activationPct is not provided, reuse takeProfitPct as the trailing activation threshold.
|
||
# - When trailing is enabled, fixed take-profit exits are disabled to avoid ambiguity.
|
||
if trailing_enabled and trailing_pct_eff > 0:
|
||
if trailing_activation_pct_eff <= 0 and take_profit_pct_eff > 0:
|
||
trailing_activation_pct_eff = take_profit_pct_eff
|
||
|
||
# IMPORTANT: risk percentages are defined on margin PnL (user expectation):
|
||
# e.g. 10x leverage + 5% SL means ~0.5% adverse price move.
|
||
lev = max(int(leverage or 1), 1)
|
||
stop_loss_pct_eff = stop_loss_pct / lev
|
||
take_profit_pct_eff = take_profit_pct / lev
|
||
trailing_pct_eff = trailing_pct / lev
|
||
trailing_activation_pct_eff = trailing_activation_pct / lev
|
||
|
||
pos_cfg = cfg.get('position') or {}
|
||
entry_pct_cfg = float(pos_cfg.get('entryPct') or 1.0) # expected 0~1
|
||
# Accept both 0~1 and 0~100 inputs (some clients may send percent units).
|
||
if entry_pct_cfg > 1:
|
||
entry_pct_cfg = entry_pct_cfg / 100.0
|
||
entry_pct_cfg = max(0.0, min(entry_pct_cfg, 1.0))
|
||
|
||
scale_cfg = cfg.get('scale') or {}
|
||
trend_add_cfg = scale_cfg.get('trendAdd') or {}
|
||
dca_add_cfg = scale_cfg.get('dcaAdd') or {}
|
||
trend_reduce_cfg = scale_cfg.get('trendReduce') or {}
|
||
adverse_reduce_cfg = scale_cfg.get('adverseReduce') or {}
|
||
|
||
trend_add_enabled = bool(trend_add_cfg.get('enabled'))
|
||
trend_add_step_pct = float(trend_add_cfg.get('stepPct') or 0.0)
|
||
trend_add_size_pct = float(trend_add_cfg.get('sizePct') or 0.0)
|
||
trend_add_max_times = int(trend_add_cfg.get('maxTimes') or 0)
|
||
|
||
dca_add_enabled = bool(dca_add_cfg.get('enabled'))
|
||
dca_add_step_pct = float(dca_add_cfg.get('stepPct') or 0.0)
|
||
dca_add_size_pct = float(dca_add_cfg.get('sizePct') or 0.0)
|
||
dca_add_max_times = int(dca_add_cfg.get('maxTimes') or 0)
|
||
|
||
# Prevent logical conflict: trend scale-in and mean-reversion scale-in should not run together.
|
||
# Otherwise both may trigger in the same candle (high/low both hit), causing double scaling unexpectedly.
|
||
if trend_add_enabled and dca_add_enabled:
|
||
dca_add_enabled = False
|
||
|
||
trend_reduce_enabled = bool(trend_reduce_cfg.get('enabled'))
|
||
trend_reduce_step_pct = float(trend_reduce_cfg.get('stepPct') or 0.0)
|
||
trend_reduce_size_pct = float(trend_reduce_cfg.get('sizePct') or 0.0)
|
||
trend_reduce_max_times = int(trend_reduce_cfg.get('maxTimes') or 0)
|
||
|
||
adverse_reduce_enabled = bool(adverse_reduce_cfg.get('enabled'))
|
||
adverse_reduce_step_pct = float(adverse_reduce_cfg.get('stepPct') or 0.0)
|
||
adverse_reduce_size_pct = float(adverse_reduce_cfg.get('sizePct') or 0.0)
|
||
adverse_reduce_max_times = int(adverse_reduce_cfg.get('maxTimes') or 0)
|
||
|
||
# 触发百分比按“杠杆后的保证金阈值”理解：换算为价格触发阈值需要除以杠杆倍数
|
||
# 例如 10x + 5% 触发，意味着约 0.5% 的价格波动触发
|
||
trend_add_step_pct_eff = trend_add_step_pct / lev
|
||
dca_add_step_pct_eff = dca_add_step_pct / lev
|
||
trend_reduce_step_pct_eff = trend_reduce_step_pct / lev
|
||
adverse_reduce_step_pct_eff = adverse_reduce_step_pct / lev
|
||
|
||
# State: used for trailing exits and scale-in/scale-out anchor levels
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
trend_add_times = 0
|
||
dca_add_times = 0
|
||
trend_reduce_times = 0
|
||
adverse_reduce_times = 0
|
||
last_trend_add_anchor = None
|
||
last_dca_add_anchor = None
|
||
last_trend_reduce_anchor = None
|
||
last_adverse_reduce_anchor = None
|
||
|
||
# 转换信号为数组
|
||
open_long_arr = signals['open_long'].values
|
||
close_long_arr = signals['close_long'].values
|
||
open_short_arr = signals['open_short'].values
|
||
close_short_arr = signals['close_short'].values
|
||
|
||
# Apply execution timing to avoid look-ahead bias:
|
||
# If signals are computed using bar close, realistic execution is next bar open.
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
open_long_arr = np.insert(open_long_arr[:-1], 0, False)
|
||
close_long_arr = np.insert(close_long_arr[:-1], 0, False)
|
||
open_short_arr = np.insert(open_short_arr[:-1], 0, False)
|
||
close_short_arr = np.insert(close_short_arr[:-1], 0, False)
|
||
|
||
# 根据交易方向过滤信号
|
||
if trade_direction == 'long':
|
||
# 只做多：禁用所有做空信号
|
||
open_short_arr = np.zeros(len(df), dtype=bool)
|
||
close_short_arr = np.zeros(len(df), dtype=bool)
|
||
elif trade_direction == 'short':
|
||
# 只做空：禁用所有做多信号
|
||
open_long_arr = np.zeros(len(df), dtype=bool)
|
||
close_long_arr = np.zeros(len(df), dtype=bool)
|
||
else:
|
||
pass
|
||
|
||
# 加仓信号
|
||
if has_position_management:
|
||
add_long_arr = signals['add_long'].values
|
||
add_short_arr = signals['add_short'].values
|
||
position_size_arr = signals.get('position_size', pd.Series([0.0] * len(df))).values
|
||
|
||
# 根据交易方向过滤加仓信号
|
||
if trade_direction == 'long':
|
||
add_short_arr = np.zeros(len(df), dtype=bool)
|
||
elif trade_direction == 'short':
|
||
add_long_arr = np.zeros(len(df), dtype=bool)
|
||
|
||
# 开仓触发价格（如果指标提供了精确开仓价格）
|
||
open_long_price_arr = signals.get('open_long_price', pd.Series([0.0] * len(df))).values
|
||
open_short_price_arr = signals.get('open_short_price', pd.Series([0.0] * len(df))).values
|
||
|
||
# 平仓目标价格（如果指标提供了精确平仓价格）
|
||
close_long_price_arr = signals.get('close_long_price', pd.Series([0.0] * len(df))).values
|
||
close_short_price_arr = signals.get('close_short_price', pd.Series([0.0] * len(df))).values
|
||
|
||
# 加仓目标价格（如果指标提供了精确加仓价格）
|
||
add_long_price_arr = signals.get('add_long_price', pd.Series([0.0] * len(df))).values
|
||
add_short_price_arr = signals.get('add_short_price', pd.Series([0.0] * len(df))).values
|
||
|
||
for i, (timestamp, row) in enumerate(df.iterrows()):
|
||
if is_liquidated:
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': 0
|
||
})
|
||
continue
|
||
|
||
# 若已无持仓且余额过低，视为赔光并停止后续交易
|
||
if position == 0 and capital < min_capital_to_trade:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(float(row.get('close', 0) or 0), 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': 0})
|
||
continue
|
||
|
||
# Use OHLC to evaluate triggers.
|
||
high = row['high']
|
||
low = row['low']
|
||
close = row['close']
|
||
open_ = row.get('open', close)
|
||
|
||
# Default execution price depends on timing mode
|
||
# - bar_close: close
|
||
# - next_bar_open: open (this bar is the next bar for a prior signal)
|
||
exec_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else close
|
||
|
||
# --- Risk controls: SL / TP / trailing exit (highest priority) ---
|
||
if position != 0 and position_type in ['long', 'short']:
|
||
# 更新持仓期间极值（用于移动止盈止损）
|
||
if position_type == 'long':
|
||
if highest_since_entry is None:
|
||
highest_since_entry = entry_price
|
||
if lowest_since_entry is None:
|
||
lowest_since_entry = entry_price
|
||
highest_since_entry = max(highest_since_entry, high)
|
||
lowest_since_entry = min(lowest_since_entry, low)
|
||
else: # short
|
||
if lowest_since_entry is None:
|
||
lowest_since_entry = entry_price
|
||
if highest_since_entry is None:
|
||
highest_since_entry = entry_price
|
||
lowest_since_entry = min(lowest_since_entry, low)
|
||
highest_since_entry = max(highest_since_entry, high)
|
||
|
||
# 收集同一根K线内触发的强制平仓点
|
||
# 回测为K线级别，无法确定同一根K线内的真实触发顺序；这里按“确定性优先级”处理：
|
||
# 止损 > 移动止盈(回撤) > 固定止盈
|
||
candidates = [] # [(trade_type, trigger_price)]
|
||
if position_type == 'long' and position > 0:
|
||
if stop_loss_pct_eff > 0:
|
||
sl_price = entry_price * (1 - stop_loss_pct_eff)
|
||
if low <= sl_price:
|
||
candidates.append(('close_long_stop', sl_price))
|
||
# Fixed take-profit exit is disabled when trailing is enabled (see conflict rule above).
|
||
if (not trailing_enabled) and take_profit_pct_eff > 0:
|
||
tp_price = entry_price * (1 + take_profit_pct_eff)
|
||
if high >= tp_price:
|
||
candidates.append(('close_long_profit', tp_price))
|
||
if trailing_enabled and trailing_pct_eff > 0 and highest_since_entry is not None:
|
||
trail_active = True
|
||
if trailing_activation_pct_eff > 0:
|
||
trail_active = highest_since_entry >= entry_price * (1 + trailing_activation_pct_eff)
|
||
if trail_active:
|
||
tr_price = highest_since_entry * (1 - trailing_pct_eff)
|
||
if low <= tr_price:
|
||
candidates.append(('close_long_trailing', tr_price))
|
||
|
||
if candidates:
|
||
# 按优先级选择触发点：止损 > 移动止盈 > 止盈
|
||
pri = {'close_long_stop': 0, 'close_long_trailing': 1, 'close_long_profit': 2}
|
||
trade_type, trigger_price = sorted(candidates, key=lambda x: (pri.get(x[0], 99), x[1]))[0]
|
||
exec_price_close = trigger_price * (1 - slippage)
|
||
commission_fee_close = position * exec_price_close * commission
|
||
# 开仓手续费已在开仓时扣除，这里只扣平仓手续费
|
||
profit = (exec_price_close - entry_price) * position - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': trade_type,
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
if position_type == 'short' and position < 0:
|
||
shares = abs(position)
|
||
if stop_loss_pct_eff > 0:
|
||
sl_price = entry_price * (1 + stop_loss_pct_eff)
|
||
if high >= sl_price:
|
||
candidates.append(('close_short_stop', sl_price))
|
||
# Fixed take-profit exit is disabled when trailing is enabled (see conflict rule above).
|
||
if (not trailing_enabled) and take_profit_pct_eff > 0:
|
||
tp_price = entry_price * (1 - take_profit_pct_eff)
|
||
if low <= tp_price:
|
||
candidates.append(('close_short_profit', tp_price))
|
||
if trailing_enabled and trailing_pct_eff > 0 and lowest_since_entry is not None:
|
||
trail_active = True
|
||
if trailing_activation_pct_eff > 0:
|
||
trail_active = lowest_since_entry <= entry_price * (1 - trailing_activation_pct_eff)
|
||
if trail_active:
|
||
tr_price = lowest_since_entry * (1 + trailing_pct_eff)
|
||
if high >= tr_price:
|
||
candidates.append(('close_short_trailing', tr_price))
|
||
|
||
if candidates:
|
||
# 按优先级选择触发点：止损 > 移动止盈 > 止盈
|
||
pri = {'close_short_stop': 0, 'close_short_trailing': 1, 'close_short_profit': 2}
|
||
trade_type, trigger_price = sorted(candidates, key=lambda x: (pri.get(x[0], 99), -x[1]))[0]
|
||
exec_price_close = trigger_price * (1 + slippage)
|
||
commission_fee_close = shares * exec_price_close * commission
|
||
# 开仓手续费已在开仓时扣除，这里只扣平仓手续费
|
||
profit = (entry_price - exec_price_close) * shares - commission_fee_close
|
||
|
||
if capital + profit <= 0:
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': 0})
|
||
continue
|
||
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': trade_type,
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
# 处理平仓信号（优先处理，包括止损/止盈）
|
||
if position > 0 and close_long_arr[i]:
|
||
# 平多：使用指标提供的目标价格（如果有），否则使用收盘价
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
target_price = open_
|
||
else:
|
||
target_price = close_long_price_arr[i] if close_long_price_arr[i] > 0 else close
|
||
exec_price = target_price * (1 - slippage)
|
||
commission_fee = position * exec_price * commission
|
||
profit = (exec_price - entry_price) * position - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
# NOTE:
|
||
# This is a "signal close" (not a forced stop-loss/take-profit/trailing exit).
|
||
# Do NOT label it as *_stop/*_profit based on PnL sign, otherwise it looks like a stop-loss happened
|
||
# even when risk controls are disabled (stopLossPct/takeProfitPct == 0).
|
||
trade_type = 'close_long'
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': trade_type,
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
|
||
# 平仓后余额过低则停止交易（避免同K线反手开仓）
|
||
if capital < min_capital_to_trade:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
elif position < 0 and close_short_arr[i]:
|
||
# 平空：使用指标提供的目标价格（如果有），否则使用收盘价
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
target_price = open_
|
||
else:
|
||
target_price = close_short_price_arr[i] if close_short_price_arr[i] > 0 else close
|
||
exec_price = target_price * (1 + slippage)
|
||
shares = abs(position)
|
||
commission_fee = shares * exec_price * commission
|
||
profit = (entry_price - exec_price) * shares - commission_fee
|
||
|
||
if capital + profit <= 0:
|
||
logger.warning(f"平空时资金不足爆仓")
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': 0})
|
||
continue
|
||
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
# Signal close (not forced TP/SL/trailing).
|
||
trade_type = 'close_short'
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': trade_type,
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
|
||
if capital < min_capital_to_trade:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
# If this candle has a main strategy signal (open/close long/short),
|
||
# we must NOT apply any scale-in/scale-out actions on the same candle.
|
||
main_signal_on_bar = bool(open_long_arr[i] or open_short_arr[i] or close_long_arr[i] or close_short_arr[i])
|
||
|
||
# --- Parameterized scaling rules (no strategy code needed) ---
|
||
# Rules:
|
||
# - Trend scale-in: long triggers when price rises stepPct from anchor; short triggers when price falls stepPct from anchor
|
||
# - Mean-reversion DCA: long triggers when price falls stepPct from anchor; short triggers when price rises stepPct from anchor
|
||
# - Trend reduce: long reduces on rise; short reduces on fall
|
||
# - Adverse reduce: long reduces on fall; short reduces on rise
|
||
if (not main_signal_on_bar) and position != 0 and position_type in ['long', 'short'] and capital >= min_capital_to_trade:
|
||
# 做多
|
||
if position_type == 'long' and position > 0:
|
||
# Trend scale-in (trigger on higher price)
|
||
if trend_add_enabled and trend_add_step_pct_eff > 0 and trend_add_size_pct > 0 and (trend_add_max_times == 0 or trend_add_times < trend_add_max_times):
|
||
anchor = last_trend_add_anchor if last_trend_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 + trend_add_step_pct_eff)
|
||
if high >= trigger:
|
||
order_pct = trend_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 + slippage)
|
||
use_capital = capital * order_pct
|
||
# 手续费按成交名义价值扣除；下单数量不再除以(1+commission)
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = position * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position += shares_add
|
||
entry_price = total_cost_after / position
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
trend_add_times += 1
|
||
last_trend_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_long',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Mean-reversion DCA (trigger on lower price)
|
||
if dca_add_enabled and dca_add_step_pct_eff > 0 and dca_add_size_pct > 0 and (dca_add_max_times == 0 or dca_add_times < dca_add_max_times):
|
||
anchor = last_dca_add_anchor if last_dca_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 - dca_add_step_pct_eff)
|
||
if low <= trigger:
|
||
order_pct = dca_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 + slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = position * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position += shares_add
|
||
entry_price = total_cost_after / position
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
dca_add_times += 1
|
||
last_dca_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_long',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Trend reduce (trigger on higher price)
|
||
if trend_reduce_enabled and trend_reduce_step_pct_eff > 0 and trend_reduce_size_pct > 0 and (trend_reduce_max_times == 0 or trend_reduce_times < trend_reduce_max_times):
|
||
anchor = last_trend_reduce_anchor if last_trend_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 + trend_reduce_step_pct_eff)
|
||
if high >= trigger:
|
||
reduce_pct = max(trend_reduce_size_pct, 0.0)
|
||
reduce_shares = position * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 - slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (exec_price_reduce - entry_price) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position -= reduce_shares
|
||
if position <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
trend_reduce_times += 1
|
||
last_trend_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_long',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Adverse reduce (trigger on lower price)
|
||
if position_type == 'long' and position > 0 and adverse_reduce_enabled and adverse_reduce_step_pct_eff > 0 and adverse_reduce_size_pct > 0 and (adverse_reduce_max_times == 0 or adverse_reduce_times < adverse_reduce_max_times):
|
||
anchor = last_adverse_reduce_anchor if last_adverse_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 - adverse_reduce_step_pct_eff)
|
||
if low <= trigger:
|
||
reduce_pct = max(adverse_reduce_size_pct, 0.0)
|
||
reduce_shares = position * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 - slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (exec_price_reduce - entry_price) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position -= reduce_shares
|
||
if position <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
adverse_reduce_times += 1
|
||
last_adverse_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_long',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 做空
|
||
if position_type == 'short' and position < 0:
|
||
shares_total = abs(position)
|
||
|
||
# Trend scale-in (trigger on lower price)
|
||
if trend_add_enabled and trend_add_step_pct_eff > 0 and trend_add_size_pct > 0 and (trend_add_max_times == 0 or trend_add_times < trend_add_max_times):
|
||
anchor = last_trend_add_anchor if last_trend_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 - trend_add_step_pct_eff)
|
||
if low <= trigger:
|
||
order_pct = trend_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 - slippage) # 卖出加空，滑点不利
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = shares_total * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position -= shares_add
|
||
shares_total = abs(position)
|
||
entry_price = total_cost_after / shares_total
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
trend_add_times += 1
|
||
last_trend_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_short',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Mean-reversion DCA (trigger on higher price)
|
||
if dca_add_enabled and dca_add_step_pct_eff > 0 and dca_add_size_pct > 0 and (dca_add_max_times == 0 or dca_add_times < dca_add_max_times):
|
||
anchor = last_dca_add_anchor if last_dca_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 + dca_add_step_pct_eff)
|
||
if high >= trigger:
|
||
order_pct = dca_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 - slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = shares_total * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position -= shares_add
|
||
shares_total = abs(position)
|
||
entry_price = total_cost_after / shares_total
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
dca_add_times += 1
|
||
last_dca_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_short',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Trend reduce (trigger on lower price)
|
||
if trend_reduce_enabled and trend_reduce_step_pct_eff > 0 and trend_reduce_size_pct > 0 and (trend_reduce_max_times == 0 or trend_reduce_times < trend_reduce_max_times):
|
||
anchor = last_trend_reduce_anchor if last_trend_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 - trend_reduce_step_pct_eff)
|
||
if low <= trigger:
|
||
reduce_pct = max(trend_reduce_size_pct, 0.0)
|
||
reduce_shares = shares_total * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 + slippage) # 回补更贵
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (entry_price - exec_price_reduce) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position += reduce_shares
|
||
shares_total = abs(position)
|
||
if shares_total <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
trend_reduce_times += 1
|
||
last_trend_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_short',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Adverse reduce (trigger on higher price)
|
||
if position_type == 'short' and position < 0 and adverse_reduce_enabled and adverse_reduce_step_pct_eff > 0 and adverse_reduce_size_pct > 0 and (adverse_reduce_max_times == 0 or adverse_reduce_times < adverse_reduce_max_times):
|
||
anchor = last_adverse_reduce_anchor if last_adverse_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 + adverse_reduce_step_pct_eff)
|
||
if high >= trigger:
|
||
reduce_pct = max(adverse_reduce_size_pct, 0.0)
|
||
reduce_shares = shares_total * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 + slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (entry_price - exec_price_reduce) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position += reduce_shares
|
||
shares_total = abs(position)
|
||
if shares_total <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
adverse_reduce_times += 1
|
||
last_adverse_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_short',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 处理加仓信号（仓位管理模式）
|
||
if has_position_management and (not main_signal_on_bar):
|
||
if position > 0 and add_long_arr[i] and capital >= min_capital_to_trade:
|
||
# 加多仓：使用指标提供的目标价格（如果有），否则使用收盘价
|
||
target_price = add_long_price_arr[i] if add_long_price_arr[i] > 0 else close
|
||
exec_price = target_price * (1 + slippage)
|
||
|
||
# 使用指定比例的资金加仓
|
||
position_pct = position_size_arr[i] if position_size_arr[i] > 0 else 0.1
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
# 更新平均成本
|
||
total_cost_before = position * entry_price
|
||
total_cost_after = total_cost_before + shares * exec_price
|
||
position += shares
|
||
entry_price = total_cost_after / position
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
|
||
# 重新计算爆仓线
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif position < 0 and add_short_arr[i] and capital >= min_capital_to_trade:
|
||
# 加空仓：使用指标提供的目标价格（如果有），否则使用收盘价
|
||
target_price = add_short_price_arr[i] if add_short_price_arr[i] > 0 else close
|
||
exec_price = target_price * (1 - slippage)
|
||
|
||
# 使用指定比例的资金加仓
|
||
position_pct = position_size_arr[i] if position_size_arr[i] > 0 else 0.1
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
# 更新平均成本
|
||
current_shares = abs(position)
|
||
total_cost_before = current_shares * entry_price
|
||
total_cost_after = total_cost_before + shares * exec_price
|
||
position -= shares # 空头是负数
|
||
current_shares = abs(position)
|
||
entry_price = total_cost_after / current_shares
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
|
||
# 重新计算爆仓线
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 处理开仓信号
|
||
# 注意：code6.py已经处理了反转（先平后开），所以这里只需要处理position==0的情况
|
||
if open_long_arr[i] and position == 0 and capital >= min_capital_to_trade:
|
||
# 使用指标提供的开仓触发价格（如果有），否则使用收盘价
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
base_price = open_
|
||
else:
|
||
base_price = open_long_price_arr[i] if open_long_price_arr[i] > 0 else close
|
||
exec_price = base_price * (1 + slippage)
|
||
|
||
# 使用指定比例的资金开仓（优先采用回测弹窗的 entryPct；其次采用指标提供的 position_size；否则全仓）
|
||
position_pct = None
|
||
if entry_pct_cfg and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
elif has_position_management and position_size_arr[i] > 0:
|
||
position_pct = position_size_arr[i]
|
||
if position_pct is not None and position_pct > 0 and position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = shares
|
||
entry_price = exec_price
|
||
position_type = 'long'
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
highest_since_entry = entry_price
|
||
lowest_since_entry = entry_price
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Strict intrabar stop-loss / liquidation check right after entry (closer to live trading).
|
||
# If this bar touches stop-loss price, close immediately at stop price (with slippage).
|
||
# If this bar also touches liquidation price, assume stop-loss triggers first only if it is above liquidation.
|
||
if position_type == 'long' and position > 0:
|
||
sl_price = entry_price * (1 - stop_loss_pct_eff) if stop_loss_pct_eff > 0 else None
|
||
hit_sl = (sl_price is not None) and (low <= sl_price)
|
||
hit_liq = liquidation_price > 0 and (low <= liquidation_price)
|
||
if hit_sl or hit_liq:
|
||
if hit_liq and (not hit_sl or (sl_price is not None and sl_price <= liquidation_price)):
|
||
# Liquidation happens before stop-loss (or stop-loss not configured).
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
else:
|
||
# Stop-loss triggers first.
|
||
exec_price_close = sl_price * (1 - slippage)
|
||
commission_fee_close = position * exec_price_close * commission
|
||
profit = (exec_price_close - entry_price) * position - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
if capital <= 0:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long_stop',
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
elif open_short_arr[i] and position == 0 and capital >= min_capital_to_trade:
|
||
# 使用指标提供的开仓触发价格（如果有），否则使用收盘价
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
base_price = open_
|
||
else:
|
||
base_price = open_short_price_arr[i] if open_short_price_arr[i] > 0 else close
|
||
exec_price = base_price * (1 - slippage)
|
||
|
||
# 使用指定比例的资金开仓（优先采用回测弹窗的 entryPct；其次采用指标提供的 position_size；否则全仓）
|
||
position_pct = None
|
||
if entry_pct_cfg and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
elif has_position_management and position_size_arr[i] > 0:
|
||
position_pct = position_size_arr[i]
|
||
if position_pct is not None and position_pct > 0 and position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = -shares
|
||
entry_price = exec_price
|
||
position_type = 'short'
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
highest_since_entry = entry_price
|
||
lowest_since_entry = entry_price
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Strict intrabar stop-loss / liquidation check right after entry (closer to live trading).
|
||
if position_type == 'short' and position < 0:
|
||
sl_price = entry_price * (1 + stop_loss_pct_eff) if stop_loss_pct_eff > 0 else None
|
||
hit_sl = (sl_price is not None) and (high >= sl_price)
|
||
hit_liq = liquidation_price > 0 and (high >= liquidation_price)
|
||
if hit_sl or hit_liq:
|
||
if hit_liq and (not hit_sl or (sl_price is not None and sl_price >= liquidation_price)):
|
||
# Liquidation happens before stop-loss (or stop-loss not configured).
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(abs(position), 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
else:
|
||
# Stop-loss triggers first.
|
||
exec_price_close = sl_price * (1 + slippage)
|
||
shares_close = abs(position)
|
||
commission_fee_close = shares_close * exec_price_close * commission
|
||
profit = (entry_price - exec_price_close) * shares_close - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
if capital <= 0:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short_stop',
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(shares_close, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
# 检测持仓期间是否触及爆仓线（作为兜底保护）
|
||
# 注意：这个检查在所有主动平仓信号处理之后
|
||
# 如果触及爆仓线，检查是否有止损信号，止损优先
|
||
if position != 0 and not is_liquidated:
|
||
if position_type == 'long' and low <= liquidation_price:
|
||
# 做多触及爆仓线：检查是否有止损信号
|
||
has_stop_loss = close_long_arr[i] and close_long_price_arr[i] > 0
|
||
stop_loss_price = close_long_price_arr[i] if has_stop_loss else 0
|
||
|
||
# 判断先触发止损还是爆仓
|
||
if has_stop_loss and stop_loss_price > liquidation_price:
|
||
# 止损在爆仓前触发，使用止损价平仓
|
||
exec_price_close = stop_loss_price * (1 - slippage)
|
||
commission_fee_close = position * exec_price_close * commission
|
||
profit = (exec_price_close - entry_price) * position - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long_stop',
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
else:
|
||
# 止损不够严格或无止损，触发爆仓
|
||
logger.warning(f"做多爆仓！开仓价={entry_price:.2f}, 最低价={low:.2f}, "
|
||
f"爆仓线={liquidation_price:.2f}, 止损价={stop_loss_price:.2f}")
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(abs(position), 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': capital})
|
||
continue
|
||
|
||
elif position_type == 'short' and high >= liquidation_price:
|
||
# 做空触及爆仓线：检查是否有止损信号
|
||
has_stop_loss = close_short_arr[i] and close_short_price_arr[i] > 0
|
||
stop_loss_price = close_short_price_arr[i] if has_stop_loss else 0
|
||
|
||
logger.warning(f"[K线{i}] 做空触及爆仓线！开仓={entry_price:.2f}, 最高={high:.2f}, 爆仓线={liquidation_price:.2f}, "
|
||
f"止损信号={close_short_arr[i]}, 止损价={stop_loss_price:.4f}, 时间={timestamp}")
|
||
|
||
# 判断先触发止损还是爆仓
|
||
if has_stop_loss and stop_loss_price < liquidation_price:
|
||
# 止损在爆仓前触发，使用止损价平仓
|
||
exec_price_close = stop_loss_price * (1 + slippage)
|
||
shares_close = abs(position)
|
||
commission_fee_close = shares_close * exec_price_close * commission
|
||
profit = (entry_price - exec_price_close) * shares_close - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short_stop',
|
||
'price': round(exec_price_close, 4),
|
||
'amount': round(shares_close, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
else:
|
||
# 止损不够严格或无止损，触发爆仓
|
||
logger.warning(f"做空爆仓！开仓价={entry_price:.2f}, 最高价={high:.2f}, "
|
||
f"爆仓线={liquidation_price:.2f}, 止损价={stop_loss_price:.2f}")
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(abs(position), 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': capital})
|
||
continue
|
||
|
||
# 记录权益（使用收盘价计算未实现盈亏）
|
||
if position_type == 'long':
|
||
unrealized_pnl = (close - entry_price) * position
|
||
total_value = capital + unrealized_pnl
|
||
elif position_type == 'short':
|
||
shares = abs(position)
|
||
unrealized_pnl = (entry_price - close) * shares
|
||
total_value = capital + unrealized_pnl
|
||
else:
|
||
total_value = capital
|
||
|
||
if total_value < 0:
|
||
total_value = 0
|
||
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': round(total_value, 2)
|
||
})
|
||
|
||
# 回测结束时强制平仓
|
||
if position != 0:
|
||
timestamp = df.index[-1]
|
||
final_close = df.iloc[-1]['close']
|
||
|
||
if position > 0: # 平多
|
||
exec_price = final_close * (1 - slippage)
|
||
commission_fee = position * exec_price * commission
|
||
profit = (exec_price - entry_price) * position - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
else: # 平空
|
||
exec_price = final_close * (1 + slippage)
|
||
shares = abs(position)
|
||
commission_fee = shares * exec_price * commission
|
||
profit = (entry_price - exec_price) * shares - commission_fee
|
||
|
||
if capital + profit <= 0:
|
||
logger.warning(f"回测结束爆仓！")
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-capital, 2),
|
||
'balance': 0
|
||
})
|
||
else:
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
if equity_curve:
|
||
equity_curve[-1]['value'] = round(capital, 2)
|
||
|
||
return equity_curve, trades, total_commission_paid
|
||
|
||
def _simulate_trading_old_format(
|
||
self,
|
||
df: pd.DataFrame,
|
||
signals: pd.Series,
|
||
initial_capital: float,
|
||
commission: float,
|
||
slippage: float,
|
||
leverage: int = 1,
|
||
trade_direction: str = 'long',
|
||
strategy_config: Optional[Dict[str, Any]] = None
|
||
) -> tuple:
|
||
"""
|
||
使用旧格式信号进行交易模拟（保持兼容性）
|
||
"""
|
||
equity_curve = []
|
||
trades = []
|
||
total_commission_paid = 0 # 累计手续费
|
||
is_liquidated = False # 爆仓标志
|
||
liquidation_price = 0 # 爆仓价格
|
||
min_capital_to_trade = 1.0 # 余额低于该值则视为赔光，不再开新单
|
||
|
||
capital = initial_capital
|
||
position = 0 # 正数=多头持仓，负数=空头持仓
|
||
entry_price = 0
|
||
position_type = None # 'long' or 'short'
|
||
|
||
# Risk controls (also supported for legacy signals): SL / TP / trailing exit
|
||
cfg = strategy_config or {}
|
||
exec_cfg = cfg.get('execution') or {}
|
||
# Signal confirmation / execution timing (legacy mode):
|
||
# - bar_close: execute on the same bar close
|
||
# - next_bar_open: execute on next bar open after signal is confirmed on bar close (recommended)
|
||
signal_timing = str(exec_cfg.get('signalTiming') or 'next_bar_open').strip().lower()
|
||
risk_cfg = cfg.get('risk') or {}
|
||
stop_loss_pct = float(risk_cfg.get('stopLossPct') or 0.0)
|
||
take_profit_pct = float(risk_cfg.get('takeProfitPct') or 0.0)
|
||
trailing_cfg = risk_cfg.get('trailing') or {}
|
||
trailing_enabled = bool(trailing_cfg.get('enabled'))
|
||
trailing_pct = float(trailing_cfg.get('pct') or 0.0)
|
||
trailing_activation_pct = float(trailing_cfg.get('activationPct') or 0.0)
|
||
|
||
# Risk percentages are defined on margin PnL; convert to price move thresholds by leverage.
|
||
lev = max(int(leverage or 1), 1)
|
||
stop_loss_pct_eff = stop_loss_pct / lev
|
||
take_profit_pct_eff = take_profit_pct / lev
|
||
trailing_pct_eff = trailing_pct / lev
|
||
trailing_activation_pct_eff = trailing_activation_pct / lev
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
|
||
# --- Position / scaling config (make old-format strategies support the same backtest modal features) ---
|
||
pos_cfg = cfg.get('position') or {}
|
||
entry_pct_cfg = float(pos_cfg.get('entryPct') if pos_cfg.get('entryPct') is not None else 1.0) # expected 0~1
|
||
# Accept both 0~1 and 0~100 inputs (some clients may send percent units).
|
||
if entry_pct_cfg > 1:
|
||
entry_pct_cfg = entry_pct_cfg / 100.0
|
||
entry_pct_cfg = max(0.0, min(entry_pct_cfg, 1.0))
|
||
|
||
scale_cfg = cfg.get('scale') or {}
|
||
trend_add_cfg = scale_cfg.get('trendAdd') or {}
|
||
dca_add_cfg = scale_cfg.get('dcaAdd') or {}
|
||
trend_reduce_cfg = scale_cfg.get('trendReduce') or {}
|
||
adverse_reduce_cfg = scale_cfg.get('adverseReduce') or {}
|
||
|
||
trend_add_enabled = bool(trend_add_cfg.get('enabled'))
|
||
trend_add_step_pct = float(trend_add_cfg.get('stepPct') or 0.0)
|
||
trend_add_size_pct = float(trend_add_cfg.get('sizePct') or 0.0)
|
||
trend_add_max_times = int(trend_add_cfg.get('maxTimes') or 0)
|
||
|
||
dca_add_enabled = bool(dca_add_cfg.get('enabled'))
|
||
dca_add_step_pct = float(dca_add_cfg.get('stepPct') or 0.0)
|
||
dca_add_size_pct = float(dca_add_cfg.get('sizePct') or 0.0)
|
||
dca_add_max_times = int(dca_add_cfg.get('maxTimes') or 0)
|
||
|
||
trend_reduce_enabled = bool(trend_reduce_cfg.get('enabled'))
|
||
trend_reduce_step_pct = float(trend_reduce_cfg.get('stepPct') or 0.0)
|
||
trend_reduce_size_pct = float(trend_reduce_cfg.get('sizePct') or 0.0)
|
||
trend_reduce_max_times = int(trend_reduce_cfg.get('maxTimes') or 0)
|
||
|
||
adverse_reduce_enabled = bool(adverse_reduce_cfg.get('enabled'))
|
||
adverse_reduce_step_pct = float(adverse_reduce_cfg.get('stepPct') or 0.0)
|
||
adverse_reduce_size_pct = float(adverse_reduce_cfg.get('sizePct') or 0.0)
|
||
adverse_reduce_max_times = int(adverse_reduce_cfg.get('maxTimes') or 0)
|
||
|
||
# 触发百分比按杠杆后换算为价格阈值
|
||
trend_add_step_pct_eff = trend_add_step_pct / lev
|
||
dca_add_step_pct_eff = dca_add_step_pct / lev
|
||
trend_reduce_step_pct_eff = trend_reduce_step_pct / lev
|
||
adverse_reduce_step_pct_eff = adverse_reduce_step_pct / lev
|
||
|
||
# State for scaling
|
||
trend_add_times = 0
|
||
dca_add_times = 0
|
||
trend_reduce_times = 0
|
||
adverse_reduce_times = 0
|
||
last_trend_add_anchor = None
|
||
last_dca_add_anchor = None
|
||
last_trend_reduce_anchor = None
|
||
last_adverse_reduce_anchor = None
|
||
|
||
# Apply execution timing to avoid look-ahead bias in legacy signals (buy/sell series):
|
||
# If signal is computed on bar close, realistic execution is next bar open.
|
||
signals_exec = signals
|
||
if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next']:
|
||
try:
|
||
signals_exec = signals.shift(1).fillna(0)
|
||
except Exception:
|
||
signals_exec = signals
|
||
|
||
for i, (timestamp, row) in enumerate(df.iterrows()):
|
||
# 如果已爆仓，停止交易
|
||
if is_liquidated:
|
||
# 记录爆仓后的权益（保持为0）
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': 0
|
||
})
|
||
continue
|
||
|
||
# 若已无持仓且余额过低，视为赔光并停止后续交易
|
||
if position == 0 and capital < min_capital_to_trade:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(float(row.get('close', 0) or 0), 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': 0})
|
||
continue
|
||
|
||
signal = signals_exec.iloc[i] if i < len(signals_exec) else 0
|
||
high = row['high']
|
||
low = row['low']
|
||
price = row['close']
|
||
open_ = row.get('open', price)
|
||
|
||
# 强制平仓（止盈止损/移动止盈）优先于信号
|
||
if position != 0 and position_type in ['long', 'short']:
|
||
if position_type == 'long' and position > 0:
|
||
if highest_since_entry is None:
|
||
highest_since_entry = entry_price
|
||
highest_since_entry = max(highest_since_entry, high)
|
||
candidates = []
|
||
if stop_loss_pct_eff > 0:
|
||
sl_price = entry_price * (1 - stop_loss_pct_eff)
|
||
if low <= sl_price:
|
||
candidates.append(('stop', sl_price))
|
||
if take_profit_pct_eff > 0:
|
||
tp_price = entry_price * (1 + take_profit_pct_eff)
|
||
if high >= tp_price:
|
||
candidates.append(('profit', tp_price))
|
||
if trailing_enabled and trailing_pct_eff > 0:
|
||
trail_active = True
|
||
if trailing_activation_pct_eff > 0:
|
||
trail_active = highest_since_entry >= entry_price * (1 + trailing_activation_pct_eff)
|
||
if trail_active:
|
||
tr_price = highest_since_entry * (1 - trailing_pct_eff)
|
||
if low <= tr_price:
|
||
candidates.append(('trailing', tr_price))
|
||
if candidates:
|
||
# 止损 > 移动止盈(回撤) > 止盈
|
||
pri = {'stop': 0, 'trailing': 1, 'profit': 2}
|
||
reason, trigger_price = sorted(candidates, key=lambda x: (pri.get(x[0], 99), x[1]))[0]
|
||
exec_price = trigger_price * (1 - slippage)
|
||
commission_fee = position * exec_price * commission
|
||
# 开仓手续费已在开仓时扣除，这里只扣平仓手续费
|
||
profit = (exec_price - entry_price) * position - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': {'stop': 'close_long_stop', 'profit': 'close_long_profit', 'trailing': 'close_long_trailing'}.get(reason, 'close_long'),
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
if position_type == 'short' and position < 0:
|
||
shares = abs(position)
|
||
if lowest_since_entry is None:
|
||
lowest_since_entry = entry_price
|
||
lowest_since_entry = min(lowest_since_entry, low)
|
||
candidates = []
|
||
if stop_loss_pct_eff > 0:
|
||
sl_price = entry_price * (1 + stop_loss_pct_eff)
|
||
if high >= sl_price:
|
||
candidates.append(('stop', sl_price))
|
||
if take_profit_pct_eff > 0:
|
||
tp_price = entry_price * (1 - take_profit_pct_eff)
|
||
if low <= tp_price:
|
||
candidates.append(('profit', tp_price))
|
||
if trailing_enabled and trailing_pct_eff > 0:
|
||
trail_active = True
|
||
if trailing_activation_pct_eff > 0:
|
||
trail_active = lowest_since_entry <= entry_price * (1 - trailing_activation_pct_eff)
|
||
if trail_active:
|
||
tr_price = lowest_since_entry * (1 + trailing_pct_eff)
|
||
if high >= tr_price:
|
||
candidates.append(('trailing', tr_price))
|
||
if candidates:
|
||
# 止损 > 移动止盈(回撤) > 止盈
|
||
pri = {'stop': 0, 'trailing': 1, 'profit': 2}
|
||
reason, trigger_price = sorted(candidates, key=lambda x: (pri.get(x[0], 99), -x[1]))[0]
|
||
exec_price = trigger_price * (1 + slippage)
|
||
commission_fee = shares * exec_price * commission
|
||
# 开仓手续费已在开仓时扣除，这里只扣平仓手续费
|
||
profit = (entry_price - exec_price) * shares - commission_fee
|
||
if capital + profit <= 0:
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': 0})
|
||
continue
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': {'stop': 'close_short_stop', 'profit': 'close_short_profit', 'trailing': 'close_short_trailing'}.get(reason, 'close_short'),
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
highest_since_entry = None
|
||
lowest_since_entry = None
|
||
equity_curve.append({'time': timestamp.strftime('%Y-%m-%d %H:%M'), 'value': round(capital, 2)})
|
||
continue
|
||
|
||
# --- Parameterized scaling rules (also for old-format strategies) ---
|
||
# 说明：旧格式只有 buy/sell 信号，但回测弹窗的“顺势/逆势加减仓、最小下单比例”等参数仍应生效。
|
||
# 触发百分比按杠杆后阈值理解（已除以 leverage）。
|
||
# IMPORTANT: if this candle has a main buy/sell signal, do NOT apply any scale-in/scale-out.
|
||
if signal == 0 and position != 0 and position_type in ['long', 'short'] and capital >= min_capital_to_trade:
|
||
# 做多
|
||
if position_type == 'long' and position > 0:
|
||
# Trend add（顺势加仓：上涨触发）
|
||
if trend_add_enabled and trend_add_step_pct_eff > 0 and trend_add_size_pct > 0 and (trend_add_max_times == 0 or trend_add_times < trend_add_max_times):
|
||
anchor = last_trend_add_anchor if last_trend_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 + trend_add_step_pct_eff)
|
||
if high >= trigger:
|
||
order_pct = trend_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 + slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = position * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position += shares_add
|
||
entry_price = total_cost_after / position
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
trend_add_times += 1
|
||
last_trend_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_long',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# DCA add（逆势加仓：下跌触发）
|
||
if dca_add_enabled and dca_add_step_pct_eff > 0 and dca_add_size_pct > 0 and (dca_add_max_times == 0 or dca_add_times < dca_add_max_times):
|
||
anchor = last_dca_add_anchor if last_dca_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 - dca_add_step_pct_eff)
|
||
if low <= trigger:
|
||
order_pct = dca_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 + slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = position * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position += shares_add
|
||
entry_price = total_cost_after / position
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
dca_add_times += 1
|
||
last_dca_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_long',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Trend reduce（顺势减仓：上涨触发）
|
||
if trend_reduce_enabled and trend_reduce_step_pct_eff > 0 and trend_reduce_size_pct > 0 and (trend_reduce_max_times == 0 or trend_reduce_times < trend_reduce_max_times):
|
||
anchor = last_trend_reduce_anchor if last_trend_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 + trend_reduce_step_pct_eff)
|
||
if high >= trigger:
|
||
reduce_pct = max(trend_reduce_size_pct, 0.0)
|
||
reduce_shares = position * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 - slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (exec_price_reduce - entry_price) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position -= reduce_shares
|
||
if position <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
trend_reduce_times += 1
|
||
last_trend_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_long',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Adverse reduce（逆势减仓：下跌触发）
|
||
if position_type == 'long' and position > 0 and adverse_reduce_enabled and adverse_reduce_step_pct_eff > 0 and adverse_reduce_size_pct > 0 and (adverse_reduce_max_times == 0 or adverse_reduce_times < adverse_reduce_max_times):
|
||
anchor = last_adverse_reduce_anchor if last_adverse_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 - adverse_reduce_step_pct_eff)
|
||
if low <= trigger:
|
||
reduce_pct = max(adverse_reduce_size_pct, 0.0)
|
||
reduce_shares = position * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 - slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (exec_price_reduce - entry_price) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position -= reduce_shares
|
||
if position <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
|
||
adverse_reduce_times += 1
|
||
last_adverse_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_long',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 做空
|
||
if position_type == 'short' and position < 0:
|
||
shares_total = abs(position)
|
||
|
||
# Trend add（顺势加空：下跌触发）
|
||
if trend_add_enabled and trend_add_step_pct_eff > 0 and trend_add_size_pct > 0 and (trend_add_max_times == 0 or trend_add_times < trend_add_max_times):
|
||
anchor = last_trend_add_anchor if last_trend_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 - trend_add_step_pct_eff)
|
||
if low <= trigger:
|
||
order_pct = trend_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 - slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = shares_total * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position -= shares_add
|
||
shares_total = abs(position)
|
||
entry_price = total_cost_after / shares_total
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
trend_add_times += 1
|
||
last_trend_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_short',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# DCA add（逆势加空：上涨触发）
|
||
if dca_add_enabled and dca_add_step_pct_eff > 0 and dca_add_size_pct > 0 and (dca_add_max_times == 0 or dca_add_times < dca_add_max_times):
|
||
anchor = last_dca_add_anchor if last_dca_add_anchor is not None else entry_price
|
||
trigger = anchor * (1 + dca_add_step_pct_eff)
|
||
if high >= trigger:
|
||
order_pct = dca_add_size_pct
|
||
if order_pct > 0:
|
||
exec_price_add = trigger * (1 - slippage)
|
||
use_capital = capital * order_pct
|
||
shares_add = (use_capital * leverage) / exec_price_add
|
||
commission_fee = shares_add * exec_price_add * commission
|
||
|
||
total_cost_before = shares_total * entry_price
|
||
total_cost_after = total_cost_before + shares_add * exec_price_add
|
||
position -= shares_add
|
||
shares_total = abs(position)
|
||
entry_price = total_cost_after / shares_total
|
||
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
dca_add_times += 1
|
||
last_dca_add_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'add_short',
|
||
'price': round(exec_price_add, 4),
|
||
'amount': round(shares_add, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Trend reduce（顺势减空：下跌触发，回补一部分）
|
||
if trend_reduce_enabled and trend_reduce_step_pct_eff > 0 and trend_reduce_size_pct > 0 and (trend_reduce_max_times == 0 or trend_reduce_times < trend_reduce_max_times):
|
||
anchor = last_trend_reduce_anchor if last_trend_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 - trend_reduce_step_pct_eff)
|
||
if low <= trigger:
|
||
reduce_pct = max(trend_reduce_size_pct, 0.0)
|
||
reduce_shares = shares_total * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 + slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (entry_price - exec_price_reduce) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position += reduce_shares
|
||
shares_total = abs(position)
|
||
if shares_total <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
trend_reduce_times += 1
|
||
last_trend_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_short',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# Adverse reduce（逆势减空：上涨触发）
|
||
if position_type == 'short' and position < 0 and adverse_reduce_enabled and adverse_reduce_step_pct_eff > 0 and adverse_reduce_size_pct > 0 and (adverse_reduce_max_times == 0 or adverse_reduce_times < adverse_reduce_max_times):
|
||
anchor = last_adverse_reduce_anchor if last_adverse_reduce_anchor is not None else entry_price
|
||
trigger = anchor * (1 + adverse_reduce_step_pct_eff)
|
||
if high >= trigger:
|
||
reduce_pct = max(adverse_reduce_size_pct, 0.0)
|
||
reduce_shares = shares_total * reduce_pct
|
||
if reduce_shares > 0:
|
||
exec_price_reduce = trigger * (1 + slippage)
|
||
commission_fee = reduce_shares * exec_price_reduce * commission
|
||
profit = (entry_price - exec_price_reduce) * reduce_shares - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
position += reduce_shares
|
||
shares_total = abs(position)
|
||
if shares_total <= 1e-12:
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
else:
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
|
||
adverse_reduce_times += 1
|
||
last_adverse_reduce_anchor = trigger
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'reduce_short',
|
||
'price': round(exec_price_reduce, 4),
|
||
'amount': round(reduce_shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 处理不同的交易方向
|
||
if trade_direction == 'long':
|
||
# 只做多模式
|
||
if signal == 1 and position == 0 and capital >= min_capital_to_trade: # 买入开多
|
||
logger.debug(f"[做多模式] 买入开多: 时间={timestamp}, 价格={price}, 杠杆={leverage}x")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 + slippage)
|
||
# 使用杠杆：实际持仓 = 本金 × 杠杆 / 价格
|
||
# 使用指定比例的资金开仓（entryPct 优先；否则全仓）
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
# 保证金（手续费从本金扣除）
|
||
margin = capital
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = shares
|
||
entry_price = exec_price
|
||
position_type = 'long'
|
||
capital -= commission_fee # 只扣手续费，不扣全部成本
|
||
total_commission_paid += commission_fee
|
||
|
||
# 计算爆仓线：做多时，价格跌到 entry_price × (1 - 1/leverage) 就爆仓
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
logger.debug(f"做多爆仓线: {liquidation_price:.2f}")
|
||
|
||
# init scaling anchors
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif signal == -1 and position > 0: # 卖出平多
|
||
logger.debug(f"[做多模式] 卖出平多: 时间={timestamp}, 价格={price}")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 - slippage)
|
||
# 盈亏 = (平仓价 - 开仓价) × 股数 - 手续费
|
||
commission_fee = position * exec_price * commission
|
||
profit = (exec_price - entry_price) * position - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
liquidation_price = 0 # 清除爆仓线
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
if capital < min_capital_to_trade:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
elif trade_direction == 'short':
|
||
# 只做空模式
|
||
if signal == -1 and position == 0 and capital >= min_capital_to_trade: # 卖出开空
|
||
logger.debug(f"[做空模式] 卖出开空: 时间={timestamp}, 价格={price}, 杠杆={leverage}x")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 - slippage)
|
||
# 使用杠杆：实际持仓 = 本金 × 杠杆 / 价格
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = -shares # 负数表示空头（欠股票）
|
||
entry_price = exec_price
|
||
position_type = 'short'
|
||
capital -= commission_fee # 只扣手续费
|
||
total_commission_paid += commission_fee
|
||
|
||
# 计算爆仓线：做空时，价格涨到 entry_price × (1 + 1/leverage) 就爆仓
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
logger.debug(f"做空爆仓线: {liquidation_price:.2f}")
|
||
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif signal == 1 and position < 0: # 买入平空
|
||
logger.debug(f"[做空模式] 买入平空: 时间={timestamp}, 价格={price}")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 + slippage)
|
||
shares = abs(position) # 需要买回的股数
|
||
# 盈亏 = (开仓价 - 平仓价) × 股数 - 手续费
|
||
commission_fee = shares * exec_price * commission
|
||
profit = (entry_price - exec_price) * shares - commission_fee
|
||
|
||
# 检查是否爆仓
|
||
if capital + profit <= 0:
|
||
logger.warning(f"平空时资金不足爆仓: 本金={capital:.2f}, 亏损={-profit:.2f}")
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-capital, 2),
|
||
'balance': 0
|
||
})
|
||
else:
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
position = 0
|
||
position_type = None
|
||
liquidation_price = 0 # 清除爆仓线
|
||
last_trend_add_anchor = last_dca_add_anchor = last_trend_reduce_anchor = last_adverse_reduce_anchor = None
|
||
trend_add_times = dca_add_times = trend_reduce_times = adverse_reduce_times = 0
|
||
if capital < min_capital_to_trade and not is_liquidated:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
|
||
elif trade_direction == 'both':
|
||
# 双向模式
|
||
if signal == 1 and position == 0 and capital >= min_capital_to_trade: # 买入开多
|
||
logger.debug(f"[双向模式] 买入开多: 时间={timestamp}, 价格={price}, 杠杆={leverage}x")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 + slippage)
|
||
# 使用杠杆：实际持仓 = 本金 × 杠杆 / 价格
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = shares
|
||
entry_price = exec_price
|
||
position_type = 'long'
|
||
capital -= commission_fee # 只扣手续费
|
||
total_commission_paid += commission_fee
|
||
|
||
# 计算爆仓线
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
logger.debug(f"做多爆仓线: {liquidation_price:.2f}")
|
||
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif signal == -1 and position == 0 and capital >= min_capital_to_trade: # 卖出开空
|
||
logger.debug(f"[双向模式] 卖出开空: 时间={timestamp}, 价格={price}, 杠杆={leverage}x")
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 - slippage)
|
||
# 使用杠杆：实际持仓 = 本金 × 杠杆 / 价格
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
commission_fee = shares * exec_price * commission
|
||
|
||
position = -shares
|
||
entry_price = exec_price
|
||
position_type = 'short'
|
||
capital -= commission_fee
|
||
total_commission_paid += commission_fee
|
||
|
||
# 计算爆仓线
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
logger.debug(f"做空爆仓线: {liquidation_price:.2f}")
|
||
|
||
last_trend_add_anchor = entry_price
|
||
last_dca_add_anchor = entry_price
|
||
last_trend_reduce_anchor = entry_price
|
||
last_adverse_reduce_anchor = entry_price
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif signal == -1 and position > 0: # 平多开空
|
||
logger.debug(f"[双向模式] 平多开空: 时间={timestamp}, 价格={price}")
|
||
# 先平多
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 - slippage)
|
||
commission_fee_close = position * exec_price * commission
|
||
profit = (exec_price - entry_price) * position - commission_fee_close
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 若平仓后余额过低则停止（避免同K线反手开仓）
|
||
if capital < min_capital_to_trade or is_liquidated:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
continue
|
||
|
||
# Re-open short (respects entryPct; default entryPct=100%)
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
commission_fee_open = shares * exec_price * commission
|
||
|
||
position = -shares
|
||
entry_price = exec_price
|
||
position_type = 'short'
|
||
capital -= commission_fee_open
|
||
total_commission_paid += commission_fee_open
|
||
|
||
# 计算爆仓线
|
||
liquidation_price = entry_price * (1 + 1.0 / leverage)
|
||
logger.debug(f"做空爆仓线: {liquidation_price:.2f}")
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
elif signal == 1 and position < 0: # 平空开多
|
||
logger.debug(f"[双向模式] 平空开多: 时间={timestamp}, 价格={price}")
|
||
# 先平空
|
||
base_price = open_ if signal_timing in ['next_bar_open', 'next_open', 'nextopen', 'next'] else price
|
||
exec_price = base_price * (1 + slippage)
|
||
shares = abs(position)
|
||
commission_fee_close = shares * exec_price * commission
|
||
profit = (entry_price - exec_price) * shares - commission_fee_close
|
||
|
||
# 检查是否爆仓
|
||
if capital + profit <= 0:
|
||
logger.warning(f"平空时资金不足爆仓: 本金={capital:.2f}, 亏损={-profit:.2f}")
|
||
capital = 0
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
continue # 爆仓后不再开新仓
|
||
|
||
capital += profit
|
||
total_commission_paid += commission_fee_close
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
if capital < min_capital_to_trade or is_liquidated:
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': 0,
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
continue
|
||
|
||
# Re-open long (respects entryPct; default entryPct=100%)
|
||
position_pct = None
|
||
if entry_pct_cfg is not None and entry_pct_cfg > 0:
|
||
position_pct = entry_pct_cfg
|
||
if position_pct is not None and 0 < position_pct < 1:
|
||
use_capital = capital * position_pct
|
||
shares = (use_capital * leverage) / exec_price
|
||
else:
|
||
shares = (capital * leverage) / exec_price
|
||
commission_fee_open = shares * exec_price * commission
|
||
|
||
position = shares
|
||
entry_price = exec_price
|
||
position_type = 'long'
|
||
capital -= commission_fee_open
|
||
total_commission_paid += commission_fee_open
|
||
|
||
# 计算爆仓线
|
||
liquidation_price = entry_price * (1 - 1.0 / leverage)
|
||
logger.debug(f"做多爆仓线: {liquidation_price:.2f}")
|
||
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'open_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': 0,
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 检测持仓期间是否触及爆仓线（作为兜底保护，仅在没有主动平仓的情况下检查）
|
||
# 注意：这个检查在所有信号处理之后，确保止损/止盈优先执行
|
||
if position != 0 and not is_liquidated:
|
||
if position_type == 'long':
|
||
# 做多爆仓：价格跌破爆仓线
|
||
if price <= liquidation_price:
|
||
logger.warning(f"做多爆仓！开仓价={entry_price:.2f}, 当前价={price:.2f}, 爆仓线={liquidation_price:.2f}")
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(abs(position), 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': 0
|
||
})
|
||
continue
|
||
elif position_type == 'short':
|
||
# 做空爆仓：价格涨破爆仓线
|
||
if price >= liquidation_price:
|
||
logger.warning(f"做空爆仓！开仓价={entry_price:.2f}, 当前价={price:.2f}, 爆仓线={liquidation_price:.2f}")
|
||
is_liquidated = True
|
||
capital = 0
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(liquidation_price, 4),
|
||
'amount': round(abs(position), 4),
|
||
'profit': round(-initial_capital, 2),
|
||
'balance': 0
|
||
})
|
||
position = 0
|
||
position_type = None
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': 0
|
||
})
|
||
continue
|
||
|
||
# 记录权益
|
||
if position_type == 'long':
|
||
# 多头权益 = 现金 + 未实现盈亏
|
||
# 未实现盈亏 = (当前价 - 开仓价) × 股数
|
||
unrealized_pnl = (price - entry_price) * position
|
||
total_value = capital + unrealized_pnl
|
||
elif position_type == 'short':
|
||
# 空头权益 = 现金 + 未实现盈亏
|
||
# 未实现盈亏 = (开仓价 - 当前价) × 股数
|
||
shares = abs(position)
|
||
unrealized_pnl = (entry_price - price) * shares
|
||
total_value = capital + unrealized_pnl
|
||
else:
|
||
total_value = capital
|
||
|
||
# 确保权益不为负（如果已经爆仓，在前面已经处理了）
|
||
if total_value < 0:
|
||
total_value = 0
|
||
|
||
equity_curve.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'value': round(total_value, 2)
|
||
})
|
||
|
||
# 回测结束时强制平仓
|
||
if position != 0:
|
||
timestamp = df.index[-1]
|
||
price = df.iloc[-1]['close']
|
||
|
||
if position > 0: # 平多
|
||
exec_price = price * (1 - slippage)
|
||
commission_fee = position * exec_price * commission
|
||
profit = (exec_price - entry_price) * position - commission_fee
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
# 记录平多交易
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_long',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(position, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
else: # 平空
|
||
exec_price = price * (1 + slippage)
|
||
shares = abs(position)
|
||
commission_fee = shares * exec_price * commission
|
||
profit = (entry_price - exec_price) * shares - commission_fee
|
||
|
||
# 检查是否爆仓
|
||
if capital + profit <= 0:
|
||
logger.warning(f"回测结束爆仓！平空亏损过大: 本金={capital:.2f}, 亏损={-profit:.2f}")
|
||
is_liquidated = True
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'liquidation',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(-capital, 2),
|
||
'balance': 0
|
||
})
|
||
capital = 0
|
||
else:
|
||
capital += profit
|
||
total_commission_paid += commission_fee
|
||
|
||
# 记录平空交易
|
||
trades.append({
|
||
'time': timestamp.strftime('%Y-%m-%d %H:%M'),
|
||
'type': 'close_short',
|
||
'price': round(exec_price, 4),
|
||
'amount': round(shares, 4),
|
||
'profit': round(profit, 2),
|
||
'balance': round(capital, 2)
|
||
})
|
||
|
||
# 更新权益曲线的最后一个值，包含强制平仓后的资金
|
||
if equity_curve:
|
||
equity_curve[-1]['value'] = round(capital, 2)
|
||
|
||
return equity_curve, trades, total_commission_paid
|
||
|
||
def _calculate_metrics(
|
||
self,
|
||
equity_curve: List,
|
||
trades: List,
|
||
initial_capital: float,
|
||
timeframe: str,
|
||
start_date: datetime,
|
||
end_date: datetime,
|
||
total_commission: float = 0
|
||
) -> Dict:
|
||
"""计算回测指标"""
|
||
if not equity_curve:
|
||
return {}
|
||
|
||
final_value = equity_curve[-1]['value']
|
||
total_return = (final_value - initial_capital) / initial_capital * 100
|
||
|
||
# 计算年化收益：使用简单年化而不是复利年化
|
||
# 对于高收益率策略，复利年化会产生天文数字，不具备参考价值
|
||
actual_days = (end_date - start_date).total_seconds() / 86400
|
||
years = actual_days / 365.0
|
||
|
||
# 简单年化：年化收益率 = 总收益率 / 年数
|
||
if years > 0:
|
||
annual_return = total_return / years
|
||
else:
|
||
annual_return = 0
|
||
|
||
# 计算最大回撤
|
||
values = [e['value'] for e in equity_curve]
|
||
max_drawdown = self._calculate_max_drawdown(values)
|
||
|
||
# 计算夏普比率
|
||
sharpe = self._calculate_sharpe(values, timeframe)
|
||
|
||
# 计算总盈亏：用最终权益减去初始资金（最准确）
|
||
total_profit = final_value - initial_capital
|
||
|
||
# 计算胜率（包含所有平仓操作）
|
||
# 平仓操作：profit != 0 的交易
|
||
closing_trades = [t for t in trades if t.get('profit', 0) != 0]
|
||
win_trades = [t for t in closing_trades if t['profit'] > 0]
|
||
loss_trades = [t for t in closing_trades if t['profit'] < 0]
|
||
total_trades = len(closing_trades)
|
||
win_rate = len(win_trades) / total_trades * 100 if total_trades > 0 else 0
|
||
|
||
# 计算盈亏比（Profit Factor = 总盈利 / 总亏损）
|
||
total_wins = sum(t['profit'] for t in win_trades)
|
||
total_losses = abs(sum(t['profit'] for t in loss_trades))
|
||
profit_factor = total_wins / total_losses if total_losses > 0 else (total_wins if total_wins > 0 else 0)
|
||
|
||
return {
|
||
'totalReturn': round(total_return, 2),
|
||
'annualReturn': round(annual_return, 2),
|
||
'maxDrawdown': round(max_drawdown, 2),
|
||
'sharpeRatio': round(sharpe, 2),
|
||
'winRate': round(win_rate, 2),
|
||
'profitFactor': round(profit_factor, 2),
|
||
'totalTrades': total_trades,
|
||
'totalProfit': round(total_profit, 2),
|
||
'totalCommission': round(total_commission, 2)
|
||
}
|
||
|
||
def _calculate_max_drawdown(self, values: List[float]) -> float:
|
||
"""计算最大回撤"""
|
||
if not values:
|
||
return 0
|
||
|
||
peak = values[0]
|
||
max_dd = 0
|
||
|
||
for value in values:
|
||
if value > peak:
|
||
peak = value
|
||
dd = (peak - value) / peak * 100
|
||
if dd > max_dd:
|
||
max_dd = dd
|
||
|
||
return -max_dd
|
||
|
||
def _calculate_sharpe(self, values: List[float], timeframe: str = '1D', risk_free_rate: float = 0.02) -> float:
|
||
"""
|
||
计算夏普比率
|
||
|
||
Args:
|
||
values: 权益曲线数值列表
|
||
timeframe: 时间周期
|
||
risk_free_rate: 无风险收益率（年化）
|
||
"""
|
||
if len(values) < 2:
|
||
return 0
|
||
|
||
# 过滤掉0值（爆仓后的数据），避免除以0
|
||
valid_values = [v for v in values if v > 0]
|
||
if len(valid_values) < 2:
|
||
return 0
|
||
|
||
# 根据时间周期确定年化系数
|
||
annualization_factor = {
|
||
'1m': 252 * 24 * 60, # 分钟K：约362,880
|
||
'5m': 252 * 24 * 12, # 5分钟K：约72,576
|
||
'15m': 252 * 24 * 4, # 15分钟K：约24,192
|
||
'30m': 252 * 24 * 2, # 30分钟K：约12,096
|
||
'1H': 252 * 24, # 小时K：6,048
|
||
'4H': 252 * 6, # 4小时K：1,512
|
||
'1D': 252, # 日K：252
|
||
'1W': 52 # 周K：52
|
||
}.get(timeframe, 252)
|
||
|
||
try:
|
||
# 计算周期收益率
|
||
returns = np.diff(valid_values) / valid_values[:-1]
|
||
|
||
# 过滤无效值
|
||
returns = returns[np.isfinite(returns)]
|
||
if len(returns) == 0:
|
||
return 0
|
||
|
||
# 年化平均收益率
|
||
avg_return = np.mean(returns) * annualization_factor
|
||
|
||
# 年化标准差（波动率）
|
||
std_return = np.std(returns) * np.sqrt(annualization_factor)
|
||
|
||
if std_return == 0 or not np.isfinite(std_return):
|
||
return 0
|
||
|
||
# 夏普比率 = (年化收益 - 无风险利率) / 年化波动率
|
||
sharpe = (avg_return - risk_free_rate) / std_return
|
||
return sharpe if np.isfinite(sharpe) else 0
|
||
except Exception as e:
|
||
logger.warning(f"夏普比率计算失败: {e}")
|
||
return 0
|
||
|
||
def _format_result(
|
||
self,
|
||
metrics: Dict,
|
||
equity_curve: List,
|
||
trades: List
|
||
) -> Dict[str, Any]:
|
||
"""格式化回测结果"""
|
||
# 精简权益曲线
|
||
max_points = 500
|
||
if len(equity_curve) > max_points:
|
||
step = len(equity_curve) // max_points
|
||
equity_curve = equity_curve[::step]
|
||
|
||
# 清理数据中的NaN、Inf值，确保可以被JSON序列化
|
||
def clean_value(value):
|
||
"""清理数值，将NaN/Inf转换为0"""
|
||
if isinstance(value, float):
|
||
if np.isnan(value) or np.isinf(value):
|
||
return 0
|
||
return value
|
||
|
||
# 清理metrics
|
||
cleaned_metrics = {}
|
||
for key, value in metrics.items():
|
||
cleaned_metrics[key] = clean_value(value)
|
||
|
||
# 清理equity_curve
|
||
cleaned_curve = []
|
||
for item in equity_curve:
|
||
cleaned_curve.append({
|
||
'time': item['time'],
|
||
'value': clean_value(item['value'])
|
||
})
|
||
|
||
# 清理trades
|
||
cleaned_trades = []
|
||
# 不截断交易记录：有多少条就返回多少条（前端可自行分页展示）
|
||
for trade in trades:
|
||
cleaned_trade = {}
|
||
for key, value in trade.items():
|
||
cleaned_trade[key] = clean_value(value)
|
||
cleaned_trades.append(cleaned_trade)
|
||
|
||
return {
|
||
**cleaned_metrics,
|
||
'equityCurve': cleaned_curve,
|
||
'trades': cleaned_trades
|
||
}
|
||
|