Update app.py

app.py

@@ -6,7 +6,6 @@ import numpy as np
 import plotly.graph_objs as go
 from sklearn.pipeline import make_pipeline
 from sklearn.preprocessing import RobustScaler
-from sklearn.model_selection import TimeSeriesSplit
 from lightgbm import LGBMRegressor
 from loguru import logger
 import threading
@@ -19,21 +18,23 @@ from ta.volume import OnBalanceVolumeIndicator
 # 日志配置
 logger.add("app.log", rotation="1 MB", level="DEBUG", backtrace=True, diagnose=True)
 
-def enhanced_feature_engineering(df):
-    """安全可靠的特征工程函数"""
+def safe_feature_engineering(df):
+    """安全稳定的特征工程函数"""
     try:
-        # 基础数据准备
-        df = df[['Open', 'High', 'Low', 'Close', 'Volume']].copy()
-        df = df.astype({
-            'Open': float, 'High': float, 'Low': float,
-            'Close': float, 'Volume': float
-        })
+        # 基础数据校验
+        required_cols = ['Open', 'High', 'Low', 'Close', 'Volume']
+        if not all(col in df.columns for col in required_cols):
+            raise ValueError("缺失必要数据列")
+        
+        # 数据类型强制转换
+        df = df[required_cols].copy()
+        df = df.astype({col: float for col in required_cols})
         
         # 基础特征
         df['Returns'] = df['Close'].pct_change()
         df['Volatility'] = df['Returns'].rolling(5).std()
         
-        # 技术指标
+        # 技术指标计算
         df['RSI_14'] = RSIIndicator(df['Close'], window=14).rsi()
         df['EMA_12'] = EMAIndicator(df['Close'], window=12).ema_indicator()
         df['EMA_26'] = EMAIndicator(df['Close'], window=26).ema_indicator()
@@ -42,48 +43,51 @@ def enhanced_feature_engineering(df):
             volume=df['Volume']
         ).on_balance_volume()
         
-        # 清理异常值
+        # 清理数据
         df.replace([np.inf, -np.inf], np.nan, inplace=True)
         df.dropna(inplace=True)
         
         return df[['Close', 'Returns', 'Volatility', 'RSI_14', 'EMA_12', 'EMA_26', 'OBV']]
     
     except Exception as e:
-        logger.error(f"特征工程失败: {traceback.format_exc()}")
+        logger.error(f"特征工程异常: {str(e)}")
         raise
 
-def robust_training(ticker):
-    """安全可靠的训练函数"""
+def safe_training(ticker):
+    """稳定可靠的训练函数"""
     start_time = time.time()
     try:
         # 数据获取
-        logger.info(f"开始处理股票代码: {ticker}")
+        logger.info(f"正在获取 [{ticker}] 数据...")
         data = yf.download(
             ticker,
             period="1y",
             interval="1d",
-            prepost=False,
-            threads=False,
             progress=False,
             auto_adjust=True
         )
         
-        # 数据验证
-        if data.empty or len(data) < 30:
-            raise ValueError("有效数据不足（最少需要30个交易日数据）")
+        # 数据有效性验证
+        if data.empty:
+            raise ValueError("获取数据为空")
+        if len(data) < 30:
+            raise ValueError("数据不足30天")
         if 'Close' not in data.columns:
-            raise ValueError("无效的股票数据格式")
-        if data['Close'].isnull().sum() > 5:
-            raise ValueError("存在过多缺失值")
+            raise ValueError("缺少Close列")
+        
+        # 显式处理空值
+        nan_count = data['Close'].isna().sum()
+        if nan_count > 5:
+            raise ValueError(f"检测到{n}个空值")
         
         # 特征处理
-        processed_data = enhanced_feature_engineering(data)
+        processed_data = safe_feature_engineering(data)
         
         # 准备训练数据
         X = processed_data.drop(columns=['Close'])
         y = processed_data['Close']
         
-        # 模型配置
+        # 初始化模型
         model = make_pipeline(
             RobustScaler(),
             LGBMRegressor(
@@ -96,14 +100,9 @@ def robust_training(ticker):
             )
         )
         
-        # 训练流程
-        tscv = TimeSeriesSplit(n_splits=2)
-        for train_index, _ in tscv.split(X):
-            if (time.time() - start_time) > 25:
-                break
-            X_train = X.iloc[train_index].values
-            y_train = y.iloc[train_index].values
-            model.fit(X_train, y_train)
+        # 快速训练
+        logger.info("开始模型训练...")
+        model.fit(X.values[-200:], y.values[-200:])  # 使用最近200个数据点
         
         # 生成预测
         current_features = X.iloc[-1:].copy()
@@ -121,26 +120,26 @@ def robust_training(ticker):
             current_features['Volatility'] = current_features['Volatility'].values[0]
         
         return {
-            'historical_data': data,
+            'historical': data,
             'predictions': pd.Series(predictions, index=future_dates),
-            'training_time': time.time() - start_time
+            'time_used': time.time() - start_time
         }
     
     except Exception as e:
-        logger.error(f"训练���败: {str(e)}\n{traceback.format_exc()}")
+        logger.error(f"训练异常: {str(e)}")
         return None
 
-def create_visualization(result):
-    """创建可视化图表（修复括号问题）"""
+def create_safe_plot(result):
+    """安全绘图函数"""
     fig = go.Figure()
     
     # 历史价格
     fig.add_trace(go.Scatter(
-        x=result['historical_data'].index,
-        y=result['historical_data']['Close'],
+        x=result['historical'].index,
+        y=result['historical']['Close'],
         name='历史价格',
         line=dict(color='#1f77b4', width=2)
-    ))  # 正确闭合括号
+    ))
     
     # 预测价格
     fig.add_trace(go.Scatter(
@@ -148,103 +147,88 @@ def create_visualization(result):
         y=result['predictions'].values,
         name='AI预测',
         line=dict(color='#ff7f0e', width=2, dash='dot')
-    ))  # 正确闭合括号
+    ))
     
     fig.update_layout(
-        title="股票价格预测结果",
+        title="股票价格预测",
         xaxis_title="日期",
         yaxis_title="价格 (USD)",
         hovermode="x unified",
-        template="plotly_white",
-        legend=dict(
-            orientation="h",
-            yanchor="bottom",
-            y=1.02,
-            xanchor="right",
-            x=1
-        )
+        template="plotly_white"
     )
     return fig
 
-def prediction_workflow(ticker):
-    """完整的预测工作流"""
+def safe_predict_flow(ticker):
+    """安全预测流程"""
     try:
         start_time = time.time()
-        yield "⌛ 正在快速分析市场数据（预计30秒内完成）...", None, None
+        yield "⌛ 正在快速分析中（30秒内完成）...", None, None
         
         result = None
-        error_msg = ""
         
-        # 后台训练线程
-        def training_job():
+        # 后台训练
+        def train_task():
             nonlocal result
-            result = robust_training(ticker)
+            result = safe_training(ticker)
         
-        thread = threading.Thread(target=training_job)
+        thread = threading.Thread(target=train_task)
         thread.start()
         
-        # 等待处理
+        # 等待结果
         while thread.is_alive():
-            if time.time() - start_time > 30:
-                error_msg = "⏰ 系统响应超时，请稍后重试"
+            if time.time() - start_time > 28:  # 预留2秒缓冲
+                yield "⏳ 系统正在处理，请稍候...", None, None
                 break
             time.sleep(0.1)
         
-        if error_msg:
-            yield error_msg, None, None
+        if not result:
+            yield "⚠️ 分析失败，请检查股票代码", None, None
             return
         
-        if not result or result['predictions'].empty:
-            yield "⚠️ 无法生成预测，请检查股票代码有效性", None, None
-            return
-        
-        # 构建输出信息
-        training_time = f"{result['training_time']:.1f}秒"
-        latest_pred = f"{result['predictions'].iloc[-1]:.2f}"
-        info_content = f"""
-        ## 分析结果
-        ✅ 成功完成分析（耗时：{training_time}）
-        📅 最新预测日期：{result['predictions'].index[-1].strftime('%Y-%m-%d')}
-        💵 预测收盘价：{latest_pred} USD
+        # 构建结果
+        info = f"""
+        ✅ 分析成功（耗时：{result['time_used']:.1f}秒）
+        📅 最新预测：{result['predictions'].index[-1].strftime('%Y-%m-%d')}
+        💵 预测价格：{result['predictions'].iloc[-1]:.2f} USD
         """
         
-        # 风险提示
-        risk_content = """
+        risk = """
         **风险提示**
-        1. 本预测基于历史数据建模，不构成投资建议
-        2. 实际价格可能受市场突发事件影响
-        3. 预测准确率随预测时间跨度增加而降低
-        4. 请结合其他信息进行综合判断
+        1. 本预测仅供参考，不构成投资建议
+        2. 实际价格可能受市场波动影响
+        3. 预测误差可能随时间增加
         """
         
-        yield info_content, create_visualization(result), risk_content
+        yield info, create_safe_plot(result), risk
     
     except Exception as e:
-        logger.critical(f"系统级错误: {traceback.format_exc()}")
-        yield "⚠️ 发生意外错误，请联系技术支持", None, None
+        logger.critical(f"系统异常: {traceback.format_exc()}")
+        yield "⚠️ 系统繁忙，请稍后再试", None, None
 
-# 创建Gradio界面
-with gr.Blocks(theme=gr.themes.Soft(), title="智能股票预测系统") as demo:
-    gr.Markdown("# 📈 智能股票预测系统")
+# 创建界面
+with gr.Blocks(title="稳定版股票预测", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 📊 股票价格预测系统")
     
     with gr.Row():
-        with gr.Column(scale=2):
-            ticker_input = gr.Textbox(
-                label="输入股票代码",
-                placeholder="例如：AAPL (苹果), 00700.HK (腾讯)",
+        input_col = gr.Column(scale=2)
+        with input_col:
+            stock_input = gr.Textbox(
+                label="股票代码",
+                placeholder="输入代码 (如: AAPL, 00700.HK)",
                 max_lines=1
             )
             submit_btn = gr.Button("开始分析", variant="primary")
         
-        with gr.Column(scale=3):
-            status_display = gr.Markdown("## 当前状态")
-            plot_display = gr.Plot(label="价格走势")
-            risk_display = gr.Markdown()
-
+        output_col = gr.Column(scale=3)
+        with output_col:
+            status = gr.Markdown("## 状态")
+            plot = gr.Plot(label="价格走势")
+            risk = gr.Markdown()
+    
     submit_btn.click(
-        prediction_workflow,
-        inputs=ticker_input,
-        outputs=[status_display, plot_display, risk_display]
+        safe_predict_flow,
+        inputs=stock_input,
+        outputs=[status, plot, risk]
     )
 
 if __name__ == "__main__":
@@ -252,11 +236,10 @@ if __name__ == "__main__":
     import warnings
     warnings.filterwarnings("ignore")
     
-    # 正确启用队列配置
-    demo.queue()  # 先配置队列
-    
-    # 正确启动参数
-    demo.launch(
+    # 稳定启动
+    app.queue(concurrency_count=2)
+    app.launch(
         server_port=7860,
-        show_error=True
+        show_error=True,
+        ssr_mode=False  # 禁用实验性功能
     )