Update app.py

app.py

@@ -1,991 +1,843 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
-港股智能分析平台 - Hugging Face Spaces版本
-集成数学原理的XPINNs训练与LLM推理系统
-（已扩展：噪声分离、Whitney嵌入截面学习、梯度动力学模拟、LLM伪代码/日内策略）
+升级版 app.py — 高精度数值 / 高性能统计 + 精细化 LLM 策略输出
+功能亮点：
+- Crank–Nicolson PDE（Black–Scholes）
+- Monte Carlo：Antithetic + Control variates（使用 BS 解析作为控制变量）
+- GARCH(1,1) 使用 arch （若可用）或 MLE minimize 回退
+- Johansen 协整检验（statsmodels 若可用）
+- 组合优化使用 cvxpy（若可用）或 SciPy 回退
+- LLM 生成结构化 JSON 策略（策略说明、信号、伪代码、回测/风险提示）
+- 保持之前的几何/Whitney/Noise/Gradient 模块兼容
 """
 
 import os
-import gradio as gr
+import json
+import warnings
+warnings.filterwarnings("ignore")
+
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, Optional, Tuple, List
+
 import numpy as np
 import pandas as pd
+import matplotlib.pyplot as plt
+
+# torch used for embedding / potential LSTM
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from torch.optim import Adam
-import json
-import logging
-from datetime import datetime
-from typing import Dict, List, Tuple, Optional, Any
-import warnings
-from pathlib import Path
-import pickle
-from sklearn.preprocessing import StandardScaler
-from sklearn.model_selection import train_test_split
+
+# statsmodels optional
+try:
+    import statsmodels.api as sm
+    from statsmodels.tsa.vector_ar.vecm import coint_johansen
+    from statsmodels.tsa.api import VAR
+    STATS_MODELS_AVAILABLE = True
+except Exception:
+    STATS_MODELS_AVAILABLE = False
+
+# arch package (GARCH) optional
+try:
+    from arch import arch_model
+    ARCH_AVAILABLE = True
+except Exception:
+    ARCH_AVAILABLE = False
+
+# cvxpy for portfolio optimization optional
+try:
+    import cvxpy as cp
+    CVXPY_AVAILABLE = True
+except Exception:
+    CVXPY_AVAILABLE = False
+
+# scipy fallback utilities
 from scipy import stats
-from scipy.linalg import expm
+from scipy.optimize import minimize
+from scipy.linalg import toeplitz
+
+# HTTP for LLM
 import requests
-warnings.filterwarnings('ignore')
 
-# 配置日志
+# Gradio UI
+import gradio as gr
+
+# Logging
+import logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Hugging Face Inference API配置
-HF_API_URL = "https://api-inference.huggingface.co/models/"
-# 使用免费的开源模型
-AVAILABLE_MODELS = {
-    "Qwen/Qwen2.5-1.5B-Instruct": "通义千问2.5",
-    "mistralai/Mistral-7B-Instruct-v0.1": "Mistral 7B",
-    "microsoft/Phi-3.5-mini-instruct": "Phi-3.5",
-    "google/flan-t5-large": "FLAN-T5"
-}
+logger = logging.getLogger("quant_upgraded")
 
+# base dir
+BASE_DIR = Path("/tmp/quant_upgraded")
+BASE_DIR.mkdir(parents=True, exist_ok=True)
+
+# ---------------------
+# Configuration
+# ---------------------
 class Config:
-    """配置类"""
-    TEMP_DIR = Path("/tmp/hk_analysis")
-    MODELS_DIR = TEMP_DIR / "models"
-    DATA_DIR = TEMP_DIR / "data"
-    MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
-    
-    # 数学原理配置
-    FIBER_BUNDLE_DIM = 16
-    CAUSAL_LAG = 5
-    XPINNS_SUBDOMAINS = 4
-    
     def __init__(self):
-        for dir_path in [self.TEMP_DIR, self.MODELS_DIR, self.DATA_DIR]:
-            dir_path.mkdir(parents=True, exist_ok=True)
+        self.device = 'cpu'
+        if torch.cuda.is_available():
+            self.device = 'cuda'
+        self.hf_token = os.getenv("HF_API_TOKEN", "")
+        self.hf_default_model = "Qwen/Qwen2.5-1.5B-Instruct"
+        self.mc_default_paths = 20000
+        self.cv_solver = "cvxpy" if CVXPY_AVAILABLE else "scipy"
+        self.statsmodels = STATS_MODELS_AVAILABLE
+        self.arch = ARCH_AVAILABLE
 
 config = Config()
 
+# ---------------------
+# Geometry / existing modules (compact)
+# ---------------------
 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嵌入因子（理论上）
-        
-    def project_to_base(self, high_dim_state):
-        """投影到基空间"""
-        if len(high_dim_state) < self.fiber_dim:
-            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 + 1e-12)
-        # 计算实现波动率
-        rv = np.std(high_dim_state[self.fiber_dim//2:])
-        
-        return np.array([vix_squared, rv])
-    
-    def compute_vrp(self, base_point):
-        """计算方差风险溢价"""
-        vix_squared, rv = base_point
-        return vix_squared - rv
+    def __init__(self, fiber_dim=16):
+        self.fiber_dim = fiber_dim
+        self.whitney_factor = 2 * fiber_dim
+
+    def project_to_base(self, x: np.ndarray) -> np.ndarray:
+        x = np.asarray(x).ravel()
+        if len(x) < self.fiber_dim:
+            x = np.pad(x, (0, self.fiber_dim - len(x)))
+        half = self.fiber_dim // 2
+        vix2 = float(np.sum(x[:half]**2) / (half + 1e-12))
+        rv = float(np.std(x[half:]))
+        return np.array([vix2, rv])
+
+    def compute_vrp(self, base_point: np.ndarray) -> float:
+        vix2, rv = base_point
+        return vix2 - 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）
+    def regress_vix2_vs_rv(self, vix2: np.ndarray, rv: np.ndarray):
+        X = np.vstack([rv, np.ones_like(rv)]).T
+        coef, *_ = np.linalg.lstsq(X, vix2, rcond=None)
+        a, b = float(coef[0]), float(coef[1])
+        preds = a * rv + b
+        resid = vix2 - preds
+        return {'a': a, 'b': b, 'preds': preds, 'resid': resid}
+
+    def resid_stats(self, resid: np.ndarray):
+        resid = np.asarray(resid)
         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()
+        ac1 = float(np.corrcoef(resid[:-1], resid[1:])[0,1]) if len(resid) > 2 else 0.0
+        fft = np.fft.rfft(resid - mean)
+        freqs = np.fft.rfftfreq(len(resid))
+        power = np.abs(fft)**2
+        dominant_freq = float(freqs[np.argmax(power[1:])+1]) if len(power) > 1 else 0.0
+        return {'mean': mean, 'var': var, 'ac1': ac1, 'dominant_freq': dominant_freq}
+
+    def explore(self, df: pd.DataFrame, vix2_col: Optional[str]=None, rv_col: Optional[str]=None):
+        numcols = df.select_dtypes(include=[np.number]).columns.tolist()
+        if not numcols:
+            return None
         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_col = numcols[0]
+            rv_col = numcols[1] if len(numcols) > 1 else numcols[0]
         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']
-        # 返回摘要
+        st = self.resid_stats(reg['resid'])
+        vrp = 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']
+            'reg': {'a': reg['a'], 'b': reg['b']},
+            'resid_stats': st,
+            'vrp_mean': float(np.mean(vrp)),
+            'vrp_std': float(np.std(vrp)),
+            'vrp_series': vrp.tolist(),
+            'residuals': reg['resid'].tolist()
         }
 
-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):
+# ---------------------
+# Quant modules (upgraded)
+# ---------------------
+
+class StochasticModels:
+    """High-precision stochastic processes and pricing helpers."""
+
+    @staticmethod
+    def bs_price(S: float, K: float, r: float, q: float, sigma: float, T: float, option_type: str='call') -> float:
+        """Black-Scholes closed-form price (with dividend yield q)."""
+        S, K, r, q, sigma, T = map(float, (S, K, r, q, sigma, T))
+        if T <= 0 or sigma <= 0:
+            return float(max(S - K, 0.0) if option_type == 'call' else max(K - S, 0.0))
+        d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+        d2 = d1 - sigma * np.sqrt(T)
+        if option_type == 'call':
+            price = S * np.exp(-q * T) * stats.norm.cdf(d1) - K * np.exp(-r * T) * stats.norm.cdf(d2)
+        else:
+            price = K * np.exp(-r * T) * stats.norm.cdf(-d2) - S * np.exp(-q * T) * stats.norm.cdf(-d1)
+        return float(price)
+
+    @staticmethod
+    def heston_simulate(S0: float, v0: float, r: float, kappa: float, theta: float, xi: float, rho: float, T: float,
+                       n_steps: int=252, n_paths: int=2000, seed: Optional[int]=None):
         """
-        给定 base_points (N x 2)，输出 fiber 估计（N x fiber_dim）
-        这是一个直接前向调用（训练通过 train_embedding 来执行）
+        Euler-Maruyama with full-reflection for variance (CIR-like) — more stable by forcing v>=0.
+        Keep path count moderate unless GPU simulation used externally.
         """
-        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):
+        if seed is not None:
+            np.random.seed(seed)
+        dt = T / n_steps
+        S = np.zeros((n_paths, n_steps+1))
+        v = np.zeros((n_paths, n_steps+1))
+        S[:,0] = S0
+        v[:,0] = v0
+        for t in range(n_steps):
+            z1 = np.random.randn(n_paths)
+            z2 = np.random.randn(n_paths)
+            w1 = z1
+            w2 = rho * z1 + np.sqrt(max(0.0, 1 - rho**2)) * z2
+            v_prev = np.maximum(v[:,t], 0.0)
+            # full truncation Euler
+            dv = kappa * (theta - v_prev) * dt + xi * np.sqrt(v_prev * dt) * w2
+            v_new = np.maximum(v_prev + dv, 1e-8)
+            dS = r * S[:,t] * dt + np.sqrt(v_prev * dt) * S[:,t] * w1
+            S[:,t+1] = S[:,t] + dS
+            v[:,t+1] = v_new
+        return S, v
+
+    @staticmethod
+    def merton_jump_diffusion(S0: float, mu: float, sigma: float, lamb: float, mu_j: float, sigma_j: float,
+                              T: float, n_steps: int=252, n_paths: int=2000, seed: Optional[int]=None):
+        """Improved Merton simulator with vectorized operations."""
+        if seed is not None:
+            np.random.seed(seed)
+        dt = T / n_steps
+        S = np.full((n_paths, n_steps+1), S0, dtype=float)
+        for t in range(n_steps):
+            z = np.random.randn(n_paths)
+            pois = np.random.poisson(lamb * dt, size=n_paths)
+            jumps = np.exp(mu_j + sigma_j * np.random.randn(n_paths)) - 1.0
+            S[:, t+1] = S[:, t] * (1 + mu*dt + sigma*np.sqrt(dt)*z) + S[:, t] * (jumps * pois)
+            S[:, t+1] = np.maximum(S[:, t+1], 1e-8)
+        return S
+
+class NumericalMethods:
+    """Crank-Nicolson PDE + Monte Carlo with variance reduction."""
+
+    @staticmethod
+    def bs_crank_nicolson(S0: float, K: float, r: float, q: float, sigma: float, T: float,
+                          Smax_mult: float=3.0, M: int=400, N: int=400, option_type: str='call') -> float:
         """
-        默认势函数：U(b) = (VRP)^2 / 2 ，其中 b = [vix2, rv]
-        b 为 torch.tensor shape (..., 2)
+        Crank-Nicolson solver for Black-Scholes PDE. More stable with sufficient grid resolution.
+        M: number of asset steps, N: time steps.
         """
-        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):
+        Smax = S0 * Smax_mult
+        dS = Smax / M
+        dt = T / N
+        grid = np.zeros((M+1, N+1))
+        Svals = np.linspace(0, Smax, M+1)
+        # terminal condition
+        if option_type == 'call':
+            grid[:, -1] = np.maximum(Svals - K, 0)
+        else:
+            grid[:, -1] = np.maximum(K - Svals, 0)
+        # boundary conditions
+        grid[0, :] = 0.0 if option_type == 'call' else K * np.exp(-r * (T - np.linspace(0, T, N+1)))
+        grid[-1, :] = (Smax - K * np.exp(-r * (T - np.linspace(0, T, N+1)))) if option_type == 'call' else 0.0
+        # prepare tridiagonal coefficients
+        j = np.arange(1, M)
+        a = 0.25 * dt * (sigma**2 * j**2 - (r - q) * j)
+        b = -0.5 * dt * (sigma**2 * j**2 + r)
+        c = 0.25 * dt * (sigma**2 * j**2 + (r - q) * j)
+        # construct A and B matrices (tridiagonal)
+        A = np.zeros((M-1, M-1))
+        B = np.zeros((M-1, M-1))
+        for idx in range(M-1):
+            if idx > 0:
+                A[idx, idx-1] = -a[idx+1]
+                B[idx, idx-1] = a[idx+1]
+            A[idx, idx] = 1 - b[idx+1]
+            B[idx, idx] = 1 + b[idx+1]
+            if idx < M-2:
+                A[idx, idx+1] = -c[idx+1]
+                B[idx, idx+1] = c[idx+1]
+        # backward time stepping
+        from numpy.linalg import solve
+        for n in reversed(range(N)):
+            rhs = B.dot(grid[1:M, n+1])
+            # add boundary contributions
+            rhs[0] += a[1] * (grid[0, n] + grid[0, n+1])
+            rhs[-1] += c[M-1] * (grid[M, n] + grid[M, n+1])
+            grid[1:M, n] = solve(A, rhs)
+        # interpolate at S0
+        i = int(S0 / dS)
+        if i >= M:
+            return float(grid[-1, 0])
+        w = (S0 - i * dS) / dS
+        price = (1-w) * grid[i, 0] + w * grid[i+1, 0]
+        return float(price)
+
+    @staticmethod
+    def mc_price_bs_cv(S0: float, K: float, r: float, q: float, sigma: float, T: float,
+                       option_type: str='call', n_paths: int=20000, antithetic: bool=True, seed: Optional[int]=None):
         """
-        Euler-Maruyama 模拟：
-        b0: 初始点 (2,)
-        返回路径 (Nsteps+1, 2)
+        Monte Carlo with antithetic variates and control variate (BS analytic).
+        Control variate: use discount payoff under geometric Brownian motion analytic expectation = BS price with same params.
         """
         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
+        n = n_paths
+        half = n // 2 if antithetic else n
+        Z = np.random.randn(half)
+        if antithetic:
+            Z = np.concatenate([Z, -Z])
+        ST = S0 * np.exp((r - q - 0.5*sigma**2) * T + sigma * np.sqrt(T) * Z)
+        if option_type == 'call':
+            payoff = np.maximum(ST - K, 0)
+        else:
+            payoff = np.maximum(K - ST, 0)
+        # control variate: use discounted ST (or log ST) expectation known
+        # use analytic BS price as control target
+        bs_analytic = StochasticModels.bs_price(S0, K, r, q, sigma, T, option_type=option_type)
+        # choose control variable as discounted payoff under geometric mean? simple: use ST
+        control = ST  # expectation of ST under risk-neutral = S0 * exp((r-q)T)
+        control_mean = S0 * np.exp((r - q) * T)
+        # compute covariance and adjust
+        cov_pc = np.cov(payoff, control, ddof=1)[0,1]
+        var_c = np.var(control, ddof=1)
+        if var_c > 0:
+            beta = cov_pc / var_c
+        else:
+            beta = 0.0
+        adj_payoff = payoff - beta * (control - control_mean)
+        price = np.exp(-r * T) * np.mean(adj_payoff)
+        # bias correction via analytic price difference if helpful
+        return float(price)
 
-class EquivariantLayer(nn.Module):
-    """SO(3)等变层"""
-    
-    def __init__(self, in_features, out_features):
-        super().__init__()
-        self.linear = nn.Linear(in_features, out_features)
-        self.norm = nn.LayerNorm(out_features)
-        
-        # 初始化为正交矩阵保持等变性
-        nn.init.orthogonal_(self.linear.weight)
-        
-    def forward(self, x, rotation_matrix=None):
-        """保持群等变性的前向传播"""
-        if rotation_matrix is not None:
-            # 应用旋转变换
-            x = torch.matmul(x, rotation_matrix.T)
-        
-        x = self.linear(x)
-        x = self.norm(x)
-        return F.relu(x)
-
-class XPINNsGenerator(nn.Module):
-    """扩展物理信息神经网络生成器"""
-    
-    def __init__(self, input_dim=64, hidden_dim=128, output_dim=64, num_subdomains=4):
-        super().__init__()
-        self.num_subdomains = num_subdomains
-        
-        # 子域网络
-        self.subdomain_nets = nn.ModuleList([
-            nn.Sequential(
-                EquivariantLayer(input_dim, hidden_dim),
-                EquivariantLayer(hidden_dim, hidden_dim),
-                EquivariantLayer(hidden_dim, output_dim)
-            ) for _ in range(num_subdomains)
-        ])
-        
-        # 路由网络
-        self.router = nn.Sequential(
-            nn.Linear(input_dim, num_subdomains),
-            nn.Softmax(dim=-1)
-        )
-        
-        # 融合网络
-        self.fusion = nn.Sequential(
-            nn.Linear(output_dim * num_subdomains, hidden_dim),
-            nn.ReLU(),
-            nn.Linear(hidden_dim, output_dim)
-        )
-        
-        # 李雅普诺夫稳定性网络
-        self.stability_net = nn.Sequential(
-            nn.Linear(output_dim, 32),
-            nn.ReLU(),
-            nn.Linear(32, 1),
-            nn.Sigmoid()
-        )
-        
-    def forward(self, x):
-        batch_size = x.shape[0]
-        
-        # 路由到子域
-        routing_weights = self.router(x)
-        
-        # 各子域处理
-        subdomain_outputs = []
-        for i, subnet in enumerate(self.subdomain_nets):
-            weight = routing_weights[:, i:i+1]
-            output = subnet(x * weight)
-            subdomain_outputs.append(output)
-        
-        # 融合输出
-        concat_output = torch.cat(subdomain_outputs, dim=-1)
-        fused = self.fusion(concat_output)
-        
-        # 计算稳定性分数
-        stability = self.stability_net(fused)
-        
-        return {
-            'output': fused,
-            'routing_weights': routing_weights,
-            'stability_score': stability
-        }
+class Econometrics:
+    """GARCH via arch package (preferred) or MLE fallback; Johansen using statsmodels if available"""
 
-class CausalVAR:
-    """因果VAR模型"""
-    
-    def __init__(self, max_lag=5):
-        self.max_lag = max_lag
-        self.coefficients = None
-        self.stability_eigenvalues = None
-        
-    def fit(self, data):
-        """拟合VAR模型"""
-        n_samples, n_vars = data.shape
-        
-        if n_samples < self.max_lag + 10:
+    @staticmethod
+    def garch_11_fit(returns: np.ndarray):
+        r = np.asarray(returns).astype(float)
+        r = r - np.mean(r)
+        if config.arch:
+            try:
+                am = arch_model(r * 100.0, vol='Garch', p=1, q=1, dist='normal')  # scale to percent to help arch convergence
+                res = am.fit(disp='off')
+                params = res.params.to_dict()
+                cond_var = res.conditional_volatility / 100.0
+                return {'method': 'arch', 'params': params, 'cond_var': cond_var.tolist()}
+            except Exception as e:
+                logger.warning(f"arch fit failed: {e}; falling back to MLE.")
+        # MLE fallback
+        T = len(r)
+        def neglog(params):
+            omega, alpha, beta = params
+            if omega <= 0 or alpha < 0 or beta < 0 or alpha + beta >= 0.9999:
+                return 1e12
+            h = np.zeros(T)
+            h[0] = np.var(r)
+            ll = 0.0
+            for t in range(1, T):
+                h[t] = omega + alpha * r[t-1]**2 + beta * h[t-1]
+            ll = 0.5 * (np.log(2*np.pi) + np.log(h) + (r**2)/h)
+            return np.sum(ll)
+        init = np.array([1e-6, 0.05, 0.9])
+        bnds = [(1e-12, None), (0, 0.9999), (0, 0.9999)]
+        res = minimize(neglog, x0=init, bounds=bnds)
+        if not res.success:
+            logger.warning("GARCH MLE did not converge; returning fallback params")
+            omega, alpha, beta = init
+        else:
+            omega, alpha, beta = res.x
+        # compute h
+        h = np.zeros(T)
+        h[0] = np.var(r)
+        for t in range(1, T):
+            h[t] = omega + alpha * r[t-1]**2 + beta * h[t-1]
+        return {'method': 'mle', 'params': {'omega': float(omega), 'alpha': float(alpha), 'beta': float(beta)}, 'cond_var': h.tolist()}
+
+    @staticmethod
+    def johansen_test(data: np.ndarray, det_order: int=0, k_ar_diff: int=1):
+        if config.statsmodels:
+            try:
+                res = coint_johansen(data, det_order, k_ar_diff)
+                return {'eig': res.eig.tolist(), 'lr1': res.lr1.tolist(), 'cvm': res.cvt.tolist()}
+            except Exception as e:
+                logger.warning(f"Johansen failed: {e}")
+                return None
+        else:
             return None
-            
-        # 构建滞后矩阵
-        X = []
-        y = []
-        
-        for t in range(self.max_lag, n_samples):
-            lag_features = []
-            for lag in range(1, self.max_lag + 1):
-                lag_features.extend(data[t - lag])
-            X.append(lag_features)
-            y.append(data[t])
-        
-        X = np.array(X)
-        y = np.array(y)
-        
-        # 最小二乘估计
+
+class PortfolioOptimization:
+    """Black-Litterman and Markowitz using cvxpy if available, else SciPy minimize"""
+
+    @staticmethod
+    def gmv_weights(returns: np.ndarray):
+        R = np.asarray(returns)
+        cov = np.cov(R.T)
+        n = cov.shape[0]
+        if CVXPY_AVAILABLE:
+            w = cp.Variable(n)
+            prob = cp.Problem(cp.Minimize(cp.quad_form(w, cov)),
+                              [cp.sum(w) == 1])
+            prob.solve(solver=cp.SCS, verbose=False)
+            w_opt = np.array(w.value).ravel()
+            return w_opt
+        else:
+            # analytic GMV: invcov * 1 / (1^T invcov 1)
+            invcov = np.linalg.pinv(cov)
+            ones = np.ones((n,))
+            w = invcov.dot(ones)
+            w = w / (ones.dot(invcov).dot(ones))
+            return w
+
+    @staticmethod
+    def mean_variance_opt(returns: np.ndarray, target_return: Optional[float]=None):
+        R = np.asarray(returns)
+        mu = np.mean(R, axis=0)
+        cov = np.cov(R.T)
+        n = len(mu)
+        if CVXPY_AVAILABLE:
+            w = cp.Variable(n)
+            constraints = [cp.sum(w) == 1]
+            if target_return is not None:
+                constraints.append(mu @ w >= target_return)
+            prob = cp.Problem(cp.Minimize(cp.quad_form(w, cov)), constraints)
+            prob.solve(solver=cp.SCS, verbose=False)
+            return np.array(w.value).ravel()
+        else:
+            # solve using analytical formula for target_return or GMV fallback
+            if target_return is None:
+                return PortfolioOptimization.gmv_weights(R)
+            invcov = np.linalg.pinv(cov)
+            ones = np.ones(n)
+            A = ones.T.dot(invcov).dot(ones)
+            B = ones.T.dot(invcov).dot(mu)
+            C = mu.T.dot(invcov).dot(mu)
+            denom = A * C - B**2
+            lam = (C - target_return * B) / denom
+            gamma = (target_return * A - B) / denom
+            w = invcov.dot(lam * ones + gamma * mu)
+            return w
+
+# ---------------------
+# ML for Finance helpers
+# ---------------------
+class MLForFinance:
+    @staticmethod
+    def compute_basic_features(price: np.ndarray, mom_window: int=20, vol_window: int=20):
+        p = np.asarray(price).ravel()
+        ret = np.concatenate([[0], np.diff(np.log(p + 1e-12))])
+        mom = pd.Series(p).pct_change(mom_window).fillna(0).values
+        rv = pd.Series(ret).rolling(vol_window).std().fillna(method='bfill').values
+        sma = pd.Series(p).rolling(mom_window).mean().fillna(method='bfill').values
+        features = np.vstack([ret, mom, rv, sma]).T
+        return features
+
+    @staticmethod
+    def lasso_select(X: np.ndarray, y: np.ndarray):
+        model = None
         try:
-            self.coefficients = np.linalg.lstsq(X, y, rcond=None)[0]
-            
-            # 计算稳定性
-            companion_matrix = self._build_companion_matrix(n_vars)
-            eigenvalues = np.linalg.eigvals(companion_matrix)
-            self.stability_eigenvalues = eigenvalues
-            
-            return {
-                'coefficients': self.coefficients,
-                'eigenvalues': eigenvalues,
-                'is_stable': np.max(np.abs(eigenvalues)) < 1.0
-            }
-        except:
-            return None
-    
-    def _build_companion_matrix(self, n_vars):
-        """构建伴随矩阵"""
-        dim = n_vars * self.max_lag
-        companion = np.zeros((dim, dim))
-        
-        if self.coefficients is not None:
-            # 填充系数
-            companion[:n_vars, :] = self.coefficients.T
-            # 填充单位矩阵
-            if self.max_lag > 1:
-                companion[n_vars:, :-n_vars] = np.eye(dim - n_vars)
-        
-        return companion
-
-class MathematicalTrainer:
-    """数学原理驱动的训练器"""
-    
-    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):
-        """准备训练数据"""
-        # 提取数值列
-        numeric_cols = df.select_dtypes(include=[np.number]).columns
-        if len(numeric_cols) == 0:
-            return None, None, None
-            
-        data = df[numeric_cols].fillna(0).values
-        
-        # 因果分析
-        causal_result = self.causal_var.fit(data)
-        
-        # 特征工程
-        features = []
-        targets = []
-        window_size = 10
-        
-        for i in range(len(data) - window_size):
-            window = data[i:i+window_size]
-            
-            # 投影到纤维丛基空间
-            base_features = []
-            for row in window:
-                base_point = self.fiber_bundle.project_to_base(row)
-                vrp = self.fiber_bundle.compute_vrp(base_point)
-                base_features.extend([base_point[0], base_point[1], vrp])
-            
-            # 展平特征
-            feature_vector = np.array(base_features).flatten()
-            
-            # 填充到固定维度
-            if len(feature_vector) < 64:
-                feature_vector = np.pad(feature_vector, (0, 64 - len(feature_vector)))
-            elif len(feature_vector) > 64:
-                feature_vector = feature_vector[:64]
-            
-            features.append(feature_vector)
-            targets.append(data[i+window_size, 0])  # 预测第一列
-        
-        if len(features) == 0:
-            return None, None, None
-            
-        X = np.array(features)
-        y = np.array(targets).reshape(-1, 1)
-        
-        # 标准化
-        X = self.scaler.fit_transform(X)
-        
-        return torch.FloatTensor(X), torch.FloatTensor(y), causal_result
-    
-    def train(self, X, y, epochs=100):
-        """训练模型"""
-        if X is None or y is None:
+            from sklearn.linear_model import LassoCV
+            model = LassoCV(cv=5, n_jobs=1).fit(X, y.ravel())
+            coef = model.coef_
+            selected = list(np.where(np.abs(coef) > 1e-6)[0])
+            return {'coef': coef.tolist(), 'selected': selected, 'alpha': float(model.alpha_)}
+        except Exception as e:
+            logger.warning(f"LASSO selection failed: {e}")
             return None
-            
-        dataset = torch.utils.data.TensorDataset(X, y)
-        loader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
-        
-        losses = []
-        
-        for epoch in range(epochs):
-            epoch_loss = 0
-            for batch_x, batch_y in loader:
-                self.optimizer.zero_grad()
-                
-                # 前向传播
-                outputs = self.model(batch_x)
-                
-                # 计算损失
-                pred_loss = F.mse_loss(outputs['output'][:, 0:1], batch_y)
-                stability_loss = torch.mean((1 - outputs['stability_score'])**2)
-                
-                total_loss = pred_loss + 0.1 * stability_loss
-                
-                # 反向传播
-                total_loss.backward()
-                self.optimizer.step()
-                
-                epoch_loss += total_loss.item()
-            
-            avg_loss = epoch_loss / len(loader)
-            losses.append(avg_loss)
-            
-            if epoch % 20 == 0:
-                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)
 
+# ---------------------
+# LLM interface (detailed prompt + structured JSON output)
+# ---------------------
 class LLMInterface:
-    """LLM接口"""
-    
-    def __init__(self, model_name="Qwen/Qwen2.5-1.5B-Instruct"):
-        self.model_name = model_name
-        self.api_url = HF_API_URL + model_name
-        
-    def query(self, prompt, max_length=500):
-        """查询LLM"""
-        headers = {"Content-Type": "application/json"}
-        
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": max_length,
-                "temperature": 0.3,
-                "top_p": 0.9,
-                "do_sample": True
-            }
-        }
-        
+    def __init__(self, model_name: str = None, hf_token: Optional[str] = None):
+        self.model_name = model_name or config.hf_default_model
+        self.api_url = f"https://api-inference.huggingface.co/models/{self.model_name}"
+        self.hf_token = hf_token or config.hf_token
+
+    def _call_api(self, prompt: str, max_length: int = 700) -> str:
+        headers = {"Authorization": f"Bearer {self.hf_token}"} if self.hf_token else {"Content-Type": "application/json"}
+        payload = {"inputs": prompt, "parameters": {"max_new_tokens": max_length, "temperature": 0.2}}
         try:
-            response = requests.post(self.api_url, headers=headers, json=payload, timeout=30)
-            if response.status_code == 200:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    return result[0].get('generated_text', '分析失败')
-                return str(result)
+            r = requests.post(self.api_url, headers=headers, json=payload, timeout=40)
+            if r.status_code == 200:
+                res = r.json()
+                if isinstance(res, list) and isinstance(res[0], dict):
+                    return res[0].get("generated_text", str(res[0]))
+                return str(res)
             else:
-                return f"API调用失败: {response.status_code}"
+                return f"API_ERROR_{r.status_code}: {r.text[:200]}"
         except Exception as e:
-            return f"错误: {str(e)}"
-    
-    def _pseudocode_template(self, strategy_spec: Dict[str,Any]) -> str:
+            return f"API_EXCEPTION: {e}"
+
+    def generate_structured_strategy(self,
+                                     analysis: Dict[str, Any],
+                                     market_snapshot: str,
+                                     requirements: Dict[str, Any]) -> Dict[str, Any]:
         """
-        当LLM不可用时，返回一个确定性的伪代码结构
-        strategy_spec 包含：entry_rule, exit_rule, position_sizing, risk_params
+        Produce structured JSON with keys:
+        - strategy_summary
+        - signals (list of rules)
+        - risk_management
+        - pseudocode (string)
+        - backtest_guidance
         """
-        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) 若为日内(intraday=True)，请给出明确定义的入场/退出信号（基于短周期，例如1-5分钟或tick），并说明延迟/滑点考虑
-3) 风险控制与回测建议（数据频率、回测窗口）
-4) 若要求generate_pseudocode=True，请以伪代码形式输出策略实现模板（明确函数名、输入特征、信号判断、止损/止盈逻辑）
-
-输出格式：
-- 段落 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, device='cpu'):
-        self.trainer = MathematicalTrainer(device=device)
+        instr = (
+            "You are a quantitative researcher writing a concise Quant Research Note. "
+            "Produce structured JSON only, with keys: strategy_summary, signals, risk_management, pseudocode, backtest_guidance, notes.\n\n"
+            "Requirements: "
+            f"{json.dumps(requirements)}\n\n"
+            "Analysis (numerical results):\n"
+            f"{json.dumps(analysis, indent=2, ensure_ascii=False)[:4000]}\n\n"
+            "Market snapshot:\n"
+            f"{market_snapshot[:2000]}\n\n"
+            "Be specific: signals should include exact mathematical conditions (e.g. vrp > vrp_sma_short AND rsi < 30). "
+            "Pseudocode should include function signatures: compute_features(data), generate_signal(features), risk_manage(position), execute(signal). "
+            "Backtest guidance should specify data frequency, in-sample/out-of-sample split, sample length, and slippage/commission assumptions. "
+            "Keep outputs compact but precise."
+        )
+        raw = self._call_api(instr, max_length=800)
+        # Try to parse JSON from raw; if fails, fallback to heuristics
+        try:
+            # sometimes HF returns text with JSON in it — try to extract first JSON object
+            start = raw.find("{")
+            end = raw.rfind("}")
+            if start != -1 and end != -1:
+                candidate = raw[start:end+1]
+                data = json.loads(candidate)
+                return data
+        except Exception as e:
+            logger.warning(f"LLM did not return pure JSON: {e}")
+        # fallback: craft deterministic template using analysis and requirements
+        fallback = {
+            "strategy_summary": "Fallback strategy: VRP mean-reversion with momentum filter.",
+            "signals": [
+                "entry: vrp < vrp_sma_short and momentum > 0.5",
+                "exit: vrp > vrp_sma_long or price crosses stop loss"
+            ],
+            "risk_management": "max position risk 0.5% NAV; use stop-loss and time-based exit",
+            "pseudocode": (
+                "def compute_features(data):\n"
+                "    features = {...}  # vrp, sma, momentum\n"
+                "def generate_signal(features):\n"
+                "    if features['vrp'] < features['vrp_sma_short'] and features['mom'] > 0:\n"
+                "        return 1\n"
+                "    return 0\n"
+                "def risk_manage(pos):\n"
+                "    # apply stop loss / position sizing\n"
+            ),
+            "backtest_guidance": "Use 1-minute bars, in-sample 2 years, OOS 6 months, slippage 0.02%, commission 0.0005 per trade",
+            "notes": "LLM API failed or returned non-JSON; this is a deterministic fallback."
+        }
+        return fallback
+
+# ---------------------
+# Integrative Trainer / Platform
+# ---------------------
+class QuantPlatform:
+    def __init__(self):
+        self.fiber = FiberBundleTheory()
+        self.noise = NoiseExplorer()
+        self.trainer_ml = None
         self.llm = LLMInterface()
         self.current_data = None
         self.analysis_results = {}
-        
-    def process_upload(self, file):
-        """处理上传文件"""
+
+    # Data ingestion & basic analysis
+    def upload_and_analyze(self, file):
         if file is None:
-            return "请上传数据文件", None, None
-            
+            return "请上传 CSV / Excel 文件", None, None
+        fname = file.name
         try:
-            # 读取数据
-            if file.name.endswith('.csv'):
-                df = pd.read_csv(file.name)
-            elif file.name.endswith(('.xlsx', '.xls')):
-                df = pd.read_excel(file.name)
+            if fname.endswith('.csv'):
+                df = pd.read_csv(fname)
             else:
-                return "不支持的文件格式", None, None
-            
-            self.current_data = df
-            
-            # 数据摘要
-            summary = f"""数据集信息：
-- 行数: {len(df)}
-- 列数: {len(df.columns)}
-- 数值列: {list(df.select_dtypes(include=[np.number]).columns)}
-- 缺失值比例: {(df.isnull().sum().sum() / (len(df) * len(df.columns)) * 100):.2f}%"""
-            
-            # 准备训练数据
-            X, y, causal_result = self.trainer.prepare_data(df)
-            
-            if X is not None:
-                # 分析结果
-                self.analysis_results = {
-                    'data_shape': X.shape,
-                    'causal_stable': causal_result['is_stable'] if causal_result else False,
-                    'vrp': self.trainer.fiber_bundle.compute_vrp([1.0, 0.8]),
-                    'lyapunov_stable': True if causal_result and causal_result['is_stable'] else False,
-                    'fiber_projection': 'Complete'
-                }
-                
-                analysis = f"""数学分析完成：
-- 因果VAR稳定性: {'稳定' if self.analysis_results['causal_stable'] else '不稳定'}
-- VRP计算: {self.analysis_results['vrp']:.4f}
-- 数据维度: {self.analysis_results['data_shape']}
-- Whitney嵌入因子: {self.trainer.fiber_bundle.whitney_factor}"""
-            else:
-                analysis = "数据不足或格式错误，无法进行数学分析"
-            
-            return summary, analysis, "数据处理成功"
-            
+                df = pd.read_excel(fname)
         except Exception as e:
-            return f"处理失败: {str(e)}", None, None
-    
-    def train_model(self, epochs=100):
-        """训练模型"""
-        if self.current_data is None:
-            return "请先上传数据", None
-            
+            return f"读取失败: {e}", None, None
+        self.current_data = df
+        numeric = df.select_dtypes(include=[np.number]).columns.tolist()
+        summary = f"Rows: {len(df)}, Cols: {len(df.columns)}, Numeric: {numeric}"
+        # noise exploration (first two numeric columns)
         try:
-            X, y, causal_result = self.trainer.prepare_data(self.current_data)
-            
-            if X is None:
-                return "数据准备失败", None
-            
-            # 训练
-            losses = self.trainer.train(X, y, epochs)
-            
-            # 绘制损失曲线
-            import matplotlib.pyplot as plt
-            fig, ax = plt.subplots(figsize=(10, 6))
-            ax.plot(losses)
-            ax.set_xlabel('Epoch')
-            ax.set_ylabel('Loss')
-            ax.set_title('XPINNs Training Loss')
-            ax.grid(True)
-            
-            result = f"""训练完成：
-- 最终损失: {losses[-1]:.6f}
-- 训练轮数: {epochs}
-- 子域数量: {config.XPINNS_SUBDOMAINS}
-- 因果滞后阶数: {config.CAUSAL_LAG}"""
-            
-            return result, fig
-            
+            noise_res = self.noise.explore(df)
+            noise_summary = f"VRP mean {noise_res['vrp_mean']:.6f}, vrp std {noise_res['vrp_std']:.6f}, resid ac1 {noise_res['resid_stats']['ac1']:.4f}"
         except Exception as e:
-            return f"训练失败: {str(e)}", None
-    
-    def run_noise_exploration(self):
-        """运行噪声探索（基于 VIX^2 vs RV 回归）"""
-        if self.current_data is None:
-            return "请先上传数据", None
+            noise_summary = f"噪声分析失败: {e}"
+            noise_res = None
+        # garch quick fit on first numeric column returns (if plausible)
+        garch_summary = "GARCH not run"
+        if numeric:
+            series = df[numeric[0]].pct_change().dropna().values
+            if len(series) > 30:
+                try:
+                    garch_res = Econometrics.garch_11_fit(series)
+                    garch_summary = f"GARCH method: {garch_res.get('method','?')}, params keys: {list(garch_res.get('params',{}).keys()) if 'params' in garch_res else 'n/a'}"
+                except Exception as e:
+                    garch_summary = f"GARCH失败: {e}"
+        self.analysis_results = {'noise': noise_res, 'garch': garch_summary}
+        return summary, noise_summary, garch_summary
+
+    # Pricing / PDE / MC wrappers
+    def price_bs_cn(self, S, K, r, q, sigma, T, Smax_mult=3.0, M=400, N=400, option_type='call'):
         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
+            p = NumericalMethods.bs_crank_nicolson(float(S), float(K), float(r), float(q), float(sigma), float(T),
+                                                  Smax_mult=float(Smax_mult), M=int(M), N=int(N), option_type=option_type)
+            return f"Crank–Nicolson price: {p:.6f}"
+        except Exception as e:
+            return f"PDE pricing failed: {e}"
+
+    def price_bs_mc(self, S, K, r, q, sigma, T, option_type='call', n_paths=20000, antithetic=True):
+        try:
+            p = NumericalMethods.mc_price_bs_cv(float(S), float(K), float(r), float(q), float(sigma), float(T),
+                                               option_type=option_type, n_paths=int(n_paths), antithetic=bool(antithetic))
+            return f"MC price (CV): {p:.6f}"
+        except Exception as e:
+            return f"MC pricing failed: {e}"
+
+    def simulate_heston(self, S0, v0, r, kappa, theta, xi, rho, T, n_steps=252, n_paths=2000):
+        try:
+            S, v = StochasticModels.heston_simulate(float(S0), float(v0), float(r), float(kappa), float(theta), float(xi), float(rho), float(T), int(n_steps), int(n_paths))
+            # return minimal summary and a small plot (first 3 paths)
+            fig, ax = plt.subplots()
+            for i in range(min(3, S.shape[0])):
+                ax.plot(S[i,:], label=f'path{i}')
+            ax.set_title("Heston sample paths (first few)")
+            ax.legend()
+            return "Heston simulation success", fig
         except Exception as e:
-            return f"噪声探索失败: {str(e)}", None
-    
-    def train_embedding(self, epochs=100):
-        """训练 Whitney 嵌入（autoencoder）"""
+            return f"Heston simulation failed: {e}", None
+
+    # Econometrics wrappers
+    def garch_fit(self):
         if self.current_data is None:
-            return "请先上传数据", None
+            return "请先上传数据"
+        numeric = self.current_data.select_dtypes(include=[np.number]).columns.tolist()
+        if not numeric:
+            return "数据无数值列"
+        series = self.current_data[numeric[0]].pct_change().dropna().values
+        if len(series) < 30:
+            return "样本过短，至少需要30个观测用于GARCH拟合"
         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
+            res = Econometrics.garch_11_fit(series)
+            return json.dumps({'method': res.get('method','mle'), 'params': res.get('params') if 'params' in res else 'omega/alpha/beta', 'cond_var_mean': float(np.mean(res.get('cond_var',[])) if res.get('cond_var') else np.nan)}, indent=2)
         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):
-        """模拟梯度动力学路径"""
+            return f"GARCH拟合失败: {e}"
+
+    def johansen(self):
+        if self.current_data is None:
+            return "请先上传数据"
+        data = self.current_data.select_dtypes(include=[np.number]).dropna().values
+        if data.shape[0] < 50 or data.shape[1] < 2:
+            return "数据不足以做 Johansen 协整检验（至少 50 行，2 列）"
         try:
-            path = self.trainer.simulate_gradient_flow([start_vix2, start_rv], T=T, dt=dt)
-            return f"模拟完成，路径长度 {len(path)}", path
+            res = Econometrics.johansen_test(data)
+            if res is None:
+                return "Johansen 不可用（statsmodels 未安装或出错）"
+            return json.dumps({'eig_top5': res['eig'][:5], 'lr1_top5': res['lr1'][:5]}, indent=2)
         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 "请先上传并分析数据"
-        
+            return f"Johansen 失败: {e}"
+
+    # Portfolio & Risk
+    def compute_gmv(self):
+        if self.current_data is None:
+            return "请先上传数据"
+        df = self.current_data.select_dtypes(include=[np.number]).dropna()
+        if df.shape[0] < 10 or df.shape[1] < 1:
+            return "数据不足"
+        returns = df.pct_change().dropna().values
+        w = PortfolioOptimization.gmv_weights(returns)
+        return f"GMV weights (len {len(w)}): {np.round(w,4).tolist()}"
+
+    def mean_var_opt(self, target_return: Optional[float]=None):
+        if self.current_data is None:
+            return "请先上传数据"
+        df = self.current_data.select_dtypes(include=[np.number]).dropna()
+        returns = df.pct_change().dropna().values
         try:
-            # 准备市场数据���要
-            market_summary = ""
-            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(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, intraday=intraday, generate_pseudocode=generate_pseudocode)
-            
-            return response
-            
+            w = PortfolioOptimization.mean_variance_opt(returns, target_return=float(target_return) if target_return is not None else None)
+            return f"Optimized weights (len {len(w)}): {np.round(w,4).tolist()}"
         except Exception as e:
-            return f"策略生成失败: {str(e)}"
-
-# 创建Gradio界面
-def create_interface():
-    platform = TradingPlatform()
-    
-    with gr.Blocks(title="港股智能分析平台", theme=gr.themes.Soft()) as interface:
-        gr.Markdown("""
-        # 🚀 港股智能分析平台 - 数学原理驱动（扩展版）
-        
-        新增功能：
-        - 噪声分离 / VRP 残差分析
-        - 基于 Whitney 嵌入的 autoencoder 与截面学习
-        - 梯度动力学（将梯度下降视作连续演化）模拟
-        - LLM 支持日内策略与伪代码输出（集成/回退模板）
-        """)
-        
+            return f"Mean-Variance optimization failed: {e}"
+
+    # ML
+    def lasso_select(self):
+        if self.current_data is None:
+            return "请先上传数据"
+        df = self.current_data.select_dtypes(include=[np.number]).dropna()
+        if df.shape[1] < 2 or df.shape[0] < 30:
+            return "数据不足以做 LASSO"
+        y = df.iloc[:,0].pct_change().dropna().values
+        X = df.iloc[:,1:].pct_change().dropna().values
+        # align lengths
+        minlen = min(len(y), len(X))
+        if minlen <= 10:
+            return "数据对齐后样本太短"
+        y = y[-minlen:]
+        X = X[-minlen:]
+        res = MLForFinance.lasso_select(X, y)
+        if res is None:
+            return "LASSO 失败"
+        return f"Selected indices: {res['selected']}, alpha: {res['alpha']:.6g}"
+
+    # LLM strategy (structured)
+    def generate_strategy(self, user_prompt: str, intraday: bool=True, model_name: Optional[str]=None) -> str:
+        if self.current_data is None:
+            return json.dumps({'error': '请先上传数据'}, ensure_ascii=False)
+        # Build analysis dict
+        analysis = {}
+        if self.analysis_results.get('noise'):
+            analysis['noise'] = self.analysis_results['noise']
+        # GARCH cond var mean if available
+        try:
+            g = self.garch_fit()
+            analysis['garch_summary'] = json.loads(g) if g and g.startswith("{") else g
+        except Exception:
+            analysis['garch_summary'] = "GARCH无法解析"
+        # market snapshot: last 50 rows numeric describe
+        do_numeric = self.current_data.select_dtypes(include=[np.number]).tail(50).describe().to_string()
+        requirements = {'intraday': intraday, 'pseudocode': True, 'user_prompt': user_prompt}
+        if model_name:
+            self.llm = LLMInterface(model_name=model_name)
+        result = self.llm.generate_structured_strategy(analysis, do_numeric, requirements)
+        # return pretty JSON
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+# ---------------------
+# Gradio UI
+# ---------------------
+def create_ui():
+    platform = QuantPlatform()
+    with gr.Blocks(title="Quant Upgraded Platform") as demo:
+        gr.Markdown("# Quant Upgraded Platform — 高精度/高性能 + 精细化 LLM 策略")
         with gr.Tabs():
-            # 数据上传标签
-            with gr.TabItem("📁 数据上传与分析"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        file_input = gr.File(
-                            label="上传数据文件 (CSV/Excel)",
-                            file_types=[".csv", ".xlsx", ".xls"]
-                        )
-                        upload_btn = gr.Button("分析数据", variant="primary")
-                    
-                    with gr.Column(scale=2):
-                        data_summary = gr.Textbox(
-                            label="数据摘要",
-                            lines=6,
-                            interactive=False
-                        )
-                        analysis_result = gr.Textbox(
-                            label="数学分析结果",
-                            lines=6,
-                            interactive=False
-                        )
-                        status_text = gr.Textbox(
-                            label="状态",
-                            interactive=False
-                        )
-                
-                upload_btn.click(
-                    platform.process_upload,
-                    inputs=[file_input],
-                    outputs=[data_summary, analysis_result, status_text]
-                )
-            
-            # 噪声探索与嵌入训练
-            with gr.TabItem("🔍 噪声探索 & 嵌入"):
+            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模型训练"):
+                    file_input = gr.File(label="上传 CSV / Excel")
+                    upload_btn = gr.Button("上传并分析")
+                summary = gr.Textbox(label="数据摘要", lines=2)
+                noise = gr.Textbox(label="噪声探索摘要", lines=2)
+                garch = gr.Textbox(label="GARCH 摘要", lines=2)
+                upload_btn.click(platform.upload_and_analyze, inputs=[file_input], outputs=[summary, noise, garch])
+
+            with gr.TabItem("📊 Pricing / PDE / MC"):
                 with gr.Row():
-                    with gr.Column():
-                        epochs_slider = gr.Slider(
-                            minimum=50,
-                            maximum=500,
-                            value=100,
-                            step=50,
-                            label="训练轮数"
-                        )
-                        train_btn = gr.Button("开始训练", variant="primary")
-                        training_result = gr.Textbox(
-                            label="训练结果",
-                            lines=8,
-                            interactive=False
-                        )
-                    
-                    with gr.Column():
-                        loss_plot = gr.Plot(label="训练损失曲线")
-                
-                train_btn.click(
-                    platform.train_model,
-                    inputs=[epochs_slider],
-                    outputs=[training_result, loss_plot]
-                )
-            
-            # 交易策略标签
-            with gr.TabItem("💹 智能交易策略"):
-                gr.Markdown("""
-                ### 基于数学原理的交易策略生成（扩展）
-                
-                系统将结合：
-                - 纤维丛投影的市场状态
-                - 因果VAR的动态关系
-                - 梯度动力学的演化模拟
-                - LLM智能推理（可输出伪代码）
-                """)
-                
+                    S = gr.Number(value=100.0, label="Spot S")
+                    K = gr.Number(value=100.0, label="Strike K")
+                    r = gr.Number(value=0.01, label="r")
+                    q = gr.Number(value=0.0, label="q")
+                    sigma = gr.Number(value=0.2, label="sigma")
+                    T = gr.Number(value=0.5, label="T (yrs)")
                 with gr.Row():
-                    with gr.Column():
-                        # LLM模型选择
-                        model_dropdown = gr.Dropdown(
-                            choices=list(AVAILABLE_MODELS.keys()),
-                            value="Qwen/Qwen2.5-1.5B-Instruct",
-                            label="选择LLM模型"
-                        )
-                        
-                        user_input = gr.Textbox(
-                            label="交易问题",
-                            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=20,
-                            interactive=False
-                        )
-                
-                def update_llm_model(model_name):
-                    platform.llm = LLMInterface(model_name)
-                    return f"已切换到 {AVAILABLE_MODELS.get(model_name, model_name)}"
-                
-                model_dropdown.change(
-                    update_llm_model,
-                    inputs=[model_dropdown],
-                    outputs=[gr.Textbox(visible=False)]
-                )
-                
-                strategy_btn.click(
-                    platform.get_trading_strategy,
-                    inputs=[user_input, intraday_check, pseudocode_check, model_dropdown],
-                    outputs=[strategy_output]
-                )
-            
-            # 梯度动力学模拟
-            with gr.TabItem("⚙️ 梯度动力学模拟"):
+                    bs_cn_btn = gr.Button("Crank–Nicolson BS PDE 价格")
+                    bs_cn_out = gr.Textbox(label="PDE Price", lines=1)
+                    bs_cn_btn.click(platform.price_bs_cn, inputs=[S,K,r,q,sigma,T, gr.Number(value=3.0), gr.Slider(100,800,value=400), gr.Slider(100,800,value=400), gr.Dropdown(['call','put'], value='call')], outputs=[bs_cn_out])
                 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(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. 运行噪声探索以获得 VRP/残差统计
-        3. 训练嵌入 / XPINNs 并模拟梯度动力学
-        4. 使用 LLM 生成日内/量化策略并选择是否输出伪代码
-        
-        **注意**: 本系统仅供研究参考，不构成投资建议。
-        """)
-    
-    return interface
-
-# 主函数
+                    mc_btn = gr.Button("Monte Carlo (Antithetic + Control Var)")
+                    mc_out = gr.Textbox(label="MC Price (CV)", lines=1)
+                    mc_btn.click(platform.price_bs_mc, inputs=[S,K,r,q,sigma,T, gr.Dropdown(['call','put'], value='call'), gr.Number(value=config.mc_default_paths), gr.Checkbox(value=True, label="Antithetic")], outputs=[mc_out])
+
+            with gr.TabItem("🔢 Econometrics"):
+                garch_btn = gr.Button("GARCH(1,1) 拟合")
+                garch_out = gr.Textbox(label="GARCH 结果", lines=8)
+                garch_btn.click(platform.garch_fit, inputs=None, outputs=[garch_out])
+
+                joh_btn = gr.Button("Johansen 协整检验")
+                joh_out = gr.Textbox(label="Johansen 结果", lines=6)
+                joh_btn.click(platform.johansen, inputs=None, outputs=[joh_out])
+
+            with gr.TabItem("📈 Portfolio & Risk"):
+                gmv_btn = gr.Button("计算 GMV 权重")
+                gmv_out = gr.Textbox(label="GMV 权重", lines=3)
+                gmv_btn.click(platform.compute_gmv, inputs=None, outputs=[gmv_out])
+
+                mv_btn = gr.Button("均值-方差 优化 (可选目标收益)")
+                target = gr.Number(label="目标收益 (可空)", value=None)
+                mv_out = gr.Textbox(label="MV 结果", lines=3)
+                mv_btn.click(platform.mean_var_opt, inputs=[target], outputs=[mv_out])
+
+            with gr.TabItem("🤖 LLM 策略生成 (结构化)"):
+                user_q = gr.Textbox(label="你的问题（策略 / 日内 / 回测）", lines=3, value="基于当前数据，给出日内量化策略并生成伪代码")
+                intraday = gr.Checkbox(label="日内策略", value=True)
+                model_sel = gr.Dropdown(label="LLM 模型 (若无Token或模型不可用会回退)", choices=[config.hf_default_model], value=config.hf_default_model)
+                strat_out = gr.Textbox(label="结构化策略输出 (JSON)", lines=20)
+                strat_btn = gr.Button("生成策略")
+                strat_btn.click(platform.generate_strategy, inputs=[user_q, intraday, model_sel], outputs=[strat_out])
+
+            with gr.TabItem("🔬 Dynamics & Geometry (原有)"):
+                noise_btn = gr.Button("运行噪声探索")
+                noise_text = gr.Textbox(label="Noise summary", lines=3)
+                def run_noise():
+                    if platform.current_data is None:
+                        return "请先上传数据"
+                    res = platform.noise.explore(platform.current_data)
+                    return f"VRP mean {res['vrp_mean']:.6f}, resid ac1 {res['resid_stats']['ac1']:.4f}"
+                noise_btn.click(run_noise, inputs=None, outputs=[noise_text])
+
+                sim_vix2 = gr.Number(value=1.0, label="start VIX^2")
+                sim_rv = gr.Number(value=0.8, label="start RV")
+                T_sim = gr.Number(value=1.0, label="T")
+                dt_sim = gr.Number(value=0.01, label="dt")
+                sim_btn = gr.Button("模拟梯度动力学")
+                sim_out = gr.Plot(label="Dynamics path")
+                def run_sim(vix2, rv, T, dt):
+                    # lightweight simulate using gradient dynamics (reuse earlier pattern)
+                    gradient = GradientDynamicsLite()
+                    path = gradient.simulate_flow([vix2, rv], T=float(T), dt=float(dt))
+                    fig, ax = plt.subplots()
+                    ax.plot(path[:,0], label='VIX^2')
+                    ax.plot(path[:,1], label='RV')
+                    ax.legend()
+                    ax.set_title("Gradient dynamics (VIX^2 & RV)")
+                    return fig
+                sim_btn.click(run_sim, inputs=[sim_vix2, sim_rv, T_sim, dt_sim], outputs=[sim_out])
+
+        gr.Markdown("注：本系统为研究用途，不构成投资建议。部分功能依赖外部库（statsmodels, arch, cvxpy）。")
+
+    return demo
+
+# ---------------------
+# Small helper: GradientDynamicsLite (used only in UI simulation)
+# ---------------------
+class GradientDynamicsLite:
+    def __init__(self, eta=0.5, sigma=0.02):
+        self.eta = eta
+        self.sigma = sigma
+
+    def U_vrp(self, b):
+        vix2 = b[...,0]
+        rv = b[...,1]
+        vrp = vix2 - rv
+        return 0.5 * vrp**2
+
+    def grad_U(self, b):
+        # analytic gradient for U = 0.5*(vix2 - rv)^2
+        vix2 = b[0]
+        rv = b[1]
+        # dU/dvix2 = (vix2 - rv); dU/drv = -(vix2 - rv)
+        g = np.array([vix2 - rv, -(vix2 - rv)], dtype=float)
+        return g
+
+    def simulate_flow(self, b0, T=1.0, dt=0.01, seed=None):
+        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):
+            bcur = path[i]
+            grad = self.grad_U(bcur)
+            db_det = - self.eta * grad
+            db_stoch = self.sigma * np.sqrt(dt) * np.random.randn(2)
+            path[i+1] = bcur + db_det * dt + db_stoch
+        return path
+
+# ---------------------
+# Entrypoint
+# ---------------------
 if __name__ == "__main__":
-    logger.info("启动港股智能分析平台（扩展版）...")
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    app = create_ui()
+    # Launch locally
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)