""" AgentSignalStrategy - 读取 Agent 团队生成的信号，由 Freqtrade 执行交易 工作模式: 1. Live/Dry-run: 读取 signal.json 中的 Agent 信号 → 执行交易 2. 回测: 使用简单技术指标规则生成信号 (模拟 Agent 决策) 核心回调: - populate_indicators: 计算基础指标 - populate_entry_trend: 入场信号 (Agent 信号 或 回测规则) - populate_exit_trend: 出场信号 - custom_stoploss: 动态止损 + 移动止盈 - custom_exit: 最终止盈级别全仓平仓 - adjust_trade_position: 分批止盈减仓 - custom_stake_amount: Agent 仓位控制 - leverage: 杠杆控制 """ import json import logging from datetime import datetime, timezone from pathlib import Path import pandas_ta # noqa: F401 from freqtrade.strategy import IStrategy, DecimalParameter from pandas import DataFrame logger = logging.getLogger(__name__) SIGNAL_FILE = Path("data/output/signals/signal.json") def _ensure_utc(dt: datetime) -> datetime: """确保 datetime 带 UTC 时区信息""" if dt.tzinfo is None: return dt.replace(tzinfo=timezone.utc) return dt class AgentSignalStrategy(IStrategy): """读取 Agent 团队生成的信号，由 Freqtrade 执行交易""" INTERFACE_VERSION = 3 can_short = True # ROI (回测用，实盘由 Agent 信号控制) minimal_roi = {"0": 0.20, "120": 0.10, "240": 0.05, "480": 0.02} stoploss = -0.05 trailing_stop = False timeframe = "5m" process_only_new_candles = True startup_candle_count = 100 # 需要 100 根 K 线热身 # 移动止盈参数 (可 Hyperopt 优化) ts_profit_1 = DecimalParameter(0.03, 0.08, default=0.05, space="sell") ts_profit_2 = DecimalParameter(0.08, 0.15, default=0.10, space="sell") ts_profit_3 = DecimalParameter(0.15, 0.30, default=0.20, space="sell") def __init__(self, config: dict | None = None) -> None: if config is not None: super().__init__(config) # 信号缓存（基于文件 mtime，避免每根 K 线重复读磁盘） self._signal_cache: list[dict] = [] self._signal_mtime: float = 0.0 def _read_signals(self) -> list[dict]: """读取并过滤有效信号（带 mtime 缓存）""" if not SIGNAL_FILE.exists(): return [] mtime = SIGNAL_FILE.stat().st_mtime if mtime == self._signal_mtime and self._signal_cache is not None: return self._signal_cache try: data = json.loads(SIGNAL_FILE.read_text()) now = datetime.now(timezone.utc) self._signal_cache = [ s for s in data.get("signals", []) if _ensure_utc(datetime.fromisoformat(s["expires_at"])) > now ] self._signal_mtime = mtime return self._signal_cache except (json.JSONDecodeError, KeyError, ValueError) as e: logger.warning(f"读取信号失败: {e}") return [] def _get_signal_for_pair(self, pair: str) -> dict | None: """获取指定交易对的信号""" symbol = pair.replace("/", "").replace(":USDT", "") for s in self._read_signals(): if s["symbol"] == symbol: return s return None def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """计算指标 (回测和实盘通用)""" # EMA dataframe["ema_7"] = dataframe.ta.ema(length=7) dataframe["ema_25"] = dataframe.ta.ema(length=25) dataframe["ema_99"] = dataframe.ta.ema(length=99) # RSI dataframe["rsi"] = dataframe.ta.rsi(length=14) # MACD macd = dataframe.ta.macd(fast=12, slow=26, signal=9) if macd is not None: dataframe["macd"] = macd.iloc[:, 0] dataframe["macd_signal"] = macd.iloc[:, 1] dataframe["macd_hist"] = macd.iloc[:, 2] # Bollinger Bands bbands = dataframe.ta.bbands(length=20, std=2) if bbands is not None: dataframe["bb_lower"] = bbands.iloc[:, 0] dataframe["bb_mid"] = bbands.iloc[:, 1] dataframe["bb_upper"] = bbands.iloc[:, 2] # ATR dataframe["atr"] = dataframe.ta.atr(length=14) # Volume EMA dataframe["volume_ema"] = dataframe.ta.ema(close=dataframe["volume"], length=20) return dataframe def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """入场信号""" dataframe.loc[:, "enter_long"] = 0 dataframe.loc[:, "enter_short"] = 0 # --- 模式 1: 读取 Agent 信号 (实盘/模拟盘) --- signal = self._get_signal_for_pair(metadata["pair"]) if signal is not None: # P8: 入场价格范围检查 entry_range = signal.get("entry_price_range") if entry_range and len(entry_range) == 2: current_price = dataframe["close"].iloc[-1] low, high = entry_range tolerance = (high - low) * 0.15 # 15% 容差 if not (low - tolerance <= current_price <= high + tolerance): logger.info( "[Agent] %s 价格 %.2f 不在范围 [%.2f, %.2f]±15%%, 跳过", metadata["pair"], current_price, low, high, ) return dataframe if signal["action"] == "long": dataframe.loc[dataframe.index[-1], "enter_long"] = 1 logger.info( f"[Agent] {metadata['pair']} LONG " f"置信度={signal.get('confidence')} " f"杠杆={signal.get('leverage')}" ) elif signal["action"] == "short": dataframe.loc[dataframe.index[-1], "enter_short"] = 1 logger.info( f"[Agent] {metadata['pair']} SHORT " f"置信度={signal.get('confidence')} " f"杠杆={signal.get('leverage')}" ) return dataframe # --- 模式 2: 规则化信号 (回测用) --- # 做多条件: EMA 多头排列 + RSI 超卖回升 + MACD 金叉 dataframe.loc[ ( (dataframe["ema_7"] > dataframe["ema_25"]) & (dataframe["ema_25"] > dataframe["ema_99"]) & (dataframe["rsi"] > 30) & (dataframe["rsi"] < 70) & (dataframe["macd_hist"] > 0) & (dataframe["macd_hist"].shift(1) <= 0) & (dataframe["volume"] > dataframe["volume_ema"]) ), "enter_long", ] = 1 # 做空条件: EMA 空头排列 + RSI 超买回落 + MACD 死叉 dataframe.loc[ ( (dataframe["ema_7"] < dataframe["ema_25"]) & (dataframe["ema_25"] < dataframe["ema_99"]) & (dataframe["rsi"] < 70) & (dataframe["rsi"] > 30) & (dataframe["macd_hist"] < 0) & (dataframe["macd_hist"].shift(1) >= 0) & (dataframe["volume"] > dataframe["volume_ema"]) ), "enter_short", ] = 1 return dataframe def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """出场信号""" dataframe.loc[:, "exit_long"] = 0 dataframe.loc[:, "exit_short"] = 0 # Agent 平仓信号 signal = self._get_signal_for_pair(metadata["pair"]) if signal is not None: if signal["action"] == "close_long": dataframe.loc[dataframe.index[-1], "exit_long"] = 1 elif signal["action"] == "close_short": dataframe.loc[dataframe.index[-1], "exit_short"] = 1 return dataframe # 回测规则出场 # 多单出场: RSI 超买 或 EMA 死叉 dataframe.loc[ (dataframe["rsi"] > 75) | (dataframe["ema_7"] < dataframe["ema_25"]), "exit_long", ] = 1 # 空单出场: RSI 超卖 或 EMA 金叉 dataframe.loc[ (dataframe["rsi"] < 25) | (dataframe["ema_7"] > dataframe["ema_25"]), "exit_short", ] = 1 return dataframe def custom_stoploss( self, pair: str, trade, current_time: datetime, current_rate: float, current_profit: float, after_fill: bool, **kwargs, ) -> float: """动态止损 + 移动止盈 优先级: 1. Agent trailing_stop_pct (AI 推荐的尾随比例，盈利 > 2% 后激活) 2. Agent 固定止损价 3. 三档移动止盈 4. 默认止损 """ signal = self._get_signal_for_pair(pair) # 优先级 1: Agent 尾随止盈（盈利 > 2% 后激活） if signal and signal.get("trailing_stop_pct") and current_profit > 0.02: trail_pct = signal["trailing_stop_pct"] / 100 return -(current_profit - trail_pct) # 优先级 1.5: MFE 自适应尾随 (ATR-based) # 浮盈 >= 2×ATR 后保本，之后每 1×ATR 收紧止损 if signal and current_profit > 0 and trade: atr_val = None atr_pct = signal.get("atr_pct") if atr_pct: atr_val = atr_pct / 100 elif hasattr(trade, "pair"): # 从 dataframe 中获取 ATR (如有) try: dp = self.dp if dp: df = dp.get_pair_dataframe(trade.pair, self.timeframe) if df is not None and "atr" in df.columns and len(df) > 0: last_atr = df["atr"].iloc[-1] last_close = df["close"].iloc[-1] if last_close > 0 and last_atr > 0: atr_val = last_atr / last_close except Exception: pass if atr_val and atr_val > 0: trigger = atr_val * 2 if current_profit >= trigger: trail_steps = int((current_profit - trigger) / atr_val) # 保本 + 阶梯收紧 (每步收紧 0.5×ATR) tightened = trail_steps * atr_val * 0.5 new_sl = -(current_profit - 0.001 - tightened) return min(new_sl, self.stoploss) # 优先级 2: Agent 固定止损价 if signal and signal.get("stop_loss") and trade: sl_price = signal["stop_loss"] if trade.is_short: sl_pct = (sl_price - current_rate) / current_rate else: sl_pct = (current_rate - sl_price) / current_rate if sl_pct > 0: return -sl_pct else: # 价格已穿越止损价，立即触发止损 return self.stoploss # 优先级 3: 移动止盈（三档尾随） # 若有 AI take_profit 且未全部执行完，跳过固定尾随（避免与分批止盈冲突） if signal and signal.get("take_profit") and trade: tp_list = signal["take_profit"] filled_orders = trade.orders or [] all_tp_filled = all( any( o.ft_order_tag == f"tp_{i}_{tp.get('price')}" and o.ft_is_open is False for o in filled_orders ) for i, tp in enumerate(tp_list[:-1]) ) if len(tp_list) >= 2 else True if not all_tp_filled: return self.stoploss # 全部 TP 完成后，保护尾随 if current_profit > 0.03: return -(current_profit - 0.02) if current_profit > self.ts_profit_3.value: # > 20%: 尾随 3%（收紧保护） return -(current_profit - 0.03) elif current_profit > self.ts_profit_2.value: # > 10%: 尾随 5% return -(current_profit - 0.05) elif current_profit > self.ts_profit_1.value: # > 5%: 移至成本线 return -0.001 return self.stoploss def custom_exit( self, pair: str, trade, current_time: datetime, current_rate: float, current_profit: float, **kwargs, ) -> str | None: """最终止盈级别全仓平仓 分批止盈的中间级别由 adjust_trade_position 减仓处理， 最后一级在这里触发全部平仓。 """ signal = self._get_signal_for_pair(pair) if not signal or not signal.get("take_profit"): return None tp_list = signal["take_profit"] if not tp_list: return None # 最后一级止盈 → 全仓平仓 last_tp = tp_list[-1] tp_price = last_tp.get("price") if tp_price is None: return None hit = (not trade.is_short and current_rate >= tp_price) or \ (trade.is_short and current_rate <= tp_price) if hit: return f"take_profit_full_{tp_price}" return None def adjust_trade_position( self, trade, current_time: datetime, current_rate: float, current_profit: float, min_stake: float, max_stake: float, current_entry_rate: float, current_exit_rate: float, current_entry_profit: float, current_exit_profit: float, **kwargs, ) -> float | None: """分批止盈：按 AI 信号的 take_profit 列表逐级减仓 返回负数表示减仓金额。最后一级由 custom_exit 全平。 """ signal = self._get_signal_for_pair(trade.pair) if not signal or not signal.get("take_profit"): return None tp_list = signal["take_profit"] if len(tp_list) < 2: # 只有一级止盈，由 custom_exit 全平处理 return None filled_orders = trade.orders or [] # 遍历除最后一级外的所有止盈级别 for i, tp in enumerate(tp_list[:-1]): tp_price = tp.get("price") tp_pct = tp.get("pct", 50) if tp_price is None: continue hit = (not trade.is_short and current_rate >= tp_price) or \ (trade.is_short and current_rate <= tp_price) # 检查是否已对该级别执行过减仓 tag = f"tp_{i}_{tp_price}" already_filled = any( o.ft_order_tag == tag for o in filled_orders if o.ft_is_open is False ) if hit and not already_filled: # P4: 基于剩余仓位计算减仓量 total_tp_pct_filled = sum( tp_list[j].get("pct", 0) for j in range(i) if any( o.ft_order_tag == f"tp_{j}_{tp_list[j].get('price')}" and o.ft_is_open is False for o in filled_orders ) ) remaining_pct = 100 - total_tp_pct_filled reduce_pct = min(tp_pct, remaining_pct) reduce_amount = trade.amount * current_rate / trade.leverage * reduce_pct / 100 logger.info( "[Agent] %s 分批止盈 TP%d @ %.2f, 减仓 %.1f%% (剩余 %.1f%%)", trade.pair, i + 1, tp_price, reduce_pct, remaining_pct, ) return -reduce_amount return None def custom_stake_amount( self, pair: str, current_time: datetime, current_rate: float, proposed_stake: float, min_stake: float | None, max_stake: float, leverage: float, entry_tag: str | None, side: str, **kwargs, ) -> float: """控制初始仓位大小""" min_stake_amount = min_stake if min_stake else 0 signal = self._get_signal_for_pair(pair) if signal and signal.get("position_size_usdt"): stake = min(signal["position_size_usdt"], max_stake) return max(stake, min_stake_amount) return max(proposed_stake, min_stake_amount) def leverage( self, pair: str, current_time: datetime, current_rate: float, proposed_leverage: float, max_leverage: float, entry_tag: str | None, side: str, **kwargs, ) -> float: """杠杆控制 优先读取 Agent 信号杠杆，否则使用默认值。 硬上限从 signal.max_leverage → settings.yaml → 5x 依次 fallback。 """ signal = self._get_signal_for_pair(pair) # 确定杠杆硬上限: signal.max_leverage → settings → 5 hard_limit = 5.0 if signal and signal.get("max_leverage"): hard_limit = float(signal["max_leverage"]) else: try: import yaml with open("config/settings.yaml") as f: settings = yaml.safe_load(f) or {} hard_limit = float( settings.get("risk", {}).get("max_leverage", 5) ) except Exception: pass if signal and signal.get("leverage"): lev = float(signal["leverage"]) return min(lev, max_leverage, hard_limit) return min(3.0, max_leverage, hard_limit)