Update app.py

app.py

@@ -2,6 +2,7 @@
 """
 港股智能分析平台 - Hugging Face Spaces版本
 集成数学原理的XPINNs训练与LLM推理系统
+（已扩展：噪声分离、Whitney嵌入截面学习、梯度动力学模拟、LLM伪代码/日内策略）
 """
 
 import os
@@ -64,7 +65,7 @@ class FiberBundleTheory:
     def __init__(self, base_dim=2, fiber_dim=16):
         self.base_dim = base_dim  # VIX^2, RV
         self.fiber_dim = fiber_dim  # 隐藏状态维度
-        self.whitney_factor = 2 * fiber_dim  # Whitney嵌入定理
+        self.whitney_factor = 2 * fiber_dim  # Whitney嵌入因子（理论上）
         
     def project_to_base(self, high_dim_state):
         """投影到基空间"""
@@ -72,7 +73,7 @@ class FiberBundleTheory:
             high_dim_state = np.pad(high_dim_state, (0, self.fiber_dim - len(high_dim_state)))
         
         # 计算VIX^2代理
-        vix_squared = np.sum(high_dim_state[:self.fiber_dim//2]**2) / (self.fiber_dim//2)
+        vix_squared = np.sum(high_dim_state[:self.fiber_dim//2]**2) / (self.fiber_dim//2 + 1e-12)
         # 计算实现波动率
         rv = np.std(high_dim_state[self.fiber_dim//2:])
         
@@ -83,6 +84,182 @@ class FiberBundleTheory:
         vix_squared, rv = base_point
         return vix_squared - rv
 
+class NoiseExplorer:
+    """
+    噪声分离与验证：基于 VIX^2 与 RV 的关系，尝试把观测上的噪声（纤维方向）与基空间信息分离。
+    简单实现：对 VIX^2 与 RV 做线性回归，分析残差的统计特性（自相关、能量谱），并给出 VRP 统计摘要。
+    以后可扩展为更严格的协整检验（Johansen / ADF）。
+    """
+    def __init__(self):
+        pass
+    
+    def regress_vix2_vs_rv(self, vix2_series, rv_series):
+        # 简单线性回归：vix2 = a * rv + b
+        X = np.vstack([rv_series, np.ones_like(rv_series)]).T
+        try:
+            coef, _, _, _ = np.linalg.lstsq(X, vix2_series, rcond=None)
+            a, b = coef[0], coef[1]
+            preds = a * rv_series + b
+            resid = vix2_series - preds
+            return {
+                'a': float(a), 'b': float(b),
+                'preds': preds, 'resid': resid
+            }
+        except Exception as e:
+            return None
+    
+    def resid_stats(self, resid):
+        # 基本残差统计：均值、方差、自相关（lag1）、能量谱（简单FFT）
+        mean = float(np.mean(resid))
+        var = float(np.var(resid))
+        if len(resid) > 2:
+            ac1 = float(np.corrcoef(resid[:-1], resid[1:])[0,1])
+        else:
+            ac1 = 0.0
+        # FFT能量谱主频
+        try:
+            fft = np.fft.rfft(resid - mean)
+            freqs = np.fft.rfftfreq(len(resid))
+            power = np.abs(fft)**2
+            dominant_idx = int(np.argmax(power[1:]) + 1) if len(power) > 1 else 0
+            dominant_freq = float(freqs[dominant_idx]) if len(freqs) > dominant_idx else 0.0
+        except:
+            dominant_freq = 0.0
+        return {'mean':mean, 'var':var, 'ac1':ac1, 'dominant_freq':dominant_freq}
+    
+    def explore(self, df, vix2_col=None, rv_col=None):
+        # 自动寻找列名
+        numeric = df.select_dtypes(include=[np.number]).columns.tolist()
+        if vix2_col is None or rv_col is None:
+            # 尝试匹配
+            candidates = [c.lower() for c in numeric]
+            vix_col = None
+            rv_col_local = None
+            for c in numeric:
+                if 'vix' in c.lower():
+                    vix_col = c
+                if 'rv' in c.lower() or 'realized' in c.lower():
+                    rv_col_local = c
+            if vix_col is None or rv_col_local is None:
+                # 退回到前两列
+                if len(numeric) >= 2:
+                    vix_col, rv_col_local = numeric[0], numeric[1]
+                else:
+                    return None
+            vix2_col, rv_col = vix_col, rv_col_local
+        
+        vix2 = df[vix2_col].fillna(method='ffill').values
+        rv = df[rv_col].fillna(method='ffill').values
+        
+        reg = self.regress_vix2_vs_rv(vix2, rv)
+        if reg is None:
+            return None
+        stats = self.resid_stats(reg['resid'])
+        vrp_series = vix2 - reg['preds']
+        # 返回摘要
+        return {
+            'vix2_col': vix2_col,
+            'rv_col': rv_col,
+            'reg_coeff': {'a':reg['a'], 'b':reg['b']},
+            'resid_stats': stats,
+            'vrp_mean': float(np.mean(vrp_series)),
+            'vrp_std': float(np.std(vrp_series)),
+            'vrp_series': vrp_series,
+            'reg_pred': reg['preds'],
+            'residuals': reg['resid']
+        }
+
+class WhitneyEmbedder(nn.Module):
+    """
+    基于 Whitney 嵌入思想的简单 autoencoder 与截面学习网络：
+    - autoencoder 用于学习从高维观测到低维(whitney_factor)的光滑嵌入
+    - section_net 将 base (VIX^2, RV) 映射回 fiber（截面估计），用于自演化/再构造
+    """
+    def __init__(self, input_dim=64, fiber_dim=16, device='cpu'):
+        super().__init__()
+        self.device = device
+        self.fiber_dim = fiber_dim
+        self.whitney_dim = 2 * fiber_dim  # 推荐维度
+        # encoder / decoder
+        self.encoder = nn.Sequential(
+            nn.Linear(input_dim, 128),
+            nn.ReLU(),
+            nn.Linear(128, self.whitney_dim)
+        )
+        self.decoder = nn.Sequential(
+            nn.Linear(self.whitney_dim, 128),
+            nn.ReLU(),
+            nn.Linear(128, input_dim)
+        )
+        # 截面学习网络：从 base (2维) -> fiber_dim
+        self.section_net = nn.Sequential(
+            nn.Linear(2, 32),
+            nn.ReLU(),
+            nn.Linear(32, fiber_dim)
+        )
+        self.to(self.device)
+    
+    def forward(self, x):
+        z = self.encoder(x)
+        recon = self.decoder(z)
+        return z, recon
+    
+    def learn_section(self, base_points):
+        """
+        给定 base_points (N x 2)，输出 fiber 估计（N x fiber_dim）
+        这是一个直接前向调用（训练通过 train_embedding 来执行）
+        """
+        with torch.no_grad():
+            x = torch.tensor(base_points, dtype=torch.float32, device=self.device)
+            return self.section_net(x).cpu().numpy()
+
+class GradientDynamics:
+    """
+    把势函数 U(b) 的梯度流当成市场的动力路径：db = -eta * grad U(b) dt + sigma dW
+    - 能把离散梯度下降（epochs 步）映射为连续路径的模拟
+    - 使用 torch 自动求导对 U 做梯度（U可以是任意torch可微函数）
+    """
+    def __init__(self, eta=0.1, sigma=0.01, device='cpu'):
+        self.eta = eta
+        self.sigma = sigma
+        self.device = device
+    
+    def U_vrp(self, b):
+        """
+        默认势函数：U(b) = (VRP)^2 / 2 ，其中 b = [vix2, rv]
+        b 为 torch.tensor shape (..., 2)
+        """
+        vix2 = b[...,0]
+        rv = b[...,1]
+        vrp = vix2 - rv
+        return 0.5 * vrp**2
+    
+    def grad_U(self, b):
+        b_t = torch.tensor(b, dtype=torch.float32, requires_grad=True, device=self.device)
+        U = self.U_vrp(b_t).sum()
+        U.backward()
+        grad = b_t.grad.detach().cpu().numpy()
+        return grad
+    
+    def simulate_flow(self, b0, T=1.0, dt=0.01, seed=None):
+        """
+        Euler-Maruyama 模拟：
+        b0: 初始点 (2,)
+        返回路径 (Nsteps+1, 2)
+        """
+        if seed is not None:
+            np.random.seed(seed)
+        n_steps = int(T / dt)
+        path = np.zeros((n_steps+1, 2))
+        path[0] = np.array(b0, dtype=float)
+        for i in range(n_steps):
+            b_cur = path[i]
+            grad = self.grad_U(b_cur)
+            db_det = - self.eta * grad
+            db_stoch = self.sigma * np.sqrt(dt) * np.random.randn(2)
+            path[i+1] = b_cur + db_det * dt + db_stoch
+        return path
+
 class EquivariantLayer(nn.Module):
     """SO(3)等变层"""
     
@@ -230,12 +407,17 @@ class CausalVAR:
 class MathematicalTrainer:
     """数学原理驱动的训练器"""
     
-    def __init__(self):
-        self.fiber_bundle = FiberBundleTheory()
-        self.causal_var = CausalVAR()
+    def __init__(self, device='cpu'):
+        self.device = device
+        self.fiber_bundle = FiberBundleTheory(fiber_dim=config.FIBER_BUNDLE_DIM)
+        self.causal_var = CausalVAR(max_lag=config.CAUSAL_LAG)
         self.model = XPINNsGenerator()
         self.optimizer = Adam(self.model.parameters(), lr=0.001)
         self.scaler = StandardScaler()
+        # 新增：
+        self.noise_explorer = NoiseExplorer()
+        self.embedder = None  # lazy init
+        self.gradient_dynamics = GradientDynamics(eta=0.5, sigma=0.02, device=device)
         
     def prepare_data(self, df):
         """准备训练数据"""
@@ -324,6 +506,35 @@ class MathematicalTrainer:
                 logger.info(f"Epoch {epoch}: Loss = {avg_loss:.6f}")
         
         return losses
+    
+    # ---------- 新增：嵌入器训练接口 ----------
+    def init_embedder(self, input_dim=64):
+        if self.embedder is None:
+            self.embedder = WhitneyEmbedder(input_dim=input_dim, fiber_dim=self.fiber_bundle.fiber_dim, device=self.device)
+    
+    def train_embedding(self, X_np, epochs=100, lr=1e-3):
+        """
+        训练 autoencoder，X_np: numpy array (N, input_dim)
+        """
+        self.init_embedder(input_dim=X_np.shape[1])
+        model = self.embedder
+        opt = Adam(model.parameters(), lr=lr)
+        X = torch.tensor(X_np, dtype=torch.float32, device=self.device)
+        for epoch in range(epochs):
+            opt.zero_grad()
+            z, recon = model(X)
+            loss = F.mse_loss(recon, X)  # 重构损失
+            loss.backward()
+            opt.step()
+            if epoch % 20 == 0:
+                logger.info(f"[Embedder] Epoch {epoch}, recon loss {loss.item():.6f}")
+        return loss.item()
+    
+    def explore_noise(self, df, vix2_col=None, rv_col=None):
+        return self.noise_explorer.explore(df, vix2_col=vix2_col, rv_col=rv_col)
+    
+    def simulate_gradient_flow(self, initial_base_point, T=1.0, dt=0.01):
+        return self.gradient_dynamics.simulate_flow(initial_base_point, T=T, dt=dt)
 
 class LLMInterface:
     """LLM接口"""
@@ -340,7 +551,7 @@ class LLMInterface:
             "inputs": prompt,
             "parameters": {
                 "max_new_tokens": max_length,
-                "temperature": 0.7,
+                "temperature": 0.3,
                 "top_p": 0.9,
                 "do_sample": True
             }
@@ -358,34 +569,77 @@ class LLMInterface:
         except Exception as e:
             return f"错误: {str(e)}"
     
-    def analyze_trading(self, analysis_results, market_data):
-        """分析交易策略"""
-        prompt = f"""作为量化交易专家，基于以下数学分析结果制定日内交易策略：
-
-数学分析结果：
-- 因果稳定性: {analysis_results.get('causal_stable', 'N/A')}
-- VRP值: {analysis_results.get('vrp', 'N/A')}
-- 李雅普诺夫稳定性: {analysis_results.get('lyapunov_stable', 'N/A')}
-- 纤维丛投影: {analysis_results.get('fiber_projection', 'N/A')}
+    def _pseudocode_template(self, strategy_spec: Dict[str,Any]) -> str:
+        """
+        当LLM不可用时，返回一个确定性的伪代码结构
+        strategy_spec 包含：entry_rule, exit_rule, position_sizing, risk_params
+        """
+        template = f"""# PSEUDOCODE for intraday quant strategy
+# Entry: {strategy_spec.get('entry_rule','待定')}
+# Exit: {strategy_spec.get('exit_rule','待定')}
+# Position sizing: {strategy_spec.get('position_sizing','固定仓位/比例')}
+# Risk: {strategy_spec.get('risk_params','默认')}
+def on_bar(bar):
+    features = compute_features(bar)   # e.g. VRP, momentum, spread
+    signal = 0
+    if {strategy_spec.get('entry_condition_code','False')}:
+        signal = 1
+        entry_price = bar.close
+        size = determine_size(entry_price)
+    if {strategy_spec.get('exit_condition_code','False')}:
+        signal = -1
+    manage_risk()
+    execute(signal, size)
+"""
+        return template
+    
+    def analyze_trading(self, analysis_results, market_data, intraday=False, generate_pseudocode=False):
+        """分析交易策略，扩展：日内与伪代码生成"""
+        prompt = f"""你是一个量化交易与日内交易专家。请基于以下数学分析结果和市场数据生成可操作的交易策略。
+        
+数学分析摘要：
+{json.dumps(analysis_results, indent=2)}
 
 市场数据摘要：
 {market_data}
 
-请提供：
-1. 具体的入场点位建议
-2. 止损和止盈设置
-3. 仓位管理建议
-4. 风险提示
+请给出：
+1) 简洁的策略描述（入场、止损、止盈、仓位管理）
+2) 若为日内(intraday=True)，请给出明确定义的入场/退出信号（基于短周期，例如1-5分钟或tick），并说明延迟/滑点考虑
+3) 风险控制与回测建议（数据频率、回测窗口）
+4) 若要求generate_pseudocode=True，请以伪代码形式输出策略实现模板（明确函数名、输入特征、信号判断、止损/止盈逻辑）
 
-回答应简洁专业，直接给出可执行的交易建议。"""
-        
-        return self.query(prompt)
+输出格式：
+- 段落 1: 策略概览
+- 段落 2: 规则要点（枚举）
+- 段落 3: 伪代码（如果要求）
 
+请尽量简洁、直接给出可执行的建议。
+"""
+        if generate_pseudocode:
+            prompt += "\n请在伪代码中包含：compute_features(), determine_size(), execute() 等函数签名。\n"
+        # 调用LLM
+        llm_resp = self.query(prompt, max_length=800)
+        # 如果返回是错误或API失败，fallback到确定性伪代码
+        if isinstance(llm_resp, str) and llm_resp.startswith("错误") or "API调用失败" in str(llm_resp):
+            # 构造简单策略说明
+            strategy_spec = {
+                'entry_rule': '当 VRP 从负值上穿其短期均值且短期动量为正时买入',
+                'exit_rule': '亏损超过止损点或达到止盈点或VRP反转',
+                'position_sizing': '账户风险百分比方式（例如每单最大亏损 0.5%）',
+                'risk_params': '止损与仓位受限，滑点假设 0.02%',
+                'entry_condition_code': 'features["vrp"] > features["vrp_sma_short"] and features["mom"] > 0',
+                'exit_condition_code': 'price <= entry_price*(1 - stop_loss_pct) or price >= entry_price*(1 + take_profit_pct)'
+            }
+            fallback = "LLM不可用，返回内置伪代码模板。\n\n" + self._pseudocode_template(strategy_spec)
+            return fallback
+        return llm_resp
+    
 class TradingPlatform:
     """主交易平台"""
     
-    def __init__(self):
-        self.trainer = MathematicalTrainer()
+    def __init__(self, device='cpu'):
+        self.trainer = MathematicalTrainer(device=device)
         self.llm = LLMInterface()
         self.current_data = None
         self.analysis_results = {}
@@ -473,7 +727,43 @@ class TradingPlatform:
         except Exception as e:
             return f"训练失败: {str(e)}", None
     
-    def get_trading_strategy(self, user_question):
+    def run_noise_exploration(self):
+        """运行噪声探索（基于 VIX^2 vs RV 回归）"""
+        if self.current_data is None:
+            return "请先上传数据", None
+        try:
+            res = self.trainer.explore_noise(self.current_data)
+            if res is None:
+                return "未找到合适的数值列进行噪声探索", None
+            summary = f"噪声探索结果： VRP 均值 {res['vrp_mean']:.6f}, VRP std {res['vrp_std']:.6f}, 残差自相关(1) {res['resid_stats']['ac1']:.4f}"
+            return summary, res
+        except Exception as e:
+            return f"噪声探索失败: {str(e)}", None
+    
+    def train_embedding(self, epochs=100):
+        """训练 Whitney 嵌入（autoencoder）"""
+        if self.current_data is None:
+            return "请先上传数据", None
+        try:
+            # 复用之前prepare_data的X构造方式，得到特征矩阵
+            X, y, causal = self.trainer.prepare_data(self.current_data)
+            if X is None:
+                return "数据不足以训练嵌入", None
+            X_np = X.numpy()
+            final_loss = self.trainer.train_embedding(X_np, epochs=epochs)
+            return f"嵌入训练完成, 最终重构损失 {final_loss:.6f}", None
+        except Exception as e:
+            return f"嵌入训练失败: {str(e)}", None
+    
+    def simulate_dynamics(self, start_vix2=1.0, start_rv=0.8, T=1.0, dt=0.01):
+        """模拟梯度动力学路径"""
+        try:
+            path = self.trainer.simulate_gradient_flow([start_vix2, start_rv], T=T, dt=dt)
+            return f"模拟完成，路径长度 {len(path)}", path
+        except Exception as e:
+            return f"模拟失败: {str(e)}", None
+    
+    def get_trading_strategy(self, user_question, intraday=False, generate_pseudocode=False, model_name=None):
         """获取交易策略"""
         if not self.analysis_results:
             return "请先上传并分析数据"
@@ -484,14 +774,18 @@ class TradingPlatform:
             if self.current_data is not None:
                 numeric_cols = self.current_data.select_dtypes(include=[np.number]).columns
                 if len(numeric_cols) > 0:
-                    latest_data = self.current_data[numeric_cols].tail(5).describe()
+                    latest_data = self.current_data[numeric_cols].tail(20).describe()
                     market_summary = latest_data.to_string()
             
             # 合并用户问题
             full_prompt = f"{user_question}\n\n当前分析结果：{json.dumps(self.analysis_results, indent=2)}\n\n市场数据：{market_summary}"
             
+            # 更新llm模型（可选）
+            if model_name:
+                self.llm = LLMInterface(model_name)
+            
             # 获取LLM回复
-            response = self.llm.analyze_trading(self.analysis_results, full_prompt)
+            response = self.llm.analyze_trading(self.analysis_results, full_prompt, intraday=intraday, generate_pseudocode=generate_pseudocode)
             
             return response
             
@@ -504,14 +798,13 @@ def create_interface():
     
     with gr.Blocks(title="港股智能分析平台", theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
-        # 🚀 港股智能分析平台 - 数学原理驱动
-        
-        ### 核心特性：
-        - 📊 **纤维丛理论**：高维市场状态的几何投影
-        - 🔄 **因果VAR模型**：动态因果关系发现
-        - 🌀 **等变神经网络**：SO(3)群对称性约束
-        - 🎯 **XPINNs生成器**：物理约束的域分解
-        - 🤖 **LLM策略生成**：基于数学分析的交易建议
+        # 🚀 港股智能分析平台 - 数学原理驱动（扩展版）
+        
+        新增功能：
+        - 噪声分离 / VRP 残差分析
+        - 基于 Whitney 嵌入的 autoencoder 与截面学习
+        - 梯度动力学（将梯度下降视作连续演化）模拟
+        - LLM 支持日内策略与伪代码输出（集成/回退模板）
         """)
         
         with gr.Tabs():
@@ -547,6 +840,23 @@ def create_interface():
                     outputs=[data_summary, analysis_result, status_text]
                 )
             
+            # 噪声探索与嵌入训练
+            with gr.TabItem("🔍 噪声探索 & 嵌入"):
+                with gr.Row():
+                    with gr.Column():
+                        noise_btn = gr.Button("运行噪声探索 (VIX^2 vs RV)", variant="primary")
+                        noise_summary = gr.Textbox(label="噪声探索摘要", lines=4, interactive=False)
+                        noise_details = gr.JSON(label="噪声探索详细结果", visible=False)
+                        embed_epochs = gr.Slider(minimum=20, maximum=500, value=100, step=20, label="嵌入训练轮数")
+                        embed_btn = gr.Button("训练 Whitney 嵌��", variant="primary")
+                        embed_status = gr.Textbox(label="嵌入训练状态", lines=2, interactive=False)
+                    
+                    with gr.Column():
+                        embed_plot = gr.Plot(label="嵌入（可视化）", visible=False)
+                
+                noise_btn.click(platform.run_noise_exploration, inputs=[], outputs=[noise_summary, noise_details])
+                embed_btn.click(platform.train_embedding, inputs=[embed_epochs], outputs=[embed_status, embed_plot])
+            
             # 模型训练标签
             with gr.TabItem("🧮 XPINNs模型训练"):
                 with gr.Row():
@@ -577,15 +887,13 @@ def create_interface():
             # 交易策略标签
             with gr.TabItem("💹 智能交易策略"):
                 gr.Markdown("""
-                ### 基于数学原理的交易策略生成
+                ### 基于数学原理的交易策略生成（扩展）
                 
                 系统将结合：
                 - 纤维丛投影的市场状态
                 - 因果VAR的动态关系
-                - 李雅普诺夫稳定性分析
-                - LLM智能推理
-                
-                为您生成专业的日内交易策略。
+                - 梯度动力学的演化模拟
+                - LLM智能推理（可输出伪代码）
                 """)
                 
                 with gr.Row():
@@ -599,16 +907,18 @@ def create_interface():
                         
                         user_input = gr.Textbox(
                             label="交易问题",
-                            placeholder="例如：基于当前分析，明天应该如何操作？重点关注哪些风险？",
+                            placeholder="例如：基于当前分析，今天的日内策略如何构造？请给出伪代码。",
                             lines=3
                         )
                         
+                        intraday_check = gr.Checkbox(label="日内策略 (intraday)", value=True)
+                        pseudocode_check = gr.Checkbox(label="生成伪代码", value=True)
                         strategy_btn = gr.Button("生成策略", variant="primary")
                     
                     with gr.Column():
                         strategy_output = gr.Textbox(
                             label="AI交易策略建议",
-                            lines=15,
+                            lines=20,
                             interactive=False
                         )
                 
@@ -624,54 +934,46 @@ def create_interface():
                 
                 strategy_btn.click(
                     platform.get_trading_strategy,
-                    inputs=[user_input],
+                    inputs=[user_input, intraday_check, pseudocode_check, model_dropdown],
                     outputs=[strategy_output]
                 )
             
+            # 梯度动力学模拟
+            with gr.TabItem("⚙️ 梯度动力学模拟"):
+                with gr.Row():
+                    with gr.Column():
+                        start_vix2 = gr.Number(value=1.0, label="初始 VIX^2")
+                        start_rv = gr.Number(value=0.8, label="初始 RV")
+                        T = gr.Number(value=1.0, label="模拟总时间 T")
+                        dt = gr.Number(value=0.01, label="时间步长 dt")
+                        sim_btn = gr.Button("运行模拟", variant="primary")
+                        sim_result = gr.Textbox(label="模拟结果", lines=3, interactive=False)
+                    with gr.Column():
+                        sim_plot = gr.Plot(label="模拟路径 (VIX^2, RV)")
+                
+                sim_btn.click(
+                    platform.simulate_dynamics,
+                    inputs=[start_vix2, start_rv, T, dt],
+                    outputs=[sim_result, sim_plot]
+                )
+            
             # 数学原理说明
             with gr.TabItem("📚 数学原理"):
-                gr.Markdown("""
-                ## 核心数学原理
-                
-                ### 1. 纤维丛理论 (Fiber Bundle Theory)
-                - **结构定义**: ξ = (E, π, B, F)
-                - **基空间 B**: 可观测因子 (VIX², RV)
-                - **总空间 E**: 高维市场状态
-                - **投影 π**: E → B 的降维映射
-                - **VRP截面**: s_VRP(b) = VIX² - RV
-                
-                ### 2. Whitney嵌入定理
-                - 保证2n维嵌入保留n维流形的所有微分结构
-                - 提供因子设计的理论下限
-                
-                ### 3. 梯度动力学
-                - **势函数**: U(b) = (VRP)²/2
-                - **演化方程**: db/dt = -η∇U(b) + σdW
-                - **李雅普诺夫稳定性**: V(t) ≤ V(0)e^(-αt)
-                
-                ### 4. SO(3)等变网络
-                - 保持旋转对称性: f(g·x) = g·f(x)
-                - 正交权重初始化
-                - 群作用下的不变性
-                
-                ### 5. XPINNs域分解
-                - 并行子域处理
-                - 界面条件约束
-                - 零曲率保证一致性
-                
-                ### 6. 因果VAR模型
-                - 动态因果发现
-                - Granger因果检验
-                - 脉冲响应分析
+                gr.Markdown(f"""
+                ## 核心数学原理（参考：你的笔记与论文）
+                - 纤维丛理论与VRP截面：参见上传的改进文档（BKKK改进）。:contentReference[oaicite:3]{index=3}
+                - Whitney嵌入定理与光滑嵌入：作为嵌入维度上限的理论依据。:contentReference[oaicite:4]{index=4}
+                - 等变网络与XPINNs：关于等变与几何保证的更系统论文。:contentReference[oaicite:5]{index=5}
+                - 梯度动力学视角：梯度下降路径可看作系统的演化路径、可扩展到SDE与Fokker-Planck 表述。:contentReference[oaicite:6]{index=6}
                 """)
         
         gr.Markdown("""
         ---
         ### 使用说明：
         1. 上传您的金融数据（CSV或Excel格式）
-        2. 系统自动进行数学分析和因果发现
-        3. 训练XPINNs模型学习数据模式
-        4. 使用LLM生成基于数学原理的交易策略
+        2. 运行噪声探索以获得 VRP/残差统计
+        3. 训练嵌入 / XPINNs 并模拟梯度动力学
+        4. 使用 LLM 生成日内/量化策略并选择是否输出伪代码
         
         **注意**: 本系统仅供研究参考，不构成投资建议。
         """)
@@ -680,10 +982,10 @@ def create_interface():
 
 # 主函数
 if __name__ == "__main__":
-    logger.info("启动港股智能分析平台...")
+    logger.info("启动港股智能分析平台（扩展版）...")
     interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False
-    )
+    )