File size: 9,007 Bytes
1d900df
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
# -*- coding: utf-8 -*-
"""

蒸鱼三层融合引擎 v1.0 - Fusion Engine

融合 QuantMind 三层融合架构(粗筛->精筛->风控闸门)+ 市场状态自适应权重

到蒸鱼现有终极评分体系。

"""

import numpy as np

FUSION_CONFIG = {
    "version": "2026-06-09",
    "enabled": True,
    "layer1_consensus": {
        "enabled": True,
        "min_models_required": 3,
        "min_consensus_ratio": 0.3,
        "max_neutral_ratio": 0.6,
    },
    "layer2_regime_weights": {
        "enabled": True,
        "regime_weights": {
            "TREND_UP": {
                "ml_gbdt": 0.25, "ml_lr": 0.10, "ml_hc": 0.20,
                "fv5": 0.10, "fv5_hc": 0.15,
                "plan_e": 0.05, "v4_composite": 0.05,
                "factor": 0.03, "wyckoff": 0.02,
                "wave": 0.02, "classic_pattern": 0.01,
                "multi_dimension": 0.01, "talang": 0.01,
            },
            "TREND_DOWN": {
                "ml_gbdt": 0.30, "ml_lr": 0.15, "ml_hc": 0.25,
                "fv5": 0.08, "fv5_hc": 0.12,
                "plan_e": 0.03, "v4_composite": 0.03,
                "factor": 0.02, "wyckoff": 0.01,
                "wave": 0.01, "classic_pattern": 0.00,
                "multi_dimension": 0.00, "talang": 0.00,
            },
            "RANGE": {
                "ml_gbdt": 0.15, "ml_lr": 0.08, "ml_hc": 0.10,
                "fv5": 0.15, "fv5_hc": 0.12,
                "plan_e": 0.10, "v4_composite": 0.10,
                "factor": 0.08, "wyckoff": 0.04,
                "wave": 0.03, "classic_pattern": 0.02,
                "multi_dimension": 0.02, "talang": 0.01,
            },
        },
        "high_confidence_gate": {
            "enabled": True,
            "min_confidence": 0.55,
            "gate_mode": "soft",
        },
    },
    "layer3_risk_gate": {
        "enabled": False,
        "max_single_weight": 0.30,
        "max_volatility_20d": 0.06,
    },
    "merge": {
        "mode": "weighted",
        "consensus_bonus": True,
        "divergence_penalty": True,
    },
}


class FusionEngine:
    def __init__(self, config: dict = None):
        self.config = config or FUSION_CONFIG
        self._regime_detector = None

    def _get_regime_detector(self):
        if self._regime_detector is None:
            try:
                from market_regime import MarketRegimeDetector
                self._regime_detector = MarketRegimeDetector()
            except ImportError:
                self._regime_detector = None
        return self._regime_detector

    def detect_market_regime(self, df) -> dict:
        detector = self._get_regime_detector()
        if detector is None:
            return {"regime": "RANGE", "strength": 0.0}
        try:
            close = df['close'].values.astype(float)
            high = df['high'].values.astype(float)
            low = df['low'].values.astype(float)
            volume = df['volume'].values.astype(float) if 'volume' in df.columns else None
            result = detector.detect(close, high, low, volume)
            return result
        except Exception:
            return {"regime": "RANGE", "strength": 0.0}

    def _layer1_consensus_filter(self, model_scores: dict) -> dict:
        cfg = self.config["layer1_consensus"]
        if not cfg["enabled"]:
            return model_scores
        total = len(model_scores)
        if total < cfg["min_models_required"]:
            return model_scores
        neutral_count = sum(1 for s in model_scores.values() if 40 <= s <= 60)
        if neutral_count / total > cfg["max_neutral_ratio"]:
            return {n: 50 + (s - 50) * 0.6 for n, s in model_scores.items()}
        return model_scores

    def _layer2_regime_weights(self, model_scores: dict, regime: str) -> dict:
        cfg = self.config["layer2_regime_weights"]
        if not cfg["enabled"]:
            return {m: 1.0 / len(model_scores) for m in model_scores}
        rw = cfg["regime_weights"]
        if regime not in rw:
            regime = "RANGE"
        weights = {m: rw[regime].get(m, 0.05) for m in model_scores}
        total = sum(weights.values())
        if total > 0:
            weights = {k: v / total for k, v in weights.items()}
        gate = cfg["high_confidence_gate"]
        if gate["enabled"]:
            for m in list(weights.keys()):
                conf = abs(model_scores[m] - 50) / 50
                if conf < gate["min_confidence"]:
                    if gate["gate_mode"] == "hard":
                        del weights[m]
                    else:
                        weights[m] *= conf
        total = sum(weights.values())
        if total > 0:
            weights = {k: v / total for k, v in weights.items()}
        return weights

    def _layer3_risk_gate(self, score: float, df=None) -> float:
        cfg = self.config["layer3_risk_gate"]
        if not cfg["enabled"] or df is None or len(df) < 20:
            return score
        close = df['close'].values.astype(float)
        ret = np.diff(close) / close[:-1]
        vol = np.std(ret[-20:]) * np.sqrt(252)
        if vol > cfg["max_volatility_20d"]:
            score = 50 + (score - 50) * 0.7
        return score

    def _apply_consensus_modulation(self, score: float, model_scores: dict) -> float:
        cfg = self.config["merge"]
        scores = list(model_scores.values())
        if len(scores) < 3:
            return score
        std = np.std(scores)
        if cfg["consensus_bonus"] and std < 15:
            score += (15 - std) * 0.3
        if cfg["divergence_penalty"] and std > 25:
            score -= (std - 25) * 0.2
        return np.clip(score, 0, 100)

    def fuse(self, ultimate_result: dict, df=None) -> dict:
        if not ultimate_result:
            return ultimate_result
        contributions = ultimate_result.get('model_contributions', [])
        model_scores = {c['model']: c['score'] for c in contributions}
        if not model_scores:
            return ultimate_result
        filtered = self._layer1_consensus_filter(model_scores)
        regime = "RANGE"
        regime_strength = 0.0
        if df is not None:
            rr = self.detect_market_regime(df)
            regime = rr.get('regime', 'RANGE')
            regime_strength = rr.get('adx', 0)
        weights = self._layer2_regime_weights(filtered, regime)
        fusion_score = sum(filtered[m] * weights.get(m, 0) for m in filtered) if weights else ultimate_result.get('ultimate_score', 50)
        fusion_score = self._apply_consensus_modulation(fusion_score, filtered)
        fusion_score = self._layer3_risk_gate(fusion_score, df)
        if fusion_score >= 68:
            signal, advice, action = '强烈买入', '多模型高度共振看多, 建议积极介入', 'BUY'
        elif fusion_score >= 60:
            signal, advice, action = '买入', '多数模型指向看多, 可分批建仓', 'BUY'
        elif fusion_score >= 54:
            signal, advice, action = '偏多观望', '略偏积极, 可少量试探或等待更好入场点', 'HOLD'
        elif fusion_score >= 46:
            signal, advice, action = '中性', '多空分歧较大, 建议暂缓操作等待方向明确', 'HOLD'
        elif fusion_score <= 32:
            signal, advice, action = '强烈卖出', '多模型高度共振看空, 建议果断离场', 'SELL'
        elif fusion_score <= 40:
            signal, advice, action = '卖出', '多数模型指向看空, 建议减仓或离场', 'SELL'
        else:
            signal, advice, action = '偏空观望', '略偏悲观, 已有持仓考虑减仓', 'HOLD'
        original = ultimate_result.get('ultimate_score', 50)
        result = dict(ultimate_result)
        result.update({
            'fusion_score': round(fusion_score, 1),
            'fusion_signal': signal,
            'fusion_action': action,
            'fusion_advice': advice,
            'fusion_score_delta': round(fusion_score - original, 1),
            'fusion_enabled': True,
            'fusion_config_version': self.config['version'],
            'market_regime': regime,
            'regime_strength': round(regime_strength, 1),
            'regime_weights': {k: round(v, 4) for k, v in sorted(weights.items(), key=lambda x: -x[1])},
            'layer1_active': self.config['layer1_consensus']['enabled'],
            'layer2_active': self.config['layer2_regime_weights']['enabled'],
            'layer3_active': self.config['layer3_risk_gate']['enabled'],
        })
        return result


_fusion_engine = None


def get_fusion_engine() -> FusionEngine:
    global _fusion_engine
    if _fusion_engine is None:
        _fusion_engine = FusionEngine()
    return _fusion_engine


def fuse_ultimate_score(ultimate_result: dict, df=None) -> dict:
    return get_fusion_engine().fuse(ultimate_result, df)