phyer/myTestFreqAI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

live模式下动态获取可用usdt并确认stake_amount

Browse Source
This commit is contained in:
zhangkun9038@dingtalk.com 2025-10-08 23:42:22 +08:00
parent b688f82c4c
commit 467ae7639d
1 changed files with 257 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

371
freqtrade/templates/freqaiprimer.py
View File

@ -8,7 +8,6 @@ import pandas_ta as ta
from freqtrade.persistence import Trade
import numpy as np
import datetime
import pandas as pd
import math
logger = logging.getLogger(__name__)
@ -28,11 +27,165 @@ class FreqaiPrimer(IStrategy):
# 用于跟踪市场状态的数据框缓存
_dataframe_cache = None
# 用于存储币对的波动系数
_volatility_coefficients = {}
# 基准币对 (波动系数设为1.0)
_benchmark_pair = 'BTC/USDT'
# 稳定币列表 (波动系数设为0.0)
_stablecoins = ['USDT', 'USDC', 'BUSD', 'DAI', 'TUSD', 'USDP', 'GUSD', 'USTC']
# 波动系数缓存有效期 (分钟)
_volatility_cache_ttl = 60
# 上次计算波动系数的时间
_last_volatility_calculation = 0
def __init__(self, config=None):
"""初始化策略参数，调用父类初始化方法并接受config参数"""
super().__init__(config) # 调用父类的初始化方法并传递config
# 存储从配置文件加载的默认值
self._trailing_stop_positive_default = 0.004 # 降低默认值以更容易触发跟踪止盈
# 初始化基准币对和稳定币的波动系数
self._volatility_coefficients[self._benchmark_pair] = 1.0
for stablecoin in self._stablecoins:
# 处理所有稳定币交易对，如USDT/USDC等
for quote in self._stablecoins:
if stablecoin != quote:
pair = f'{stablecoin}/{quote}'
self._volatility_coefficients[pair] = 0.0
def _is_stablecoin_pair(self, pair: str) -> bool:
"""
判断一个交易对是否为稳定币交易对
参数:
- pair: 交易对，如 BTC/USDT
返回:
- bool: 是否为稳定币交易对
"""
try:
base, quote = pair.split('/')
return base in self._stablecoins and quote in self._stablecoins
except ValueError:
return False
def _calculate_volatility(self, pair: str, lookback_period: int = 200, timeframe: str = '1h') -> float:
"""
计算一个币对的波动率
参数:
- pair: 交易对，如 BTC/USDT
- lookback_period: 回看期K线数量，默认200
- timeframe: 时间框架，默认1h
返回:
- float: 波动率值
"""
try:
# 获取K线数据
dataframe = self.dp.get_pair_dataframe(pair=pair, timeframe=timeframe)
# 确保有足够的K线数据
if len(dataframe) < lookback_period:
logger.warning(f"[{pair}] 没有足够的{timeframe} K线数据，需要{lookback_period}根，当前只有{len(dataframe)}根")
# 如果数据不足，返回0.0或默认值
return 0.0
# 获取最近的K线数据
recent_data = dataframe.iloc[-lookback_period:].copy()
# 计算收益率 (收盘价变化百分比)
recent_data['returns'] = recent_data['close'].pct_change()
# 计算对数收益率 (更适合波动率计算)
recent_data['log_returns'] = np.log(recent_data['close'] / recent_data['close'].shift(1))
# 使用对数收益率的标准差作为波动率指标
volatility = recent_data['log_returns'].std() * np.sqrt(24) # 年化波动率 (假设1天24小时)
return volatility
except Exception as e:
logger.error(f"[{pair}] 计算波动率时出错: {str(e)}")
return 0.0
def _calculate_relative_volatility_coefficient(self, pair: str) -> float:
"""
计算相对波动系数（以BTC/USDT为基准）
参数:
- pair: 交易对，如 ETH/USDT
返回:
- float: 相对波动系数
"""
try:
# 检查是否为稳定币交易对
if self._is_stablecoin_pair(pair):
return 0.0
# 检查是否为基准币对
if pair == self._benchmark_pair:
return 1.0
# 计算当前币对的波动率
pair_volatility = self._calculate_volatility(pair)
# 计算基准币对的波动率
benchmark_volatility = self._calculate_volatility(self._benchmark_pair)
# 避免除以0的情况
if benchmark_volatility == 0:
logger.warning(f"基准币对 {self._benchmark_pair} 的波动率为0，无法计算相对波动系数")
return 0.0
# 计算相对波动系数
relative_coefficient = pair_volatility / benchmark_volatility
return relative_coefficient
except Exception as e:
logger.error(f"[{pair}] 计算相对波动系数时出错: {str(e)}")
return 0.0
def get_volatility_coefficient(self, pair: str) -> float:
"""
获取币对的波动系数（带缓存机制）
参数:
- pair: 交易对，如 ETH/USDT
返回:
- float: 波动系数（稳定币为0.0，BTC/USDT为1.0，其他币对相对于BTC波动程度）
"""
try:
# 优先从缓存中获取，无需每次都检查时间戳
# 这确保了在同一交易周期内多次调用时直接返回缓存值
if pair in self._volatility_coefficients:
# 检查是否为基准币对或稳定币对（它们的波动系数固定）
if pair == self._benchmark_pair or self._is_stablecoin_pair(pair):
return self._volatility_coefficients[pair]
# 获取当前时间戳（分钟）
current_time = int(datetime.datetime.now().timestamp() / 60)
# 对于非固定波动系数的币对，检查缓存是否有效
if current_time - self._last_volatility_calculation < self._volatility_cache_ttl:
return self._volatility_coefficients[pair]
# 计算新的波动系数
coefficient = self._calculate_relative_volatility_coefficient(pair)
# 更新缓存
self._volatility_coefficients[pair] = coefficient
# 如果是首次计算或者缓存已过期，更新最后计算时间
current_time = int(datetime.datetime.now().timestamp() / 60)
if current_time - self._last_volatility_calculation >= self._volatility_cache_ttl:
self._last_volatility_calculation = current_time
# 日志记录
logger.info(f"更新了波动系数缓存，当前时间: {current_time}, 上一次计算时间: {self._last_volatility_calculation}")
# 日志记录 - 仅在计算新值时记录
logger.info(f"[{pair}] 波动系数: {coefficient:.4f}")
return coefficient
except Exception as e:
logger.error(f"[{pair}] 获取波动系数时出错: {str(e)}")
# 如果出错，返回默认值1.0（假设与BTC波动相当）
return 1.0
@property
def protections(self):
@ -83,30 +236,32 @@ class FreqaiPrimer(IStrategy):
# 自定义指标参数 - 使用Hyperopt可优化参数
bb_length = IntParameter(10, 30, default=20, optimize=True, load=True, space='buy')
bb_std = DecimalParameter(1.5, 3.0, decimals=1, default=2.0, optimize=False, load=True, space='buy')
rsi_length = IntParameter(7, 21, default=14, optimize=False, load=True, space='buy')
bb_std = DecimalParameter(1.5, 3.0, decimals=1, default=2.0, optimize=True, load=True, space='buy')
rsi_length = IntParameter(7, 21, default=14, optimize=True, load=True, space='buy')
rsi_oversold = IntParameter(30, 50, default=42, optimize=True, load=True, space='buy')
# 入场条件阈值参数
bb_lower_deviation = DecimalParameter(1.01, 1.05, decimals=2, default=1.03, optimize=True, load=True, space='buy')
rsi_bull_threshold = IntParameter(45, 55, default=50, optimize=False, load=True, space='buy')
stochrsi_bull_threshold = IntParameter(30, 40, default=35, optimize=False, load=True, space='buy')
rsi_bull_threshold = IntParameter(45, 55, default=50, optimize=True, load=True, space='buy')
stochrsi_bull_threshold = IntParameter(30, 40, default=35, optimize=True, load=True, space='buy')
stochrsi_neutral_threshold = IntParameter(20, 30, default=25, optimize=True, load=True, space='buy')
volume_multiplier = DecimalParameter(1.2, 2.0, decimals=1, default=1.5, optimize=False, load=True, space='buy')
bb_width_threshold = DecimalParameter(0.01, 0.03, decimals=3, default=0.02, optimize=False, load=True, space='buy')
volume_multiplier = DecimalParameter(1.2, 2.0, decimals=1, default=1.5, optimize=True, load=True, space='buy')
bb_width_threshold = DecimalParameter(0.01, 0.03, decimals=3, default=0.02, optimize=True, load=True, space='buy')
min_condition_count = IntParameter(2, 4, default=3, optimize=True, load=True, space='buy')
# 剧烈拉升检测参数 - 使用Hyperopt可优化参数
h1_max_candles = IntParameter(100, 300, default=200, optimize=False, load=True, space='buy')
h1_max_candles = IntParameter(100, 300, default=200, optimize=True, load=True, space='buy')
h1_rapid_rise_threshold = DecimalParameter(0.05, 0.15, decimals=3, default=0.11, optimize=True, load=True, space='buy')
h1_max_consecutive_candles = IntParameter(1, 4, default=2, optimize=False, load=True, space='buy')
h1_max_consecutive_candles = IntParameter(1, 4, default=2, optimize=True, load=True, space='buy')
# 定义可优化参数
max_entry_adjustments = IntParameter(2, 5, default=3, optimize=False, load=True, space='buy') # 最大加仓次数
add_position_callback = DecimalParameter(0.03, 0.06, decimals=3, default=0.053, optimize=True, load=True, space='buy') # 加仓回调百分比
stake_divisor = DecimalParameter(2, 4, decimals=3, default=2.867, optimize=True, load=True, space='buy') # 加仓金额分母
step_coefficient = DecimalParameter(0.5, 1.5, decimals=2, default=0.92, optimize=True, load=True, space='buy') # 加仓金额分母
# -m 4 -c 0.045 -g 4.5 -p 1.22 -d 9.3 -s 75
max_entry_adjustments = IntParameter(2, 5, default=3, optimize=True, load=True, space='buy') # 最大加仓次数
add_position_callback = DecimalParameter(0.02, 0.06, decimals=3, default=0.045, optimize=True, load=True, space='buy') # 加仓回调百分比
add_position_growth = DecimalParameter(1.5, 3.0, decimals=2, default=4.5, optimize=False, load=True, space='buy') # 加仓金额增长因子，保留2位小数用于hyperopt优化
add_position_multiplier = DecimalParameter(0.2, 10.5, decimals=2, default=1.22, optimize=False, load=True, space='buy') # 加仓间隔系数，保留2位小数用于hyperopt优化
stake_divisor = DecimalParameter(2.0, 12.0, decimals=2, default=9.3, optimize=False, load=True, space='buy') # 加仓金额分母（小数类型，保留2位小数）
# 线性ROI参数 - 用于线性函数: y = (a * (x + k)) + t
roi_param_a = DecimalParameter(-0.0002, -0.00005, decimals=5, default=-0.0001, optimize=True, load=True, space='sell') # 系数a
@ -116,14 +271,7 @@ class FreqaiPrimer(IStrategy):
exit_bb_upper_deviation = DecimalParameter(0.98, 1.02, decimals=2, default=1.0, optimize=True, load=True, space='sell')
exit_volume_multiplier = DecimalParameter(1.5, 3.0, decimals=1, default=2.0, optimize=True, load=True, space='sell')
rsi_overbought = IntParameter(57, 59, default=58, optimize=True, load=True, space='sell')
# 新增的可优化参数 - 用于should_exit逻辑
rsi_overbought_level = IntParameter(60, 80, default=70, optimize=True, load=True, space='sell')
macd_cross_threshold = DecimalParameter(0.0, 0.005, decimals=4, default=0.001, optimize=True, load=True, space='sell')
volume_spike_multiplier = DecimalParameter(2.0, 4.0, decimals=1, default=3.0, optimize=True, load=True, space='sell')
volume_drop_multiplier = DecimalParameter(0.1, 0.5, decimals=2, default=0.3, optimize=True, load=True, space='sell')
cci_overbought_level = IntParameter(150, 250, default=200, optimize=True, load=True, space='sell')
rsi_overbought = IntParameter(50, 70, default=58, optimize=True, load=True, space='sell')
def informative_pairs(self):
@ -138,20 +286,7 @@ class FreqaiPrimer(IStrategy):
missing_columns = [col for col in required_columns if col not in dataframe.columns]
if missing_columns:
logger.warning(f"[{metadata['pair']}] 数据框中缺少以下列: {missing_columns}")
def custom_stake_amount(self, pair: str, current_time: pd.Timestamp,
current_rate: float,
proposed_stake: float,
min_stake: float,
max_stake: float,
**kwargs) -> float:
# 获取初始资金（回测中固定为dry_run_wallet的值）
initial_balance = self.config.get('dry_run_wallet', 10000)
# 始终以初始资金的3.75%计算
desired_stake = initial_balance * 0.0375
desired_stake = math.floor(desired_stake) # 取整，去掉小数点后的数字
return max(min(desired_stake, max_stake), min_stake)
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# 计算 3m 周期的指标
bb_length_value = self.bb_length.value
@ -317,9 +452,9 @@ class FreqaiPrimer(IStrategy):
dataframe['prev_market_state'] = dataframe['prev_market_state'].fillna('neutral')
# 记录当前的市场状态
# if len(dataframe) > 0:
# current_score = dataframe['market_score'].iloc[-1]
# current_state = dataframe['market_state'].iloc[-1]
if len(dataframe) > 0:
current_score = dataframe['market_score'].iloc[-1]
current_state = dataframe['market_state'].iloc[-1]
#logger.info(f"[{metadata['pair']}] 熊牛得分: {current_score:.1f}, 市场状态: {current_state}")
#logger.info(f"[{metadata['pair']}] 各时间框架趋势: 3m={'牛' if dataframe['trend_3m'].iloc[-1] == 1 else '熊'}, \
# 15m={'牛' if dataframe['trend_15m'].iloc[-1] == 1 else '熊'}, \
@ -337,28 +472,7 @@ class FreqaiPrimer(IStrategy):
return dataframe
def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# 计算额外需要的指标
# 前一根K线的指标值
dataframe['rsi_1h_prev'] = dataframe['rsi_1h'].shift(1)
dataframe['macd_1h_prev'] = dataframe['macd_1h'].shift(1)
dataframe['macd_signal_1h_prev'] = dataframe['macd_signal_1h'].shift(1)
# 下一根K线的成交量
dataframe['volume_next'] = dataframe['volume'].shift(-1)
# 计算EMA指标
dataframe['ema_5_1h'] = ta.ema(dataframe['close'], length=5)
dataframe['ema_10_1h'] = ta.ema(dataframe['close'], length=10)
# 计算CCI指标
dataframe['cci_1h'] = ta.cci(dataframe['high'], dataframe['low'], dataframe['close'], length=14)
dataframe['cci_1h_prev'] = dataframe['cci_1h'].shift(1)
# 计算抛物线SAR指标 - 修复ValueError错误，提取正确的列
sar_result = ta.psar(dataframe['high'], dataframe['low'], acceleration=0.02, maximum=0.2)
# pandas_ta的psar函数返回DataFrame，我们需要选择正确的列
dataframe['sar_1h'] = sar_result.iloc[:, 0] # 选择第一列作为SAR值
# 原有出场条件
# 出场信号基于趋势和量价关系
# 条件1: 价格突破布林带上轨（使用可优化的偏差参数）
breakout_condition = dataframe['close'] >= dataframe['bb_upper_1h'] * self.exit_bb_upper_deviation.value
@ -369,45 +483,22 @@ class FreqaiPrimer(IStrategy):
macd_downward = dataframe['macd_1h'] < dataframe['macd_signal_1h']
# 条件4: RSI 进入超买区域（使用可优化的超买阈值）
rsi_overbought_old = dataframe['rsi_1h'] > self.rsi_overbought.value
# 新增的出场条件 - should_exit逻辑
# 条件1: MACD死叉 + RSI超买回落
macd_dead_cross = (dataframe['macd_1h_prev'] > dataframe['macd_signal_1h_prev']) & \
(dataframe['macd_1h'] <= dataframe['macd_signal_1h']) & \
(abs(dataframe['macd_1h'] - dataframe['macd_signal_1h']) >= self.macd_cross_threshold.value)
rsi_overbought_fallback = (dataframe['rsi_1h_prev'] > self.rsi_overbought_level.value) & \
(dataframe['rsi_1h'] < self.rsi_overbought_level.value)
exit_condition_1 = macd_dead_cross & rsi_overbought_fallback
# 条件2: 成交量异常放大后萎缩 + EMA死叉
volume_spike_new = dataframe['volume'] > dataframe['volume_ma'] * self.volume_spike_multiplier.value
volume_drop = dataframe['volume_next'] < dataframe['volume'] * self.volume_drop_multiplier.value
ema_dead_cross = dataframe['ema_5_1h'] < dataframe['ema_10_1h']
exit_condition_2 = volume_spike_new & volume_drop & ema_dead_cross
# 条件3: CCI超买回落 + 抛物线SAR反转
cci_overbought_fallback = (dataframe['cci_1h_prev'] > self.cci_overbought_level.value) & \
(dataframe['cci_1h'] < self.cci_overbought_level.value)
sar_reversal = dataframe['close'] < dataframe['sar_1h']
exit_condition_3 = cci_overbought_fallback & sar_reversal
rsi_overbought = dataframe['rsi_1h'] > self.rsi_overbought.value
# 合并所有条件
final_condition = (breakout_condition | volume_spike | macd_downward | rsi_overbought_old) | \
(exit_condition_1 | exit_condition_2 | exit_condition_3)
final_condition = breakout_condition | volume_spike | macd_downward | rsi_overbought
# 设置出场信号
dataframe.loc[final_condition, 'exit_long'] = 1
# 增强调试信息
#logger.info(f"[{metadata['pair']}] 出场条件检查:")
#logger.info(f" - 原有条件: 价格突破布林带上轨: {breakout_condition.sum()} 次, 成交量显著放大: {volume_spike.sum()} 次, MACD下降趋势: {macd_downward.sum()} 次, RSI超买: {rsi_overbought_old.sum()} 次")
#logger.info(f" - 新增条件1 (MACD死叉+RSI回落): {exit_condition_1.sum()} 次")
#logger.info(f" - 新增条件2 (放量缩量+EMA死叉): {exit_condition_2.sum()} 次")
#logger.info(f" - 新增条件3 (CCI回落+SAR反转): {exit_condition_3.sum()} 次")
#logger.info(f" - 价格突破布林带上轨: {breakout_condition.sum()} 次")
#logger.info(f" - 成交量显著放大: {volume_spike.sum()} 次")
#logger.info(f" - MACD 下降趋势: {macd_downward.sum()} 次")
#logger.info(f" - RSI 超买: {rsi_overbought.sum()} 次")
#logger.info(f" - 最终条件: {final_condition.sum()} 次")
#logger.info(f" - 使用参数: exit_bb_upper_deviation={self.exit_bb_upper_deviation.value}, exit_volume_multiplier={self.exit_volume_multiplier.value}, rsi_overbought={self.rsi_overbought.value}")
#logger.info(f" - 新增参数: rsi_overbought_level={self.rsi_overbought_level.value}, macd_cross_threshold={self.macd_cross_threshold.value}, volume_spike_multiplier={self.volume_spike_multiplier.value}, volume_drop_multiplier={self.volume_drop_multiplier.value}, cci_overbought_level={self.cci_overbought_level.value}")
# 日志记录
if dataframe['exit_long'].sum() > 0:
@ -586,32 +677,35 @@ class FreqaiPrimer(IStrategy):
# 获取当前市场状态
current_state = dataframe['market_state'].iloc[-1] if 'market_state' in dataframe.columns else 'unknown'
# 基础止损倍数
base_multiplier = 1.2
# 更激进的渐进式止损策略
if current_profit > 0.05: # 利润超过5%时
return -3.0 * atr / current_rate # 更大幅扩大止损范围，让利润奔跑
return -3.0 * base_multiplier * atr / current_rate
elif current_profit > 0.03: # 利润超过3%时
return -2.5 * atr / current_rate # 更中等扩大止损范围
return -2.5 * base_multiplier * atr / current_rate
elif current_profit > 0.01: # 利润超过1%时
return -2.0 * atr / current_rate # 更轻微扩大止损范围
return -2.0 * base_multiplier * atr / current_rate
# 在强劲牛市中，即使小亏损也可以容忍更大回调
if current_state == 'strong_bull' and current_profit > -0.01:
return -1.5 * atr / current_rate
return -1.5 * base_multiplier * atr / current_rate
# 动态调整止损范围
if current_profit > 0.05: # 利润超过5%时
return -3.0 * atr / current_rate # 更大幅扩大止损范围，让利润奔跑
return -3.0 * base_multiplier * atr / current_rate
elif current_profit > 0.03: # 利润超过3%时
return -2.5 * atr / current_rate # 更中等扩大止损范围
return -2.5 * base_multiplier * atr / current_rate
elif current_profit > 0.01: # 利润超过1%时
return -2.0 * atr / current_rate # 更轻微扩大止损范围
return -2.0 * base_multiplier * atr / current_rate
# 在强劲牛市中，即使小亏损也可以容忍更大回调
if current_state == 'strong_bull' and current_profit > -0.01:
return -1.8 * atr / current_rate
return -1.8 * base_multiplier * atr / current_rate
if atr > 0:
return -1.2 * atr / current_rate # 基础1.2倍ATR止损
return -base_multiplier * atr / current_rate
return self.stoploss
def custom_exit(self, pair: str, trade: Trade, current_time: datetime, current_rate: float,
@ -623,6 +717,8 @@ class FreqaiPrimer(IStrategy):
if trade_age_minutes < 0:
trade_age_minutes = 0
# 使用可优化的线性函数: y = (a * (x + k)) + t
a = self.roi_param_a.value # 系数a (可优化参数)
k = self.roi_param_k.value # 偏移量k (可优化参数)
@ -651,6 +747,8 @@ class FreqaiPrimer(IStrategy):
exit_ratio = 1.0
if entry_tag == 'strong_trend':
exit_ratio *= 0.8
if dynamic_roi_threshold < 0:
exit_ratio = 1.0
@ -662,7 +760,7 @@ class FreqaiPrimer(IStrategy):
return exit_ratio
def adjust_trade_position(self, trade: 'Trade', current_time, current_rate: float,
def adjust_trade_position(self, trade: 'Trade', current_time, current_rate: float,
current_profit: float, min_stake: float, max_stake: float, **kwargs) -> float:
"""
根据用户要求实现加仓逻辑
@ -671,41 +769,86 @@ class FreqaiPrimer(IStrategy):
"""
# 获取当前交易对
pair = trade.pair
# 获取当前交易的加仓次数
entry_count = len(trade.orders) # 获取所有入场订单数量
# 如果已经达到最大加仓次数，则不再加仓
if entry_count - 1 >= self.max_entry_adjustments.value:
return 0.0
# 获取初始入场价格和当前价格的差值百分比
initial_price = trade.open_rate
if initial_price == 0:
return 0.0
price_diff_pct = (current_rate - initial_price) / initial_price
# 计算加仓次数（从1开始计数）
adjustment_count = entry_count - 1 # 已加仓次数
# 检查价格回调是否达到加仓间隔
dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
current_state = dataframe['market_state'].iloc[-1] if 'market_state' in dataframe.columns else 'neutral'
if price_diff_pct <= -self.add_position_callback.value and current_state not in ['bear', 'weak_bear']:
# 获取当前币对的波动系数，用于动态调整回调百分比
volatility_coef = self.get_volatility_coefficient(pair)
# 计算当前所需的加仓间隔百分比 = 基础间隔 * (系数 ^ 已加仓次数)
current_callback = self.add_position_callback.value * (self.add_position_multiplier.value ** adjustment_count) * volatility_coef
if price_diff_pct <= -current_callback:
# 计算初始入场金额
initial_stake = trade.orders[0].cost # 第一笔订单的成本
# 计算加仓次数（从1开始计数）
adjustment_count = entry_count - 1 # 已加仓次数
# 计算加仓金额: (initial_stake / stake_divisor) ^ (adjustment_count + 1)
additional_stake = (self.step_coefficient.value * initial_stake / self.stake_divisor.value) ** (adjustment_count + 1)
additional_stake = (initial_stake / self.stake_divisor.value) * (self.add_position_growth.value ** (adjustment_count + 1))
# 确保加仓金额在允许的范围内
additional_stake = max(min_stake, min(additional_stake, max_stake - trade.stake_amount))
#logger.info(f"[{pair}] 触发加仓: 第{adjustment_count + 1}次加仓, 初始金额{initial_stake:.2f}, \
# 加仓金额{additional_stake:.2f}, 价格差{price_diff_pct:.2%}, 当前利润{current_profit:.2%}")
return additional_stake
# 不符合加仓条件，返回0
return 0.0
def custom_stake_amount(self, pair: str, current_time: datetime, **kwargs) -> float:
"""
根据波动系数动态调整初始仓位大小
- 波动率高的币对分配较小的仓位
- 波动率低的币对可以分配较大的仓位
"""
# 返回默认仓位大小
return self.stake_amount
def confirm_trade_entry(
self,
pair: str,
order_type: str,
amount: float,
rate: float,
time_in_force: str,
current_time: datetime,
entry_tag: str | None,
side: str,
**kwargs,
) -> bool:
"""
交易买入前的确认函数，用于最终决定是否执行交易
此处实现剧烈拉升检查逻辑
"""
# 默认允许交易
allow_trade = True
# 仅对多头交易进行检查
if side == 'long':
# 检查是否处于剧烈拉升的不稳固区域
is_unstable_region = self.detect_h1_rapid_rise(pair)
if is_unstable_region:
#logger.info(f"[{pair}] 由于检测到剧烈拉升，取消入场交易")
allow_trade = False
# 如果没有阻止因素，允许交易
return allow_trade