""" 回测服务 """ 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 }