Update app.py

app.py

@@ -16,20 +16,25 @@ from ta.momentum import RSIIndicator
 from ta.trend import EMAIndicator
 from ta.volume import OnBalanceVolumeIndicator
 
-# 配置日志
+# 日志配置
 logger.add("app.log", rotation="1 MB", level="DEBUG", backtrace=True, diagnose=True)
 
 def enhanced_feature_engineering(df):
-    """优化的特征工程函数"""
+    """安全可靠的特征工程函数"""
     try:
-        df = df[['Open', 'High', 'Low', 'Close', 'Volume']].copy().astype(float)
+        # 基础数据准备
+        df = df[['Open', 'High', 'Low', 'Close', 'Volume']].copy()
+        df = df.astype({
+            'Open': float, 'High': float, 'Low': float,
+            'Close': float, 'Volume': float
+        })
         
         # 基础特征
         df['Returns'] = df['Close'].pct_change()
         df['Volatility'] = df['Returns'].rolling(5).std()
         
-        # 技术指标
-        df['RSI'] = RSIIndicator(df['Close'], window=14).rsi()
+        # 技术指标（逐个添加避免冲突）
+        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()
         df['OBV'] = OnBalanceVolumeIndicator(
@@ -37,24 +42,24 @@ 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)
         
-        # 选择特征
-        selected_features = ['Close', 'Returns', 'Volatility', 'RSI', 'EMA_12', 'EMA_26', 'OBV']
-        return df[selected_features]
+        # 特征选择
+        final_features = ['Close', 'Returns', 'Volatility', 'RSI_14', 'EMA_12', 'EMA_26', 'OBV']
+        return df[final_features]
     
     except Exception as e:
-        logger.error(f"特征工程失败: {str(e)}")
+        logger.error(f"特征工程失败: {traceback.format_exc()}")
         raise
 
 def robust_training(ticker):
-    """快速训练函数（30秒超时保证）"""
+    """安全可靠的训练函数"""
     start_time = time.time()
     try:
-        # 获取数据
-        logger.info(f"正在获取 {ticker} 数据")
+        # 数据获取
+        logger.info(f"开始处理股票代码: {ticker}")
         data = yf.download(
             ticker,
             period="1y",
@@ -66,20 +71,21 @@ def robust_training(ticker):
         )
         
         # 数据验证
-        if data.empty or len(data) < 30 or 'Close' not in data.columns:
-            raise ValueError("无效或数据不足")
-        if data['Close'].isnull().sum() > 5:
-            raise ValueError("数据存在过多缺失值")
+        if data.empty or len(data) < 30:
+            raise ValueError("有效数据不足（最少需要30个交易日数据）")
+        if 'Close' not in data.columns:
+            raise ValueError("无效的股票数据格式")
+        if data['Close'].isnull().sum() > 5:  # 明确数值比较
+            raise ValueError("存在过多缺失值")
         
         # 特征处理
-        logger.debug("处理特征中...")
-        data = enhanced_feature_engineering(data)
+        processed_data = enhanced_feature_engineering(data)
         
         # 准备训练数据
-        X = data.drop(columns=['Close'])
-        y = data['Close']
+        X = processed_data.drop(columns=['Close'])
+        y = processed_data['Close']
         
-        # 初始化模型
+        # 模型配置
         model = make_pipeline(
             RobustScaler(),
             LGBMRegressor(
@@ -87,91 +93,102 @@ def robust_training(ticker):
                 max_depth=4,
                 learning_rate=0.15,
                 verbosity=-1,
-                force_row_wise=True
+                force_row_wise=True,
+                random_state=42
             )
         )
         
-        # 快速训练
-        logger.info("开始快速训练")
+        # 训练流程
         tscv = TimeSeriesSplit(n_splits=2)
         for train_index, _ in tscv.split(X):
-            if (time.time() - start_time) > 25:
+            if (time.time() - start_time) > 25:  # 保留5秒预测时间
                 break
-            model.fit(X.iloc[train_index], y.iloc[train_index])
+            X_train = X.iloc[train_index].values  # 转换为numpy数组
+            y_train = y.iloc[train_index].values
+            model.fit(X_train, y_train)
         
         # 生成预测
-        logger.debug("生成预测结果")
-        future_dates = pd.date_range(data.index[-1], periods=8)[1:]
         current_features = X.iloc[-1:].copy()
         predictions = []
+        future_dates = pd.date_range(data.index[-1], periods=8)[1:]
         
         for _ in range(7):
-            pred = model.predict(current_features)[0]
+            current_close = current_features['Close'].values[0]
+            pred = model.predict(current_features.values)[0]
             predictions.append(pred)
-            current_features['Returns'] = (pred - current_features['Close']) / current_features['Close']
+            
+            # 更新特征（标量运算）
+            current_features['Returns'] = (pred - current_close) / current_close
             current_features['Close'] = pred
+            current_features['Volatility'] = current_features['Volatility'].values[0]
         
         return {
-            'data': data,
+            'historical_data': data,
             'predictions': pd.Series(predictions, index=future_dates),
             'training_time': time.time() - start_time
         }
     
     except Exception as e:
-        logger.error(f"训练失败: {str(e)}")
+        logger.error(f"训练失败: {str(e)}\n{traceback.format_exc()}")
         return None
 
-def create_prediction_plot(result):
-    """创建交互式图表"""
+def create_visualization(result):
+    """创建可视化图表"""
     fig = go.Figure()
     
     # 历史价格
     fig.add_trace(go.Scatter(
-        x=result['data'].index,
-        y=result['data']['Close'],
+        x=result['historical_data'].index,
+        y=result['historical_data']['Close'],
         name='历史价格',
-        line=dict(color='#1f77b4')
-    ))
+        line=dict(color='#1f77b4', width=2)
+    )
     
     # 预测价格
     fig.add_trace(go.Scatter(
         x=result['predictions'].index,
         y=result['predictions'].values,
         name='AI预测',
-        line=dict(color='#ff7f0e', dash='dot')
-    ))
+        line=dict(color='#ff7f0e', width=2, dash='dot')
+    )
     
     fig.update_layout(
-        title="股票价格预测",
+        title=f"股票价格预测结果",
         xaxis_title="日期",
         yaxis_title="价格 (USD)",
         hovermode="x unified",
         template="plotly_white",
-        margin=dict(t=40, b=20)
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
     )
     return fig
 
-def predict_stock(ticker):
-    """处理预测流程"""
+def prediction_workflow(ticker):
+    """完整的预测工作流"""
     try:
         start_time = time.time()
-        yield "⌛ 正在分析市场数据（30秒内完成）...", None, None
+        yield "⌛ 正在快速分析市场数据（预计30秒内完成）...", None, None
         
         result = None
         error_msg = ""
         
         # 后台训练线程
-        def training_task():
+        def training_job():
             nonlocal result
             result = robust_training(ticker)
         
-        thread = threading.Thread(target=training_task)
+        thread = threading.Thread(target=training_job)
         thread.start()
         
-        # 等待线程完成
+        # 等待处理
         while thread.is_alive():
             if time.time() - start_time > 30:
-                error_msg = "⏰ 响应超时，请稍后重试"
+                error_msg = "⏰ 系统响应超时，请稍后重试"
                 break
             time.sleep(0.1)
         
@@ -180,56 +197,65 @@ def predict_stock(ticker):
             return
         
         if not result or result['predictions'].empty:
-            yield "⚠️ 无法生成预测，请检查股票代码", None, None
+            yield "⚠️ 无法生成预测，请检查股票代码有效性", None, None
             return
         
         # 构建输出信息
-        time_used = f"{result['training_time']:.1f}秒"
-        latest_pred = f"{result['predictions'].iloc[-1]:.2f} USD"
-        info_box = f"""
-        ✅ 分析完成（耗时：{time_used}）
+        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}
+        💵 预测收盘价：{latest_pred} USD
         """
         
         # 风险提示
-        risk_warning = """
+        risk_content = """
         **风险提示**
-        1. 本预测基于历史数据，不构成投资建议
-        2. 实际价格受市场因素影响可能大幅波动
-        3. 预测误差可能随预测时间增加而扩大
-        4. 过去表现不代表未来结果
+        1. 本预测基于历史数据建模，不构成投资建议
+        2. 实际价格可能受市场突发事件影响
+        3. 预测准确率随预测时间跨度增加而降低
+        4. 请结合其他信息进行综合判断
         """
         
-        yield info_box, create_prediction_plot(result), risk_warning
+        yield info_content, create_visualization(result), risk_content
     
     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:
+with gr.Blocks(theme=gr.themes.Soft(), title="智能股票预测系统") as demo:
     gr.Markdown("# 📈 智能股票预测系统")
     
     with gr.Row():
         with gr.Column(scale=2):
             ticker_input = gr.Textbox(
-                label="股票代码",
-                placeholder="输入股票代码 (如：AAPL, 00700.HK)",
+                label="输入股票代码",
+                placeholder="例如：AAPL (苹果), 00700.HK (腾讯)",
                 max_lines=1
             )
-            submit_btn = gr.Button("开始预测", variant="primary")
+            submit_btn = gr.Button("开始分析", variant="primary")
         
         with gr.Column(scale=3):
-            status_output = gr.Markdown("## 分析状态")
-            plot_output = gr.Plot(label="价格走势")
-            risk_output = gr.Markdown()
+            status_display = gr.Markdown("## 当前状态")
+            plot_display = gr.Plot(label="价格走势")
+            risk_display = gr.Markdown()
     
     submit_btn.click(
-        predict_stock,
+        prediction_workflow,
         inputs=ticker_input,
-        outputs=[status_output, plot_output, risk_output]
+        outputs=[status_display, plot_display, risk_display]
     )
 
 if __name__ == "__main__":
-    demo.launch(server_port=7860)
+    # 启动配置
+    import warnings
+    warnings.filterwarnings("ignore")
+    
+    demo.launch(
+        server_port=7860,
+        show_error=True,
+        enable_queue=True
+    )