From a1f8c6c6055b3c210da60c1784143f03c622374c Mon Sep 17 00:00:00 2001 From: jackyu66git Date: Thu, 16 Oct 2025 02:44:21 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E7=9A=84=E7=AD=96=E7=95=A5=EF=BC=8C?= =?UTF-8?q?=E5=85=88=E5=BC=80=E5=8D=95=EF=BC=8C=E6=98=8E=E5=A4=A9=E7=BB=A7?= =?UTF-8?q?=E7=BB=AD=E6=B7=BB=E5=8A=A0=E6=9D=A1=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ChanKLC.py | 18 +-- ChanKLU.py | 43 +----- ChanLun.py | 209 ++++++++++++++++++++++++++- config/ChanLun_BTC_60.json | 83 +++++++++++ strategies/ChanLun_BTC.py | 8 +- strategies/ChanLun_BTC_60.py | 273 +++++++++++++++++++++++++++++++++++ 6 files changed, 579 insertions(+), 55 deletions(-) create mode 100644 config/ChanLun_BTC_60.json create mode 100644 strategies/ChanLun_BTC_60.py diff --git a/ChanKLC.py b/ChanKLC.py index 2f33b82..3d88e8d 100644 --- a/ChanKLC.py +++ b/ChanKLC.py @@ -61,7 +61,7 @@ class ChanKLC(): #print(self.start_time, klc_fx_type, self.get_feature_data()['klu_macd'], self.get_feature_data()['klu_macdhist'], self.get_feature_data()['klu_rsi']) self.klc_fx_type = klc_fx_type #self.cal_fx() - #self.cal_bb_out() + self.cal_bb_out() def add_klu(self, klu): self.klus.append(klu) def set_end_klu(self, klu): @@ -100,15 +100,16 @@ class ChanKLC(): self.klc_fx_type = Chan_KLC_FX.BOTTOM8 def cal_bb_out(self): for klu in self.klus: - if self.high >= klu.bbup302 and klu.bbup302 > 0 and (self.klc_fx_type == Chan_KLC_FX.TOP1 or self.klc_fx_type == Chan_KLC_FX.TOP2): - #print(self.end_time, self.high, klu.bbup302, self.klc_fx_type) - if self.high >= klu.bbup30 and klu.bbup30 > 0 and self.next and (self.next.macd - self.macd) < 0: + if self.klc_fx_type == Chan_KLC_FX.TOP1 or self.klc_fx_type == Chan_KLC_FX.TOP2: + #print(self.start_time, self.klc_fx_type, klu.high, klu.bb52upper, self.macd, self.next.macd, klu.time) + if self.high >= klu.bb52upper and klu.bb52upper > 0 and self.next and self.high > self.next.high: self.klc_fx_type = Chan_KLC_FX.TOP4 - #self.bb_out = True - if self.low <= klu.bblow302 and klu.bblow302 > 0 and (self.klc_fx_type == Chan_KLC_FX.BOTTOM1 or self.klc_fx_type == Chan_KLC_FX.BOTTOM2): - if self.low <= klu.bblow30 and klu.bblow30 > 0 and self.next and (self.macd - self.next.macd) < 0: + print(self.end_time, self.klc_fx_type) + if self.klc_fx_type == Chan_KLC_FX.BOTTOM1 or self.klc_fx_type == Chan_KLC_FX.BOTTOM2: + #print(self.start_time, self.klc_fx_type, klu.low, klu.bb52lower, self.macd, self.next.macd, klu.time) + if self.low <= klu.bb52lower and klu.bb52lower > 0 and self.next and self.low < self.next.low: self.klc_fx_type = Chan_KLC_FX.BOTTOM4 - #self.bb_out = True + print(self.end_time, self.klc_fx_type) def cal_indicators(self): for index in range(1, len(self.klus)): self.volume += self.klus[index].volume @@ -126,7 +127,6 @@ class ChanKLC(): if len(self.klus) > 0: self.macd = self.klus[-1].macd self.signal = self.klus[-1].signal - self.body = abs(self.close - self.open) self.upper_shadow = self.high - max(self.close, self.open) self.lower_shadow = min(self.close, self.open) - self.low diff --git a/ChanKLU.py b/ChanKLU.py index 75e4cd4..3a15f81 100644 --- a/ChanKLU.py +++ b/ChanKLU.py @@ -15,23 +15,10 @@ class ChanKLU: self.signal = 0 self.macdhist = 0 self.klc = None - self.ma5 = 0 - self.ma10 = 0 - self.ma30 = 0 - self.ma50 = 0 - self.ma200 = 0 - self.ma250 = 0 self.rsi = 0 self.volume_ratio = 0 - self.bbp120 = 0 - self.bbp365 = 0 - self.bb120 = 0 - self.bb365 = 0 - self.bbp302 = 0 - self.bbup302 = 0 - self.bblow302 = 0 - self.bbup30 = 0 - self.bblow30 = 0 + self.bb52upper = 0 + self.bb52lower = 0 # === 新增：K线类型 === self.kline_type = None # K线类型：大阳线、大阴线、小阳线、小阴线 @@ -107,33 +94,13 @@ class ChanKLU: self.macd = float(item['macd']) if 'macd' in item and item['macd'] else 0 self.signal = float(item['macdsignal']) if 'macdsignal' in item and item['macdsignal'] else 0 self.macdhist = float(item['macdhist']) if 'macdhist' in item and item['macdhist'] else 0 - self.ma5 = float(item['ma5']) if 'ma5' in item and item['ma5'] else 0 - self.ma10 = float(item['ma10']) if 'ma10' in item and item['ma10'] else 0 - self.ma30 = float(item['ma30']) if 'ma30' in item and item['ma30'] else 0 self.ema52 = float(item['ema52']) if 'ema52' in item and item['ema52'] else 0 self.ema24 = float(item['ema24']) if 'ema24' in item and item['ema24'] else 0 - - # 安全检查 ma250、ma50 和 ma200 - self.ma250 = float(item['ma250']) if 'ma250' in item and item['ma250'] else 0 - self.ma50 = float(item['ma50']) if 'ma50' in item and item['ma50'] else 0 - self.ma200 = float(item['ma200']) if 'ma200' in item and item['ma200'] else 0 - self.rsi = float(item['rsi']) if 'rsi' in item and item['rsi'] else 0 self.volume_ratio = float(item['volume_ratio']) if 'volume_ratio' in item and item['volume_ratio'] else 0 - self.bbp120 = float(item['bbp120']) if 'bbp120' in item and item['bbp120'] else 0 - self.bbp365 = float(item['bbp365']) if 'bbp365' in item and item['bbp365'] else 0 - self.bb120 = float(item['bb120']) if 'bb120' in item and item['bb120'] else 0 - self.bb365 = float(item['bb365']) if 'bb365' in item and item['bb365'] else 0 - self.bbp30 = float(item['bbp30']) if 'bbp30' in item and item['bbp30'] else 0 - self.bbup30 = float(item['bbup30']) if 'bbup30' in item and item['bbup30'] else 0 - self.bblow30 = float(item['bblow30']) if 'bblow30' in item and item['bblow30'] else 0 - self.bbp302 = float(item['bbp302']) if 'bbp302' in item and item['bbp302'] else 0 - self.bbup302 = float(item['bbup302']) if 'bbup302' in item and item['bbup302'] else 0 - self.bblow302 = float(item['bblow302']) if 'bblow302' in item and item['bblow302'] else 0 - self.bbup120 = float(item['bbup120']) if 'bbup120' in item and item['bbup120'] else 0 - self.bblow120 = float(item['bblow120']) if 'bblow120' in item and item['bblow120'] else 0 - self.bbup365 = float(item['bbup365']) if 'bbup365' in item and item['bbup365'] else 0 - self.bblow365 = float(item['bblow365']) if 'bblow365' in item and item['bblow365'] else 0 + self.bb52upper = float(item['bb52upper']) if 'bb52upper' in item and item['bb52upper'] else 0 + self.bb52lower = float(item['bb52lower']) if 'bb52lower' in item and item['bb52lower'] else 0 + def cal_macd_state(self): # 按定义精简实现：优先级 CROSS0 > 位置(HIGH/HE/RETURN_ZERO) > NEAR0 > UNKNOWN # 首条或缺前一根 diff --git a/ChanLun.py b/ChanLun.py index 78a069d..e760637 100644 --- a/ChanLun.py +++ b/ChanLun.py @@ -75,6 +75,26 @@ class ChanLun(): if len(self.tf_df_dict) > 0: return {key: self.tf_df_dict[key].get_ema24() for key in self.ema_symbols} return None + def get_klu_state(self, dataframe): + klc_list = self.get_klc_list(dataframe) + bi_list = self.cal_bi_list(klc_list) + klu_state_list = [] + klc_index = 0 + for index in range(0, len(dataframe)): + if klc_index == len(klc_list): + klc_index = len(klc_list) - 1 + klc = klc_list[klc_index] + if klc.end_klu and klc.end_klu.idx == index: + if klc.klc_fx_type == Chan_KLC_FX.TOP4: + klu_state_list.append("10") + elif klc.klc_fx_type == Chan_KLC_FX.BOTTOM4: + klu_state_list.append("-10") + else: + klu_state_list.append("00") + klc_index += 1 + else: + klu_state_list.append("00") + return klu_state_list def get_current_klc_dict(self): if len(self.tf_df_dict) > 0: return {key: self.tf_df_dict[key].get_current_klc() for key in self.ema_symbols} @@ -94,7 +114,7 @@ class ChanLun(): #print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "BOTTOM") return Chan_FX_TYPE.BOTTOM return Chan_FX_TYPE.UNKNOWN - def add_indicators(self, df): + def add_indicators1(self, df): fast = 12 slow = 26 period = 9 @@ -474,6 +494,9 @@ class ChanLun(): if not klc_list: return klc_list last_trend = Chan_PRICE_TREND.UNKNOWN + # 趋势延续性：参考近 N 根已完成的KLC + lookback_n = 5 + prev_klcs = [] for klc in klc_list: price = getattr(klc, 'close', None) ema24 = getattr(klc, 'ema24', None) @@ -514,6 +537,76 @@ class ChanLun(): spread_now = ema24 - ema52 spread_pre = pre_ema24 - pre_ema52 score += 1 if spread_now >= spread_pre else -1 + # 3.1) MACD柱体动量趋势：考虑 macdhist 的斜率与过零 + pre_hist = getattr(pre, 'macdhist', None) + if pre_hist is not None and hist is not None: + # 柱体斜率：上升加分，下降减分 + if hist > pre_hist: + score += 1 + elif hist < pre_hist: + score -= 1 + # 过零加权：负转正更偏多，正转负更偏空 + if pre_hist < 0 and hist > 0: + score += 1 + elif pre_hist > 0 and hist < 0: + score -= 1 + # 3.2) EMA52 突破/跌破加权 + if ema52_valid and price_valid and pre_close is not None and pre_ema52 not in (None, 0): + # 看多突破：从均线下方上破且动量配合 + if pre_close <= pre_ema52 and price > ema52 and (hist is None or pre_hist is None or hist >= pre_hist): + score += 1 + # 看空跌破：从均线上方下破且动量配合 + if pre_close >= pre_ema52 and price < ema52 and (hist is None or pre_hist is None or hist <= pre_hist): + score -= 1 + # 3.3) EMA52 支撑/阻力触碰（非强穿越） + if ema52_valid and price_valid: + low_v = getattr(klc, 'low', None) + high_v = getattr(klc, 'high', None) + if low_v is not None and high_v is not None and ema52 not in (None, 0): + # 触碰容差（相对EMA52的0.15%） + touch_tol = 0.0015 + # 作为支撑：收盘在上，最低靠近EMA52 + near_support_touch = (price > ema52) and (abs(low_v - ema52) / abs(ema52) <= touch_tol) + # 作为阻力：收盘在下，最高靠近EMA52 + near_resistance_touch = (price < ema52) and (abs(high_v - ema52) / abs(ema52) <= touch_tol) + if near_support_touch: + # 若动量不弱，则更偏多 + score += 1 if (hist is None or pre_hist is None or hist >= pre_hist) else 0 + if near_resistance_touch: + # 若动量不强，则更偏空 + score -= 1 if (hist is None or pre_hist is None or hist <= pre_hist) else 0 + # 3.4) 多次对 EMA52 的“拒绝”配合 MACD 逆向：易形成压/支并反向 + # 统计近窗口内的上/下拒绝次数： + # - 上拒绝：价格位于 EMA52 下方，最高触及/越过 EMA52 但收盘仍在下方 + # - 下拒绝：价格位于 EMA52 上方，最低触及/跌破 EMA52 但收盘仍在上方 + recent_up_rejects = 0 + recent_down_rejects = 0 + if ema52_valid: + window_rej = prev_klcs[-lookback_n:] if len(prev_klcs) > 0 else [] + rej_tol = 0.0015 + for wk in window_rej: + wk_close = getattr(wk, 'close', None) + wk_ema52 = getattr(wk, 'ema52', None) + wk_high = getattr(wk, 'high', None) + wk_low = getattr(wk, 'low', None) + if wk_close is None or wk_ema52 in (None, 0): + continue + # 上拒绝（阻力）：下方多次试图上破但未站上 + if wk_close < wk_ema52 and wk_high is not None: + if wk_high >= wk_ema52 or abs(wk_high - wk_ema52) / abs(wk_ema52) <= rej_tol: + recent_up_rejects += 1 + # 下拒绝（支撑）：上方多次试图下破但未跌破 + if wk_close > wk_ema52 and wk_low is not None: + if wk_low <= wk_ema52 or abs(wk_low - wk_ema52) / abs(wk_ema52) <= rej_tol: + recent_down_rejects += 1 + # 定义 MACD 的方向偏好 + macd_bias_up = (macd >= signal) and (hist is None or pre_hist is None or hist >= pre_hist) + macd_bias_down = (macd <= signal) and (hist is None or pre_hist is None or hist <= pre_hist) + # 若多次上拒绝且 MACD 偏空，则更偏向下行；若多次下拒绝且 MACD 偏多，则更偏向上行 + if recent_up_rejects >= 2 and macd_bias_down: + score -= 2 + if recent_down_rejects >= 2 and macd_bias_up: + score += 2 # 4) RSI 辅助 if rsi is not None: if rsi >= 55: @@ -551,17 +644,121 @@ class ChanLun(): near_macd = abs(macd - signal) <= (abs(price) * 0.00005 if price_valid else 0) near_flat = near_ema52 and near_macd # 7) 动态阈值 + 趋势记忆（更强粘滞：趋势中容忍小幅反分） + # 引入过去 N 根KLC 的趋势延续性来动态调整翻转阈值，并结合 EMA52 支撑/阻力触碰强化门槛 + force_flip_down = False + force_flip_up = False if near_flat: trend = Chan_PRICE_TREND.FLAT else: - if last_trend == Chan_PRICE_TREND.UP: - # 仅当出现明显反向才翻转，否则维持UP - if score <= -2: + # 计算过去窗口的趋势一致性 + window = prev_klcs[-lookback_n:] if len(prev_klcs) > 0 else [] + persist_up = 0 + persist_down = 0 + for wk in window: + if getattr(wk, 'trend', None) == Chan_PRICE_TREND.UP: + persist_up += 1 + elif getattr(wk, 'trend', None) == Chan_PRICE_TREND.DOWN: + persist_down += 1 + persist_ratio_up = (persist_up / len(window)) if len(window) > 0 else 0 + persist_ratio_down = (persist_down / len(window)) if len(window) > 0 else 0 + # 基准阈值 + down_flip_threshold = -2 + up_flip_threshold = 2 + # 若最近多为UP，则从UP翻转需更强反向信号；同理对DOWN + if last_trend == Chan_PRICE_TREND.UP and persist_ratio_up >= 0.6: + down_flip_threshold = -3 + elif last_trend == Chan_PRICE_TREND.DOWN and persist_ratio_down >= 0.6: + up_flip_threshold = 3 + # EMA52 触碰强化门槛：UP时若出现支撑触碰，下翻更难；DOWN时若出现阻力触碰，上翻更难 + if ema52_valid and price_valid: + low_v = getattr(klc, 'low', None) + high_v = getattr(klc, 'high', None) + if low_v is not None and high_v is not None and ema52 not in (None, 0): + touch_tol = 0.0015 + near_support_touch = (price > ema52) and (abs(low_v - ema52) / abs(ema52) <= touch_tol) + near_resistance_touch = (price < ema52) and (abs(high_v - ema52) / abs(ema52) <= touch_tol) + if last_trend == Chan_PRICE_TREND.UP and near_support_touch: + # 强化维持UP：进一步降低向下翻转阈值 + down_flip_threshold = min(down_flip_threshold - 1, -3) + if last_trend == Chan_PRICE_TREND.DOWN and near_resistance_touch: + # 强化维持DOWN：进一步提高向上翻转阈值 + up_flip_threshold = max(up_flip_threshold + 1, 3) + # 7.1) 复合拐头信号：MACD/Signal 同向拐头 + hist 连续减弱 + 多次未能越过 EMA52 + pre_macd = getattr(pre, 'macd', None) if pre else None + pre_signal = getattr(pre, 'signal', None) if pre else None + macd_slope = (macd - pre_macd) if (pre_macd is not None and macd is not None) else 0 + signal_slope = (signal - pre_signal) if (pre_signal is not None and signal is not None) else 0 + # hist 连续减弱（绝对值缩小） + hist_seq = [] + for wk in prev_klcs[-2:]: + val = getattr(wk, 'macdhist', None) + if val is not None: + hist_seq.append(val) + if hist is not None: + hist_seq.append(hist) + weaken_steps = 0 + for i in range(1, len(hist_seq)): + if abs(hist_seq[i]) < abs(hist_seq[i-1]): + weaken_steps += 1 + # 近窗口对 EMA52 的“未能站上/跌破”统计（放宽窗口与条件） + window_ema = prev_klcs[-4:] if len(prev_klcs) > 0 else [] + no_up_break = False + no_down_break = False + if ema52_valid: + # 未能有效上破：最近若干根收盘大多数不在 EMA52 上方，且高点多次触及/接近 + cnt_touch_up = 0 + cnt_close_above = 0 + for wk in window_ema: + wk_close = getattr(wk, 'close', None) + wk_high = getattr(wk, 'high', None) + wk_ema = getattr(wk, 'ema52', None) + if wk_close is not None and wk_ema not in (None, 0): + if wk_close > wk_ema: + cnt_close_above += 1 + if wk_high is not None and (wk_high >= wk_ema or abs(wk_high - wk_ema) / abs(wk_ema) <= 0.0015): + cnt_touch_up += 1 + no_up_break = (cnt_close_above <= 1 and cnt_touch_up >= 1 and price <= ema52) + # 未能有效下破：最近若干根收盘大多数不在 EMA52 下方，且低点多次触及/接近 + cnt_touch_down = 0 + cnt_close_below = 0 + for wk in window_ema: + wk_close = getattr(wk, 'close', None) + wk_low = getattr(wk, 'low', None) + wk_ema = getattr(wk, 'ema52', None) + if wk_close is not None and wk_ema not in (None, 0): + if wk_close < wk_ema: + cnt_close_below += 1 + if wk_low is not None and (wk_low <= wk_ema or abs(wk_low - wk_ema) / abs(wk_ema) <= 0.0015): + cnt_touch_down += 1 + no_down_break = (cnt_close_below <= 1 and cnt_touch_down >= 1 and price >= ema52) + # 若当前为UP趋势，出现明显拐头+hist减弱+未能上破EMA52，则加速看空 + if last_trend == Chan_PRICE_TREND.UP and macd_slope < 0 and signal_slope < 0 and weaken_steps >= 1 and no_up_break and macd_bias_down: + score -= 3 + down_flip_threshold = max(down_flip_threshold, 0) + force_flip_down = True + # 若当前为DOWN趋势，出现明显拐头+hist减弱+未能下破EMA52，则加速看多 + if last_trend == Chan_PRICE_TREND.DOWN and macd_slope > 0 and signal_slope > 0 and weaken_steps >= 1 and no_down_break and macd_bias_up: + score += 3 + up_flip_threshold = min(up_flip_threshold, 0) + force_flip_up = True + # 多次对 EMA52 的拒绝配合 MACD 逆向：加速反向翻转（降低相反方向阈值） + if recent_up_rejects >= 2 and macd_bias_down: + # 从 UP 向 DOWN 的翻转更容易 + down_flip_threshold = max(down_flip_threshold, -1) + if recent_down_rejects >= 2 and macd_bias_up: + # 从 DOWN 向 UP 的翻转更容易 + up_flip_threshold = min(up_flip_threshold, 1) + if force_flip_down: + trend = Chan_PRICE_TREND.DOWN + elif force_flip_up: + trend = Chan_PRICE_TREND.UP + elif last_trend == Chan_PRICE_TREND.UP: + if score <= down_flip_threshold: trend = Chan_PRICE_TREND.DOWN else: trend = Chan_PRICE_TREND.UP elif last_trend == Chan_PRICE_TREND.DOWN: - if score >= 2: + if score >= up_flip_threshold: trend = Chan_PRICE_TREND.UP else: trend = Chan_PRICE_TREND.DOWN @@ -583,6 +780,8 @@ class ChanLun(): else: setattr(klc, 'trend', trend) last_trend = trend + # 更新滑窗：仅向后看 + prev_klcs.append(klc) price_diff = klc.close - klc.pre.close if klc.pre else 0 #if klc.index > len(klc_list) - 10: #print(klc.start_time, klc.end_time, klc.close, klc.ema24, klc.ema52, klc.macd, klc.signal, klc.macdhist, klc.trend, price_diff, score) diff --git a/config/ChanLun_BTC_60.json b/config/ChanLun_BTC_60.json new file mode 100644 index 0000000..1394b25 --- /dev/null +++ b/config/ChanLun_BTC_60.json @@ -0,0 +1,83 @@ +{ + "$schema": "https://schema.freqtrade.io/schema.json", + "max_open_trades": 1, + "stake_currency": "USDT", + "stake_amount": "unlimited", + "tradable_balance_ratio": 0.99, + "fiat_display_currency": "USD", + "dry_run": true, + "db_url": "sqlite:///tradesv3.chanlun_btc_60.sqlite", + "dry_run_wallet": 1000, + "cancel_open_orders_on_exit": true, + "trading_mode": "futures", + "margin_mode": "isolated", + "can_short" : true, + "timeframe" : "1m", + "process_only_new_candles" : false, + "unfilledtimeout": { + "entry": 1, + "exit": 1, + "exit_timeout_count": 5, + "unit": "minutes" + }, + "entry_pricing": { + "price_side": "same", + "use_order_book": true, + "order_book_top": 1, + "price_last_balance": 0.0, + "check_depth_of_market": { + "enabled": false, + "bids_to_ask_delta": 1 + } + }, + "exit_pricing":{ + "price_side": "same", + "use_order_book": true, + "order_book_top": 1 + }, + "exchange": { + "name": "binance", + "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8", + "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l", + "ccxt_config": {}, + "ccxt_async_config": {}, + "pair_whitelist": [ + "BTC/USDT:USDT" + ], + "pair_blacklist": [ + "BNB/.*" + ] + }, + "pairlists": [ + { + "method": "StaticPairList", + "number_assets": 1, + "sort_key": "quoteVolume", + "min_value": 0, + "refresh_period": 1800 + } + ], + "telegram": { + "enabled": true, + "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y", + "chat_id": "580807463" + }, + "api_server": { + "enabled": true, + "listen_ip_address": "0.0.0.0", + "listen_port": 8814, + "verbosity": "error", + "enable_openapi": false, + "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d", + "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg", + "CORS_origins": [], + "username": "freqtrader", + "password": "FreqTrade007" + }, + "bot_name": "freqtrade", + "initial_state": "running", + "force_entry_enable": false, + "internals": { + "process_throttle_secs": 2 + } +} \ No newline at end of file diff --git a/strategies/ChanLun_BTC.py b/strategies/ChanLun_BTC.py index dba6a92..e799199 100644 --- a/strategies/ChanLun_BTC.py +++ b/strategies/ChanLun_BTC.py @@ -21,7 +21,7 @@ logger = logging.getLogger(__name__) # freqtrade plot-dataframe --strategy ChanLun_BTC --datadir user_data/data/binance -c ./user_data/ChanLun_SOL_30.json --timerange=20250309- # freqtrade trade -c ./user_data/Chan/config/ChanLun_BTC_30.json --strategy ChanLun_BTC --strategy-path ./user_data/Chan/strategies -# freqtrade backtesting -c ./user_data/Chan/config/ChanLun_BTC_30.json --strategy ChanLun_BTC --strategy-path ./user_data/Chan/strategies --timerange=20250901- +# freqtrade backtesting -c ./user_data/Chan/config/ChanLun_BTC_30.json --strategy ChanLun_BTC --strategy-path ./user_data/Chan/strategies --timerange=20251008- # freqtrade download-data -c ./user_data/Chan/config/ChanLun_BTC_30.json -t 1m 1m 1h 1d 1M --pairs BTC/USDT:USDT --timerange=20250405- # freqtrade download-data -c ./user_data/Chan/config/ChanLun_BTC_30.json -t 1m 1h 1d 1M --pairs BTC/USDT --timerange=20170101- # freqtrade hyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi --strategy ChanLun_BTC --strategy-path ./user_data/Chan/strategies -c ./user_data/Chan/config/ChanLun_BTC_30.json -e 200 --timerange=20250201-20250901 @@ -115,11 +115,13 @@ class ChanLun_BTC(IStrategy): def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: self.init_dataframes(dataframe) return dataframe - def init_dataframes(self, dataframe_m): + def init_dataframes(self, dataframe_1m): dataframe_1h = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1h') dataframe_1d = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1d') dataframe_1M = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1M') - self.chan.init_dataframes(dataframe_m, dataframe_1h, dataframe_1d, dataframe_1M) + self.chan.init_dataframes(dataframe_1m, dataframe_1h, dataframe_1d, dataframe_1M) + current_price = dataframe_1m.iloc[-1]['close'] + print("Current Price: ", current_price) self.print_all_current_klc() def print_all_ema52(self): for key, value in self.chan.get_ema52_dict().items(): diff --git a/strategies/ChanLun_BTC_60.py b/strategies/ChanLun_BTC_60.py new file mode 100644 index 0000000..4301bf0 --- /dev/null +++ b/strategies/ChanLun_BTC_60.py @@ -0,0 +1,273 @@ +# --- Do not remove these libs --- +from statistics import median +from freqtrade.strategy import IStrategy, stoploss_from_absolute +import sys +import os +# 添加父目录到系统路径 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from ChanLun import ChanLun +from ChanEnum import Chan_FX_TYPE, Chan_KLC_FX, Chan_BI_DIR, Chan_KLC_FX +# -------------------------------- +from technical.util import resample_to_interval, resampled_merge +import talib.abstract as ta +from pandas import DataFrame +import pandas as pd +from datetime import datetime, timedelta +from freqtrade.persistence import Trade, Order +from typing import Optional +import logging +logger = logging.getLogger(__name__) +### Now you can use logger.info('asfd') to log +# freqtrade plot-dataframe --strategy ChanLun_BTC_60 --datadir user_data/data/binance -c ./user_data/ChanLun_SOL_30.json --timerange=20250309- + +# freqtrade trade -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies +# freqtrade backtesting -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies --timerange=20251008- +# freqtrade download-data -c ./user_data/Chan/config/ChanLun_BTC_60.json -t 1m 1m 1h 1d 1M --pairs BTC/USDT:USDT --timerange=20250405- +# freqtrade download-data -c ./user_data/Chan/config/ChanLun_BTC_60.json -t 1m 1h 1d 1M --pairs BTC/USDT --timerange=20170101- +# freqtrade hyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies -c ./user_data/Chan/config/ChanLun_BTC_60.json -e 200 --timerange=20250201-20250901 +# freqtrade edge -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies --timerange 20250721-20250901 +# freqtrade plot-dataframe -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies --timerange 20250721-20250901 + +# sudo docker compose run --rm chanlun_btc backtesting -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies --timerange=20250721- +# sudo docker compose run --rm chanlun_btc download-data -c ./user_data/Chan/config/ChanLun_BTC_60.json --pairs BTC/USDT:USDT -t 1m --timerange 20240101- +# sudo docker compose run --rm chanlun_btc trade -c ./user_data/Chan/config/ChanLun_BTC_60.json --strategy ChanLun_BTC_60 --strategy-path ./user_data/Chan/strategies + +class ChanLun_BTC_60(IStrategy): + INTERFACE_VERSION: int = 3 + # Minimal ROI designed for the strategy. + # This attribute will be overridden if the config file contains "minimal_roi" + # 30m and 1h + + minimal_roi = { + "0": 0.15, + "360": 0.2, + "640": 0.1, + "1200": 0 + } + # 5m and 15m + minimal_roi_1 = { + "0": 0.1, + "60": 0.05, + "120": 0.02, + "240": 0 + } + # 15m and 30m + minimal_roi_1 = { + "0": 0.1, + "240": 0.05, + "480": 0.03, + "600": 0 + } + minimal_roi_1 = { + "0": 1.50, + "120": 0.05, + "240": 0.025, + "360": 0 + } + + can_short = True + lev = 1.0 + stoploss = -0.3 # 设置为很大的负值，让custom_stoploss来控制 + use_custom_stoploss = True # 启用自定义止损 + + trailing_stop = False + trailing_stop_positive = 0.03 + trailing_stop_positive_offset = 0.06 + trailing_only_offset_is_reached = False + + # 关闭分批止盈/仓位调整 + position_adjustment_enable = False + startup_candle_count = 1600 + time5m = 5 + time15m = 15 + time30m = 30 + time1h = 60 + time2h = 120 + last_time = datetime.now() + chan = ChanLun() + last_order = None + last_trade = None + pair = 'BTC/USDT:USDT' + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe_5m = resample_to_interval(dataframe, self.get_ticker_indicator() * 5) + dataframe_15m = resample_to_interval(dataframe, self.get_ticker_indicator() * 15) + dataframe_30m = resample_to_interval(dataframe, self.get_ticker_indicator() * 30) + dataframe_1h = resample_to_interval(dataframe, self.get_ticker_indicator() * 60) + dataframe_2h = resample_to_interval(dataframe, self.get_ticker_indicator() * 120) + dataframe = self.add_indicators(dataframe) + dataframe_5m = self.add_indicators(dataframe_5m) + dataframe_15m = self.add_indicators(dataframe_15m) + dataframe_30m = self.add_indicators(dataframe_30m) + dataframe_1h = self.add_indicators(dataframe_1h) + dataframe_2h = self.add_indicators(dataframe_2h) + dataframe_1h['state'] = self.chan.get_klu_state(dataframe_1h) + dataframe = resampled_merge(dataframe, dataframe_1h) + return dataframe + def add_indicators(self, df): + fast = 12 + slow = 26 + period = 9 + macd = ta.MACD(df, fastperiod=fast, slowperiod=slow, signalperiod=period) + bb52 = ta.BBANDS(df, timeperiod=54, nbdevup=2.3, nbdevdn=2.3, matype=0) + df['bb52upper'] = bb52['upperband'] + df['bb52lower'] = bb52['lowerband'] + df['atr'] = ta.ATR(df, timeperiod=14) + df['macd'] = macd['macd'] + df['macdsignal'] = macd['macdsignal'] + df['macdhist'] = macd['macdhist'] + df['ema24'] = ta.EMA(df, timeperiod=24) + df['ema52'] = ta.EMA(df, timeperiod=52) + df['rsi'] = ta.RSI(df, timeperiod=14) + df['volume_ratio'] = self.cal_volume_ratio(df) + return df + def cal_volume_ratio(self, dataframe, window=10): + df = dataframe.copy() + # 计算过去N根K线的平均成交量 + df['avg_volume'] = df['volume'].rolling(window=window).mean() + # 计算量比 + df['volume_ratio'] = df['volume'] / df['avg_volume'] + # 填充缺失值（前N根K线） + df['volume_ratio'] = df['volume_ratio'].fillna(1.0) + return df['volume_ratio'] + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + state_str = 'resample_{}_state'.format(self.get_ticker_indicator()*self.time1h) + dataframe.loc[ + ( + (dataframe[state_str].shift(self.time1h) == "10") + ), + ['enter_long', 'enter_tag']] = (1, 'long_signal_chan') + dataframe.loc[ + ( + (dataframe[state_str].shift(self.time1h) == "-10") + ), + ['enter_short', 'enter_tag']] = (1, 'short_signal_chan') + return dataframe + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + state_str = 'resample_{}_state'.format(self.get_ticker_indicator()*self.time1h) + dataframe.loc[ + ( + (dataframe[state_str].shift(self.time1h) == "-10") + ), + ['exit_long', 'exit_tag']] = (1, 'long_signal_chan') + dataframe.loc[ + ( + (dataframe[state_str].shift(self.time1h) == "10") + ), + ['exit_short', 'exit_tag']] = (1, 'short_signal_chan') + return dataframe + def custom_entry_price(self, pair: str, trade: Trade | None, current_time: datetime, proposed_rate: float, + entry_tag: str | None, side: str, **kwargs) -> float: + new_entryprice = proposed_rate + if trade: + if trade.is_short: + new_entryprice = proposed_rate - 50 + else: + new_entryprice = proposed_rate + 50 + return new_entryprice + + def custom_exit_price(self, pair: str, trade: Trade, + current_time: datetime, proposed_rate: float, + current_profit: float, exit_tag: str | None, **kwargs) -> float: + new_exitprice = proposed_rate + if trade: + if trade.is_short: + new_exitprice = proposed_rate + 50 + else: + new_exitprice = proposed_rate - 50 + return new_exitprice + + def adjust_trade_position(self, trade: Trade, current_time: datetime, + current_rate: float, current_profit: float, + min_stake: Optional[float], max_stake: float, + current_entry_rate: float, current_exit_rate: float, + current_entry_profit: float, current_exit_profit: float, + **kwargs) -> Optional[float]: + # 关闭分批止盈，始终不调整仓位 + return None + + def custom_stoploss(self, pair: str, trade: Trade, current_time: datetime, + current_rate: float, current_profit: float, after_fill: bool, + **kwargs) -> float | None: + """ + 止损 = 开仓价 ± 1 * ATR（开仓时的ATR）。 + 多单: 开仓价 - ATR；空单: 开仓价 + ATR。 + """ + # 保本止损：当浮盈达到或超过 1% 时，将止损提至开仓价 + #if current_profit is not None and current_profit >= 0.14: + #return stoploss_from_absolute(trade.open_rate, current_rate, is_short=trade.is_short) + + entry_atr = trade.get_custom_data(key="entry_atr") + if entry_atr is None: + # 回退：取当前数据的 ATR 估算 + dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe) + if dataframe is not None and len(dataframe) > 0 and 'atr' in dataframe.columns: + entry_atr = float(dataframe.iloc[-1]['atr']) + else: + # 最保守的回退：5% + return -0.05 + dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + ema52_str = 'resample_{}_ema52'.format(self.time1h) + ema52_val = float(last_candle.get(ema52_str, 0) or 0) + close_str = 'resample_{}_close'.format(self.time1h) + close_val = float(last_candle.get(close_str, 0) or 0) + if close_val < ema52_val: + return -0.01 + if trade.is_short: + stop_price = trade.open_rate + float(entry_atr) + else: + stop_price = trade.open_rate - float(entry_atr) + return stoploss_from_absolute(stop_price, current_rate, is_short=trade.is_short) + + def custom_exit(self, pair: str, trade: Trade, current_time: datetime, current_rate: float, + current_profit: float, **kwargs): + # 不做分批止盈/最终止盈处理，退出由策略信号/ROI/止损决定 + return None + + 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: + """ + ATR 过滤：atr < 100 不开单。 + """ + try: + dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) + if dataframe is None or len(dataframe) == 0: + return False + last = dataframe.iloc[-1] + atr_str = 'resample_{}_atr'.format(self.time1h) + atr_val = float(last.get(atr_str, 0) or 0) + if atr_val < 0.001: + #logger.info(f"ATR过滤：atr={atr_val:.2f} < 100, 拒绝进场 {pair}") + return False + return True + except Exception as e: + logger.warning(f"confirm_trade_entry 异常: {e}") + return True + + def order_filled(self, pair: str, trade: Trade, order: Order, current_time: datetime, **kwargs) -> None: + """ + Called right after an order fills. + Will be called for all order types (entry, exit, stoploss, position adjustment). + :param pair: Pair for trade + :param trade: trade object. + :param order: Order object. + :param current_time: datetime object, containing the current datetime + :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. + """ + # Obtain pair dataframe (just to show how to access it) + dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + atr_str = 'resample_{}_atr'.format(self.time1h) + # 保存开仓时的ATR值用于止损计算 + if (trade.nr_of_successful_entries == 1) and (order.ft_order_side == trade.entry_side): + entry_atr = last_candle[atr_str] * 4 + trade.set_custom_data(key="entry_atr", value=entry_atr) + #logger.info(f"保存开仓时ATR值: {entry_atr}") + return None + def leverage(self, pair: str, current_time: datetime, current_rate: float, + proposed_leverage: float, max_leverage: float, entry_tag: Optional[str], side: str, + **kwargs) -> float: + return self.lev + def get_ticker_indicator(self): + return int(self.timeframe[:-1]) \ No newline at end of file