app.py

from flask import Flask, render_template, request, jsonify
import yfinance as yf
import pandas as pd
import numpy as np
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from datetime import datetime, timedelta
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVR
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.decomposition import PCA
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import MinMaxScaler
from statsmodels.tsa.arima.model import ARIMA
from arch import arch_model
import xgboost as xgb
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Conv1D, MaxPooling1D, Flatten, SimpleRNN, GRU
import json
import os
from datetime import datetime, timedelta
from sklearn.cluster import KMeans
import logging
# 设置日志
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
app = Flask(__name__)

# 扩展股票代码选项，至少 50 条
STOCK_OPTIONS = [
    {'code': 'AAPL', 'name': 'Apple Inc.'},
    {'code': 'MSFT', 'name': 'Microsoft Corporation'},
    {'code': 'GOOGL', 'name': 'Alphabet Inc.'},
    {'code': 'AMZN', 'name': 'Amazon.com Inc.'},
    {'code': 'TSLA', 'name': 'Tesla Inc.'},
    {'code': 'NVDA', 'name': 'NVIDIA Corporation'},
    {'code': 'META', 'name': 'Meta Platforms Inc.'},
    {'code': 'JPM', 'name': 'JPMorgan Chase & Co.'},
    {'code': 'V', 'name': 'Visa Inc.'},
    {'code': 'MA', 'name': 'Mastercard Incorporated'},
    {'code': 'PYPL', 'name': 'PayPal Holdings Inc.'},
    {'code': 'INTC', 'name': 'Intel Corporation'},
    {'code': 'AMD', 'name': 'Advanced Micro Devices Inc.'},
    {'code': 'NFLX', 'name': 'Netflix Inc.'},
    {'code': 'DIS', 'name': 'Walt Disney Company'},
    {'code': 'BA', 'name': 'Boeing Co.'},
    {'code': 'GE', 'name': 'General Electric Company'},
    {'code': 'F', 'name': 'Ford Motor Company'},
    {'code': 'GM', 'name': 'General Motors Company'},
    {'code': 'CAT', 'name': 'Caterpillar Inc.'},
    {'code': 'XOM', 'name': 'Exxon Mobil Corporation'},
    {'code': 'CVX', 'name': 'Chevron Corporation'},
    {'code': 'PFE', 'name': 'Pfizer Inc.'},
    {'code': 'MRNA', 'name': 'Moderna Inc.'},
    {'code': 'JNJ', 'name': 'Johnson & Johnson'},
    {'code': 'WMT', 'name': 'Walmart Inc.'},
    {'code': 'TGT', 'name': 'Target Corporation'},
    {'code': 'COST', 'name': 'Costco Wholesale Corporation'},
    {'code': 'HD', 'name': 'Home Depot Inc.'},
    {'code': 'LOW', 'name': "Lowe's Companies Inc."},
    {'code': 'NKE', 'name': 'NIKE Inc.'},
    {'code': 'SBUX', 'name': 'Starbucks Corporation'},
    {'code': 'MCD', 'name': "McDonald's Corporation"},
    {'code': 'KO', 'name': 'Coca-Cola Company'},
    {'code': 'PEP', 'name': 'PepsiCo Inc.'},
    {'code': 'PG', 'name': 'Procter & Gamble Company'},
    {'code': 'UNH', 'name': 'UnitedHealth Group Incorporated'},
    {'code': 'CSCO', 'name': 'Cisco Systems Inc.'},
    {'code': 'ORCL', 'name': 'Oracle Corporation'},
    {'code': 'IBM', 'name': 'International Business Machines Corporation'},
    {'code': 'CRM', 'name': 'Salesforce Inc.'},
    {'code': 'ADBE', 'name': 'Adobe Inc.'},
    {'code': 'QCOM', 'name': 'Qualcomm Incorporated'},
    {'code': 'TXN', 'name': 'Texas Instruments Incorporated'},
    {'code': 'GS', 'name': 'Goldman Sachs Group Inc.'},
    {'code': 'MS', 'name': 'Morgan Stanley'},
    {'code': 'BAC', 'name': 'Bank of America Corporation'},
    {'code': 'WFC', 'name': 'Wells Fargo & Company'},
    {'code': 'C', 'name': 'Citigroup Inc.'},
    {'code': 'UBER', 'name': 'Uber Technologies Inc.'},
    {'code': 'LYFT', 'name': 'Lyft Inc.'}
]

def create_candlestick_chart(stock_data_dict):
    """创建K线图"""
    fig = make_subplots(rows=4, cols=1, shared_xaxes=True,
                        vertical_spacing=0.05,
                        subplot_titles=('K线图', '成交量', 'MACD', 'RSI'),
                        row_heights=[0.4, 0.2, 0.2, 0.2])

    stock_colors = {
        'kline_increasing': '#FF0000',
        'kline_decreasing': '#00FF00',
        'ma5': '#FFA500',
        'ma20': '#800080',
        'volume': '#808080',
        'macd': '#0000FF',
        'signal': '#FF4500',
        'macd_hist': '#A9A9A9',
        'rsi': '#FF00FF'
    }

    for stock_code, df in stock_data_dict.items():
        # 计算技术指标
        df['ma5'] = df['close'].rolling(window=5).mean()
        df['ma20'] = df['close'].rolling(window=20).mean()
        ema12 = df['close'].ewm(span=12, adjust=False).mean()
        ema26 = df['close'].ewm(span=26, adjust=False).mean()
        df['macd'] = ema12 - ema26
        df['signal'] = df['macd'].ewm(span=9, adjust=False).mean()
        df['macd_hist'] = df['macd'] - df['signal']
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        df['rsi'] = 100 - (100 / (1 + rs))

        fig.add_trace(go.Candlestick(
            x=df['trade_date'],
            open=df['open'],
            high=df['high'],
            low=df['low'],
            close=df['close'],
            name=f'{stock_code} K线',
            increasing_line_color=stock_colors['kline_increasing'],
            decreasing_line_color=stock_colors['kline_decreasing'],
            increasing_fillcolor=stock_colors['kline_increasing'],
            decreasing_fillcolor=stock_colors['kline_decreasing']
        ), row=1, col=1)

        fig.add_trace(go.Scatter(
            x=df['trade_date'], y=df['ma5'], name=f'{stock_code} MA5',
            line=dict(color=stock_colors['ma5'], dash='dash')
        ), row=1, col=1)
        fig.add_trace(go.Scatter(
            x=df['trade_date'], y=df['ma20'], name=f'{stock_code} MA20',
            line=dict(color=stock_colors['ma20'], dash='dot')
        ), row=1, col=1)

        fig.add_trace(go.Bar(
            x=df['trade_date'], y=df['vol'], name=f'{stock_code} 成交量',
            marker_color=stock_colors['volume'], opacity=0.5
        ), row=2, col=1)

        fig.add_trace(go.Scatter(
            x=df['trade_date'], y=df['macd'], name=f'{stock_code} MACD',
            line=dict(color=stock_colors['macd'])
        ), row=3, col=1)
        fig.add_trace(go.Scatter(
            x=df['trade_date'], y=df['signal'], name=f'{stock_code} Signal',
            line=dict(color=stock_colors['signal'], dash='dash')
        ), row=3, col=1)
        fig.add_trace(go.Bar(
            x=df['trade_date'], y=df['macd_hist'], name=f'{stock_code} MACD Hist',
            marker_color=stock_colors['macd_hist'], opacity=0.5
        ), row=3, col=1)

        fig.add_trace(go.Scatter(
            x=df['trade_date'], y=df['rsi'], name=f'{stock_code} RSI',
            line=dict(color=stock_colors['rsi'])
        ), row=4, col=1)

    fig.update_layout(
        title='多股对比分析',
        yaxis_title='价格',
        template='plotly_white',
        xaxis_rangeslider_visible=False,
        height=1200,
        showlegend=True,
        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
        updatemenus=[
            dict(
                type="buttons",
                direction="left",
                buttons=[
                    dict(label="导出PNG", method="relayout", args=[{"export": "png"}]),
                    dict(label="全屏", method="relayout", args=[{"fullscreen": True}])
                ],
                pad={"r": 10, "t": 10},
                showactive=True,
                x=0.11,
                xanchor="left",
                y=1.1,
                yanchor="top"
            )
        ],
        plot_bgcolor='#F5F5F5',
        paper_bgcolor='#FFFFFF'
    )
    fig.update_xaxes(title_text='日期', row=4, col=1, gridcolor='#E0E0E0')
    fig.update_yaxes(title_text='价格', row=1, col=1, gridcolor='#E0E0E0')
    fig.update_yaxes(title_text='成交量', row=2, col=1, gridcolor='#E0E0E0')
    fig.update_yaxes(title_text='MACD', row=3, col=1, gridcolor='#E0E0E0')
    fig.update_yaxes(title_text='RSI', row=4, col=1, range=[0, 100], gridcolor='#E0E0E0')

    return fig.to_json()


# 获取股票数据
def get_stock_data(stock_codes, start_date, end_date, look_back_days=None, multi_stock=False):
    try:
        if isinstance(stock_codes, str):
            stock_codes = [stock_codes]
        fetch_start = start_date
        if look_back_days:
            fetch_start = (pd.to_datetime(start_date) - timedelta(days=look_back_days)).strftime('%Y-%m-%d')
        data = {}
        for code in stock_codes:
            ticker = yf.Ticker(code)
            df = ticker.history(start=fetch_start, end=end_date)
            if df.empty:
                logger.warning(f"{code} 数据为空")
                continue
            df = df.reset_index()
            df = df.rename(columns={
                'Date': 'trade_date',
                'Open': 'open',
                'High': 'high',
                'Low': 'low',
                'Close': 'close',
                'Volume': 'vol'
            })
            df['trade_date'] = pd.to_datetime(df['trade_date'])

            # 计算 MA20 和 MA50
            df['MA20'] = df['close'].rolling(window=20).mean()
            df['MA50'] = df['close'].rolling(window=50).mean()

            # 检查数据是否足够计算 MA20 和 MA50
            if len(df) < 50:
                logger.warning(f"{code} 数据不足以计算 MA50 (需要至少 50 天数据)，当前数据量: {len(df)}")
                df['MA20'] = df['MA20'].fillna(method='ffill')  # 前向填充
                df['MA50'] = df['MA50'].fillna(method='ffill')
                if df['MA20'].isna().all() or df['MA50'].isna().all():
                    logger.warning(f"{code} 无法计算有效的 MA20 或 MA50，跳过")
                    continue

            data[code] = df
        if not data:
            logger.error("所有股票数据获取失败")
            return None
        if multi_stock:
            return data
        elif look_back_days:
            code = stock_codes[0]
            df_look_back = data[code][data[code]['trade_date'] < pd.to_datetime(start_date)]
            df_main = data[code][data[code]['trade_date'] >= pd.to_datetime(start_date)]
            return df_look_back, df_main
        else:
            code = stock_codes[0]
            return data[code]
    except Exception as e:
        logger.error(f"获取股票数据失败: {e}")
        return None

# 获取股票信息
def get_stock_info(stock_code):
    try:
        ticker = yf.Ticker(stock_code)
        info = ticker.info
        return {
            'code': stock_code,
            'name': info.get('longName', 'N/A'),
            'industry': info.get('industry', 'N/A'),
            'market': info.get('exchange', 'N/A'),
            'pe_ratio': info.get('trailingPE', None),
            'market_cap': info.get('marketCap', None),
            'dividend_yield': info.get('dividendYield', None)
        }
    except Exception as e:
        logger.error(f"获取 {stock_code} 信息失败: {e}")
        return None

def prepare_data(df, look_back=60, train_ratio=0.8):
    data = df['open'].values.reshape(-1, 1)
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(data)

    X, y = [], []
    for i in range(look_back, len(scaled_data)):
        X.append(scaled_data[i - look_back:i, 0])
        y.append(scaled_data[i, 0])

    X, y = np.array(X), np.array(y)
    train_size = int(len(X) * train_ratio)
    X_train, X_test = X[:train_size], X[train_size:]
    y_train, y_test = y[:train_size], y[train_size:]

    train_start = df['trade_date'][look_back].strftime('%Y-%m-%d')
    train_end = df['trade_date'][look_back + train_size - 1].strftime('%Y-%m-%d')
    test_start = df['trade_date'][look_back + train_size].strftime('%Y-%m-%d')
    test_end = df['trade_date'].iloc[-1].strftime('%Y-%m-%d')

    split_info = {
        'train_start': train_start,
        'train_end': train_end,
        'train_size': len(y_train),
        'test_start': test_start,
        'test_end': test_end,
        'test_size': len(y_test)
    }

    return X_train, X_test, y_train, y_test, scaler, data, split_info


# 统一的 calculate_metrics 函数
def calculate_metrics(data, initial_cash=None, y_true=None, y_pred=None, mode='simulation'):
    try:
        if mode == 'simulation':
            if initial_cash is None:
                raise ValueError("仿真模式需要提供 initial_cash")
            if isinstance(data, pd.DataFrame):
                if 'Portfolio_Value' not in data.columns:
                    raise ValueError("仿真模式需要提供包含 'Portfolio_Value' 列的 DataFrame")
                portfolio_value = data['Portfolio_Value']
            elif isinstance(data, pd.Series):
                portfolio_value = data
            else:
                raise ValueError("仿真模式的 data 必须是 DataFrame 或 Series")
            portfolio_returns = portfolio_value.pct_change().dropna()
            total_return = (portfolio_value.iloc[-1] - initial_cash) / initial_cash * 100
            max_drawdown = ((portfolio_value.cummax() - portfolio_value) / portfolio_value.cummax()).max() * 100
            sharpe_ratio = portfolio_returns.mean() / portfolio_returns.std() * np.sqrt(252) if portfolio_returns.std() != 0 else 0
            metrics = {
                'total_return': round(total_return, 2),
                'max_drawdown': round(max_drawdown, 2),
                'sharpe_ratio': round(sharpe_ratio, 2)
            }
            return metrics
        elif mode == 'prediction':
            if y_true is None or y_pred is None:
                raise ValueError("预测模式需要提供 y_true 和 y_pred")
            if len(y_true) != len(y_pred):
                raise ValueError("y_true 和 y_pred 长度不匹配")
            rmse = np.sqrt(mean_squared_error(y_true, y_pred))
            mae = mean_absolute_error(y_true, y_pred)
            r2 = r2_score(y_true, y_pred)
            direction_accuracy = np.mean((np.sign(y_pred[1:] - y_pred[:-1]) == np.sign(y_true[1:] - y_true[:-1])).astype(int))
            metrics = {
                'rmse': round(rmse, 2),
                'mae': round(mae, 2),
                'r2': round(r2, 2),
                'accuracy': round(direction_accuracy * 100, 2)
            }
            return metrics
        else:
            raise ValueError("未知模式，请指定 'simulation' 或 'prediction'")
    except Exception as e:
        logger.error(f"计算指标失败: {e}")
        return None

def train_linear_regression(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    model = LinearRegression()
    model.fit(X_train, y_train)
    y_pred_train = model.predict(X_train)
    y_pred_test = model.predict(X_test)
    y_pred_train = scaler.inverse_transform(y_pred_train.reshape(-1, 1)).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test.reshape(-1, 1)).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_arima(df, params):
    p, d, q = int(params.get('p', 5)), int(params.get('d', 1)), int(params.get('q', 0))
    model = ARIMA(df['open'], order=(p, d, q))
    model_fit = model.fit()
    train_size = int(len(df) * float(params.get('train_ratio', 0.8)))
    y_train = df['open'][:train_size].values
    y_test = df['open'][train_size:].values
    y_pred_train = model_fit.predict(start=0, end=train_size - 1)
    y_pred_test = model_fit.predict(start=train_size, end=len(df) - 1)
    metrics = calculate_metrics(y_test, y_pred_test, y_test)
    return model_fit, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_garch(df, params):
    train_size = int(len(df) * float(params.get('train_ratio', 0.8)))
    train_data = df['open'][:train_size]
    test_data = df['open'][train_size:]
    model = arch_model(train_data, vol='Garch', p=int(params.get('garch_p', 1)), q=int(params.get('garch_q', 1)))
    model_fit = model.fit(disp='off')
    forecast = model_fit.forecast(horizon=len(test_data))
    y_pred_test = train_data.iloc[-1] + np.cumsum(forecast.mean.values[-1, :])
    y_pred_train = model_fit.conditional_volatility + train_data
    y_train = train_data.values
    y_test = test_data.values
    metrics = calculate_metrics(y_test, y_pred_test, y_test)
    return model_fit, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_random_forest(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    model = RandomForestRegressor(n_estimators=int(params.get('n_estimators', 100)),
                                  max_depth=int(params.get('max_depth', 10)), random_state=42)
    model.fit(X_train, y_train)
    y_pred_train = model.predict(X_train)
    y_pred_test = model.predict(X_test)
    y_pred_train = scaler.inverse_transform(y_pred_train.reshape(-1, 1)).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test.reshape(-1, 1)).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_xgboost(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    model = xgb.XGBRegressor(objective='reg:squarederror', n_estimators=int(params.get('n_estimators', 100)),
                             max_depth=int(params.get('max_depth', 6)))
    model.fit(X_train, y_train)
    y_pred_train = model.predict(X_train)
    y_pred_test = model.predict(X_test)
    y_pred_train = scaler.inverse_transform(y_pred_train.reshape(-1, 1)).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test.reshape(-1, 1)).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_svm(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    model = SVR(kernel=params.get('kernel', 'rbf'), C=float(params.get('C', 1.0)))
    model.fit(X_train, y_train)
    y_pred_train = model.predict(X_train)
    y_pred_test = model.predict(X_test)
    y_pred_train = scaler.inverse_transform(y_pred_train.reshape(-1, 1)).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test.reshape(-1, 1)).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_lstm(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    X_train_3d = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
    X_test_3d = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
    model = Sequential()
    model.add(LSTM(int(params.get('units', 50)), return_sequences=True, input_shape=(X_train.shape[1], 1)))
    model.add(LSTM(int(params.get('units', 50))))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    model.fit(X_train_3d, y_train, epochs=int(params.get('epochs', 50)), batch_size=32, verbose=0)
    y_pred_train = model.predict(X_train_3d)
    y_pred_test = model.predict(X_test_3d)
    y_pred_train = scaler.inverse_transform(y_pred_train).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_cnn(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    X_train_3d = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
    X_test_3d = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
    model = Sequential()
    model.add(
        Conv1D(filters=int(params.get('filters', 32)), kernel_size=int(params.get('kernel_size', 3)), activation='relu',
               input_shape=(X_train.shape[1], 1)))
    model.add(MaxPooling1D(pool_size=2))
    model.add(Flatten())
    model.add(Dense(50, activation='relu'))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    model.fit(X_train_3d, y_train, epochs=int(params.get('epochs', 50)), batch_size=32, verbose=0)
    y_pred_train = model.predict(X_train_3d)
    y_pred_test = model.predict(X_test_3d)
    y_pred_train = scaler.inverse_transform(y_pred_train).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_rnn(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    X_train_3d = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
    X_test_3d = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
    model = Sequential()
    model.add(SimpleRNN(int(params.get('units', 50)), return_sequences=True, input_shape=(X_train.shape[1], 1)))
    model.add(SimpleRNN(int(params.get('units', 50))))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    model.fit(X_train_3d, y_train, epochs=int(params.get('epochs', 50)), batch_size=32, verbose=0)
    y_pred_train = model.predict(X_train_3d)
    y_pred_test = model.predict(X_test_3d)
    y_pred_train = scaler.inverse_transform(y_pred_train).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def train_gru(X_train, X_test, y_train, y_test, scaler, y_test_raw, params):
    X_train_3d = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
    X_test_3d = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
    model = Sequential()
    model.add(GRU(int(params.get('units', 50)), return_sequences=True, input_shape=(X_train.shape[1], 1)))
    model.add(GRU(int(params.get('units', 50))))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    model.fit(X_train_3d, y_train, epochs=int(params.get('epochs', 50)), batch_size=32, verbose=0)
    y_pred_train = model.predict(X_train_3d)
    y_pred_test = model.predict(X_test_3d)
    y_pred_train = scaler.inverse_transform(y_pred_train).flatten()
    y_pred_test = scaler.inverse_transform(y_pred_test).flatten()
    y_train = scaler.inverse_transform(y_train.reshape(-1, 1)).flatten()
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1)).flatten()
    metrics = calculate_metrics(y_test, y_pred_test, y_test_raw)
    return model, y_pred_train, y_pred_test, y_train, y_test, metrics


def predict_future(model, last_sequence, scaler, days, is_sequence_model=False):
    future_preds = []
    current_sequence = last_sequence.copy()

    for _ in range(days):
        if is_sequence_model:
            pred = model.predict(current_sequence.reshape(1, current_sequence.shape[0], 1), verbose=0)
        else:
            pred = model.predict(current_sequence.reshape(1, -1))
        future_preds.append(pred[0] if is_sequence_model else pred)
        current_sequence = np.roll(current_sequence, -1)
        current_sequence[-1] = pred[0] if is_sequence_model else pred

    future_preds = scaler.inverse_transform(np.array(future_preds).reshape(-1, 1)).flatten()
    return future_preds


def create_forecast_chart(df, y_train, y_pred_train, y_test, y_pred_test, future_preds, future_dates):
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=df['trade_date'], y=df['open'], name='历史开盘价', line=dict(color='blue')))
    train_dates = df['trade_date'][60:60 + len(y_train)]
    fig.add_trace(go.Scatter(x=train_dates, y=y_pred_train, name='训练集预测', line=dict(color='orange', dash='dash')))
    test_dates = df['trade_date'][60 + len(y_train):]
    fig.add_trace(go.Scatter(x=test_dates, y=y_pred_test, name='测试集预测', line=dict(color='green', dash='dash')))
    fig.add_trace(go.Scatter(x=future_dates, y=future_preds, name='未来预测', line=dict(color='red')))
    fig.update_layout(
        title='开盘价时间序列预测',
        xaxis_title='日期',
        yaxis_title='开盘价',
        template='plotly_white',
        height=600,
        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
    )
    return fig.to_json()

# MACD 策略（引入买入成本）
def macd_strategy(df, initial_cash, max_holding, params, stock_code=''):
    short_period = int(params.get('macd_short', 12))
    long_period = int(params.get('macd_long', 26))
    signal_period = int(params.get('macd_signal', 9))
    df['EMA_short'] = df['close'].ewm(span=short_period, adjust=False).mean()
    df['EMA_long'] = df['close'].ewm(span=long_period, adjust=False).mean()
    df['MACD'] = df['EMA_short'] - df['EMA_long']
    df['Signal'] = df['MACD'].ewm(span=signal_period, adjust=False).mean()
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash]
    trade_log = []
    total_cost = 0  # 累计买入成本
    total_shares = 0  # 累计买入股数

    for i in range(1, len(df)):
        prev_holdings = holdings
        if df['MACD'].iloc[i] > df['Signal'].iloc[i] and df['MACD'].iloc[i-1] <= df['Signal'].iloc[i-1] and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['MACD'].iloc[i] < df['Signal'].iloc[i] and df['MACD'].iloc[i-1] >= df['Signal'].iloc[i-1] and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log

# 多因子评分策略（引入买入成本）
def multi_factor_strategy(df, initial_cash, max_holding, params, stock_code=''):
    momentum_period = int(params.get('momentum_period', 20))
    df['Momentum'] = df['close'].pct_change(momentum_period)
    df['Volatility'] = df['close'].rolling(momentum_period).std()
    df['Score'] = (df['Momentum'] / df['Volatility']).rank()
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash] * momentum_period
    trade_log = []
    total_cost = 0
    total_shares = 0

    for i in range(momentum_period, len(df)):
        prev_holdings = holdings
        if df['Score'].iloc[i] > df['Score'].quantile(0.75) and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['Score'].iloc[i] < df['Score'].quantile(0.25) and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log

# 换手率和成交量策略（引入买入成本）
def turnover_volume_strategy(df, initial_cash, max_holding, params, stock_code=''):
    volume_period = int(params.get('volume_period', 20))
    df['Turnover'] = df['vol'] / df['close']
    df['Volume_MA'] = df['vol'].rolling(volume_period).mean()
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash] * volume_period
    trade_log = []
    total_cost = 0
    total_shares = 0

    for i in range(volume_period, len(df)):
        prev_holdings = holdings
        if df['Turnover'].iloc[i] > df['Turnover'].quantile(0.75) and df['vol'].iloc[i] > df['Volume_MA'].iloc[i] and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['Turnover'].iloc[i] < df['Turnover'].quantile(0.25) and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log

# 均线交叉策略（引入买入成本）
def ma_crossover_strategy(df, initial_cash, max_holding, params, stock_code=''):
    short_period = int(params.get('ma_short', 10))
    long_period = int(params.get('ma_long', 50))
    df['MA_short'] = df['close'].rolling(short_period).mean()
    df['MA_long'] = df['close'].rolling(long_period).mean()
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash] * long_period
    trade_log = []
    total_cost = 0
    total_shares = 0

    for i in range(long_period, len(df)):
        prev_holdings = holdings
        if df['MA_short'].iloc[i] > df['MA_long'].iloc[i] and df['MA_short'].iloc[i-1] <= df['MA_long'].iloc[i-1] and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['MA_short'].iloc[i] < df['MA_long'].iloc[i] and df['MA_short'].iloc[i-1] >= df['MA_long'].iloc[i-1] and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log

# RSI 策略（引入买入成本）
def rsi_strategy(df, initial_cash, max_holding, params, stock_code=''):
    period = int(params.get('rsi_period', 14))
    df['Change'] = df['close'].diff()
    df['Gain'] = df['Change'].apply(lambda x: x if x > 0 else 0)
    df['Loss'] = df['Change'].apply(lambda x: -x if x < 0 else 0)
    df['Avg_Gain'] = df['Gain'].rolling(period).mean()
    df['Avg_Loss'] = df['Loss'].rolling(period).mean()
    df['RS'] = df['Avg_Gain'] / df['Avg_Loss'].replace(0, np.nan)
    df['RSI'] = 100 - (100 / (1 + df['RS']))
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash] * period
    trade_log = []
    total_cost = 0
    total_shares = 0

    for i in range(period, len(df)):
        prev_holdings = holdings
        if df['RSI'].iloc[i] < 30 and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['RSI'].iloc[i] > 70 and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log

# 布林带策略（引入买入成本）
def bollinger_strategy(df, initial_cash, max_holding, params, stock_code=''):
    period = int(params.get('bb_period', 20))
    std_dev = float(params.get('bb_std', 2))
    df['MA'] = df['close'].rolling(period).mean()
    df['Std'] = df['close'].rolling(period).std()
    df['Upper'] = df['MA'] + std_dev * df['Std']
    df['Lower'] = df['MA'] - std_dev * df['Std']
    df['Position'] = 0
    cash = initial_cash
    holdings = 0
    portfolio_value = [initial_cash] * period
    trade_log = []
    total_cost = 0
    total_shares = 0

    for i in range(period, len(df)):
        prev_holdings = holdings
        if df['close'].iloc[i] < df['Lower'].iloc[i] and holdings < max_holding:
            shares_to_buy = min(max_holding - holdings, int(cash / df['close'].iloc[i]))
            if shares_to_buy > 0:
                cost = shares_to_buy * df['close'].iloc[i]
                cash -= cost
                holdings += shares_to_buy
                total_cost += cost
                total_shares += shares_to_buy
                trade_log.append({
                    'date': df['trade_date'].iloc[i],
                    'stock': stock_code,
                    'action': 'Buy',
                    'shares': shares_to_buy,
                    'price': round(df['close'].iloc[i], 2),
                    'profit': 0,
                    'holding_value': round(holdings * df['close'].iloc[i], 2)
                })
        elif df['close'].iloc[i] > df['Upper'].iloc[i] and holdings > 0:
            avg_cost = total_cost / total_shares if total_shares > 0 else 0
            profit = (df['close'].iloc[i] - avg_cost) * holdings
            cash += holdings * df['close'].iloc[i]
            trade_log.append({
                'date': df['trade_date'].iloc[i],
                'stock': stock_code,
                'action': 'Sell',
                'shares': holdings,
                'price': round(df['close'].iloc[i], 2),
                'profit': round(profit, 2),
                'holding_value': 0
            })
            total_cost = 0
            total_shares = 0
            holdings = 0
        df.loc[df.index[i], 'Position'] = holdings
        portfolio_value.append(cash + holdings * df['close'].iloc[i])

    df['Portfolio_Value'] = pd.Series(portfolio_value, index=df.index)
    return df, trade_log


# 多股票仿真
def multi_stock_simulation(data, initial_cash, max_holding_per_stock, strategy, params):
    total_cash = initial_cash
    portfolio = {code: {'df': df, 'holdings': 0} for code, df in data.items()}
    portfolio_value = []

    for date in data[list(data.keys())[0]]['trade_date']:
        daily_value = 0
        for code, stock in portfolio.items():
            df = stock['df']
            if date in df['trade_date'].values:
                idx = df[df['trade_date'] == date].index[0]
                if strategy == 'macd':
                    df = macd_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                elif strategy == 'multi_factor':
                    df = multi_factor_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                elif strategy == 'turnover_volume':
                    df = turnover_volume_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                elif strategy == 'ma_crossover':
                    df = ma_crossover_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                elif strategy == 'rsi':
                    df = rsi_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                elif strategy == 'bollinger':
                    df = bollinger_strategy(df, total_cash / len(data), max_holding_per_stock, params)
                stock['df'] = df
                daily_value += df['Portfolio_Value'].iloc[idx]
        portfolio_value.append(daily_value)

    combined_df = pd.DataFrame({
        'trade_date': data[list(data.keys())[0]]['trade_date'],
        'Portfolio_Value': portfolio_value
    })
    return combined_df


# 计算指标



# 生成仿真图表
def create_simulation_chart(df, stock_data):
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=df['trade_date'], y=df['Portfolio_Value'], name='投资组合价值', line=dict(color='blue')))
    for code, data in stock_data.items():
        fig.add_trace(go.Scatter(x=data['trade_date'], y=data['close'], name=f'{code} 收盘价',
                                 line=dict(color='gray', dash='dash'), yaxis='y2'))
    fig.update_layout(
        title='量化策略仿真结果',
        xaxis_title='日期',
        yaxis_title='投资组合价值',
        yaxis2=dict(title='收盘价', overlaying='y', side='right'),
        template='plotly_white',
        height=600,
        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
    )
    return fig.to_json()


# 计算技术指标
def calculate_technical_indicators(df):
    try:
        # 确保基础列存在
        if 'close' not in df.columns:
            logger.error("缺少 'close' 列，无法计算技术指标")
            return df

        # 计算 MA20 和 MA50（如果尚未计算）
        if 'MA20' not in df.columns:
            df['MA20'] = df['close'].rolling(window=20).mean()
        if 'MA50' not in df.columns:
            df['MA50'] = df['close'].rolling(window=50).mean()

        # 计算 MACD
        ema12 = df['close'].ewm(span=12, adjust=False).mean()
        ema26 = df['close'].ewm(span=26, adjust=False).mean()
        df['MACD'] = ema12 - ema26
        df['Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()

        # 计算 RSI
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        df['RSI'] = 100 - (100 / (1 + rs))

        # 计算波动率和动量
        df['Volatility'] = df['close'].rolling(window=20).std()
        df['Momentum'] = df['close'].pct_change(periods=20)

        return df

    except Exception as e:
        logger.error(f"计算技术指标时出错: {str(e)}")
        return df

# 创建 K 线图
def create_candlestick_chart1(df, stock_info, strategy):
    try:
        # 确保 df 包含必要的列
        required_columns = ['trade_date', 'open', 'high', 'low', 'close', 'vol']
        if not all(col in df.columns for col in required_columns):
            logger.error("数据缺少必要列，无法生成K线图")
            return None

        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                            subplot_titles=(f"{stock_info['code']} K线图", "成交量"), row_heights=[0.7, 0.3])

        # 添加K线图
        fig.add_trace(
            go.Candlestick(x=df['trade_date'], open=df['open'], high=df['high'], low=df['low'], close=df['close'],
                           name='K线'), row=1, col=1)

        # 添加 MA20（如果存在）
        if 'MA20' in df.columns and not df['MA20'].isna().all():
            fig.add_trace(go.Scatter(x=df['trade_date'], y=df['MA20'], name='MA20', line=dict(color='orange')), row=1,
                          col=1)
        else:
            logger.warning("MA20 列缺失或全为 NaN，跳过 MA20 线的绘制")

        # 添加 MA50（如果存在）
        if 'MA50' in df.columns and not df['MA50'].isna().all():
            fig.add_trace(go.Scatter(x=df['trade_date'], y=df['MA50'], name='MA50', line=dict(color='purple')), row=1,
                          col=1)
        else:
            logger.warning("MA50 列缺失或全为 NaN，跳过 MA50 线的绘制")

        # 添加成交量
        fig.add_trace(go.Bar(x=df['trade_date'], y=df['vol'], name='成交量'), row=2, col=1)

        # 设置图表布局
        fig.update_layout(
            title=f"{stock_info['name']} 股价趋势及交易决策",
            xaxis_title="日期",
            yaxis_title="价格",
            template="plotly_white",
            height=600,
            showlegend=True,
            annotations=[dict(xref="paper", yref="paper", x=1.05, y=1.0, showarrow=False,
                              text=f"行业: {stock_info['industry']}<br>市场: {stock_info['market']}<br>市盈率: {stock_info['pe_ratio'] or 'N/A'}<br>市值: {stock_info['market_cap'] / 1e9 if stock_info['market_cap'] else 'N/A'}B<br>股息率: {stock_info['dividend_yield'] * 100 if stock_info['dividend_yield'] else 'N/A'}%<br>策略: {strategy}",
                              align="left")]
        )
        return fig.to_json()

    except Exception as e:
        logger.error(f"生成K线图时出错: {str(e)}")
        return None

def prepare_ml_data(df, look_back=20, is_sequence=False):
    df = calculate_technical_indicators(df)
    features = ['close', 'vol', 'MA20', 'MA50', 'MACD', 'RSI', 'Momentum', 'Volatility']
    df = df.dropna()
    if len(df) < look_back + 1:
        logger.warning("数据量不足，无法生成目标变量")
        return None, None, None
    X = df[features].values
    y = (df['close'].shift(-1) > df['close']).astype(int).dropna()
    if len(y) == 0 or len(set(y)) < 2:
        logger.warning(f"目标变量 y 只有一个类别: {set(y)}")
        return None, None, None
    scaler = MinMaxScaler()
    X_scaled = scaler.fit_transform(X)
    if is_sequence:  # 为 LSTM 和 GRU 准备序列数据
        X_seq = []
        for i in range(len(X_scaled) - look_back):
            X_seq.append(X_scaled[i:i + look_back])
        X_seq = np.array(X_seq)
        y = y[look_back:]
        return X_seq, y, scaler
    else:
        X = X_scaled[:-1]
        y = y[:-1]
        return X, y, scaler

# 详细分析函数
def get_detailed_analysis(stock_code, start_date, end_date):
    try:
        df = get_stock_data(stock_code, start_date, end_date)
        if df is None or len(df) < 50:
            logger.warning(f"{stock_code} 数据不足以进行详细分析 (需要至少 50 天数据)，当前数据量: {len(df) if df is not None else 0}")
            return {'code': stock_code, 'error': '数据不足以进行详细分析'}

        df = calculate_technical_indicators(df)
        latest = df.iloc[-1]

        # 初始化分析结果
        analysis = {
            'code': stock_code,
            'close': round(latest['close'], 2),
            'rsi': 'N/A',
            'macd': 'N/A',
            'signal': 'N/A',
            'momentum': 'N/A',
            'volatility': 'N/A',
            'recommendation': '观望'
        }

        # 填充技术指标（如果存在）
        if 'RSI' in df.columns and not pd.isna(latest['RSI']):
            analysis['rsi'] = round(latest['RSI'], 2)
        if 'MACD' in df.columns and not pd.isna(latest['MACD']):
            analysis['macd'] = round(latest['MACD'], 2)
        if 'Signal' in df.columns and not pd.isna(latest['Signal']):
            analysis['signal'] = round(latest['Signal'], 2)
        if 'Momentum' in df.columns and not pd.isna(latest['Momentum']):
            analysis['momentum'] = round(latest['Momentum'] * 100, 2)
        if 'Volatility' in df.columns and not pd.isna(latest['Volatility']):
            analysis['volatility'] = round(latest['Volatility'], 2)

        # 生成推荐建议
        if analysis['rsi'] != 'N/A' and analysis['macd'] != 'N/A' and analysis['signal'] != 'N/A':
            if analysis['rsi'] < 30 or analysis['macd'] > analysis['signal']:
                analysis['recommendation'] = '买入'
            elif analysis['rsi'] > 70 or analysis['macd'] < analysis['signal']:
                analysis['recommendation'] = '卖出'

        return analysis

    except Exception as e:
        logger.error(f"生成详细分析时出错: {str(e)}")
        return {'code': stock_code, 'error': f'分析失败: {str(e)}'}

# 筛选函数
def apply_filters(stock_info, filters):
    min_pe = float(filters.get('min_pe', 0))
    min_market_cap = float(filters.get('min_market_cap', 0))
    min_volume = float(filters.get('min_volume', 0))
    stock_data = get_stock_data(stock_info['code'], start_date=(datetime.now() - timedelta(days=20)).strftime('%Y-%m-%d'), end_date=datetime.now().strftime('%Y-%m-%d'))
    avg_volume = stock_data['vol'].mean() if stock_data is not None else 0
    return (stock_info['pe_ratio'] is not None and stock_info['pe_ratio'] >= min_pe and
            stock_info['market_cap'] is not None and stock_info['market_cap'] >= min_market_cap and
            avg_volume >= min_volume)

# 选股策略
def fundamental_strategy(stock_list, num_stocks, filters, params):
    results = []
    for stock in stock_list:
        info = get_stock_info(stock['code'])
        if info and apply_filters(info, filters):
            score = (1 / info['pe_ratio']) * 0.7 + (info['dividend_yield'] or 0) * 0.3
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': '持有并观察，关注分红'
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def technical_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 50 and apply_filters(info, filters):
            df = calculate_technical_indicators(df)
            latest = df.iloc[-1]
            score = 0
            strategy = ''
            if latest['RSI'] < 30:
                score += 0.5
                strategy = '买入（RSI超卖信号）'
            elif latest['RSI'] > 70:
                score -= 0.3
                strategy = '卖出（RSI超买信号）'
            if latest['MACD'] > latest['Signal'] and df['MACD'].iloc[-2] <= df['Signal'].iloc[-2]:
                score += 0.5
                strategy = '买入（MACD金叉）'
            elif latest['MACD'] < latest['Signal'] and df['MACD'].iloc[-2] >= df['Signal'].iloc[-2]:
                score -= 0.3
                strategy = '卖出（MACD死叉）'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round((score + 1) * 50, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def ml_dt_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        logger.error("无法获取股票数据")
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None or len(X) < 20:  # 确保足够样本
                logger.warning(f"{stock['code']} 数据不足或无效，跳过")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（数据不足）'
                })
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:  # 确保训练和测试集有效
                logger.warning(f"{stock['code']} 训练集或测试集样本不足: train_size={train_size}, test_size={len(X) - train_size}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（样本不足）'
                })
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            param_grid = {'max_depth': [params.get('dt_max_depth', 10), None]}
            model = GridSearchCV(DecisionTreeClassifier(random_state=42), param_grid, cv=3)
            try:
                model.fit(X_train, y_train)
                proba = model.best_estimator_.predict_proba(X_test)
                if proba.shape[0] == 0 or proba.shape[1] < 2:
                    logger.warning(f"{stock['code']} 预测概率异常: {proba.shape}")
                    score = 0.5
                else:
                    score = proba[-1][1]  # 取最后一个样本的正类概率
                strategy = '买入（决策树预测上涨）' if score > 0.5 else '观望'
                results.append({
                    'info': info,
                    'score': score,
                    'bullish_index': min(round(score * 100, 2), 100),
                    'strategy': strategy
                })
            except Exception as e:
                logger.error(f"{stock['code']} 决策树训练失败: {str(e)}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（模型训练失败）'
                })
        else:
            logger.warning(f"{stock['code']} 数据长度不足或未通过筛选")
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def ml_svm_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None:
                logger.warning(f"{stock['code']} 数据无效，跳过")
                results.append({
                    'info': info,
                    'score': 0.5,  # 默认中性得分
                    'bullish_index': 50,
                    'strategy': '观望（数据不足）'
                })
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10:  # 确保训练集有足够样本
                logger.warning(f"{stock['code']} 训练样本不足: {train_size}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（样本不足）'
                })
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            param_grid = {'C': [params.get('svm_c', 1.0)], 'kernel': ['rbf', 'linear']}
            model = GridSearchCV(SVC(probability=True), param_grid, cv=3, error_score='raise')
            try:
                model.fit(X_train, y_train)
                score = model.best_estimator_.predict_proba(X_test)[-1][1]
                strategy = '买入（SVM预测上涨）' if score > 0.5 else '观望'
                results.append({
                    'info': info,
                    'score': score,
                    'bullish_index': min(round(score * 100, 2), 100),
                    'strategy': strategy
                })
            except Exception as e:
                logger.error(f"{stock['code']} SVM 训练失败: {e}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（模型训练失败）'
                })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def dl_mlp_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            train_size = int(len(X) * 0.8)
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            model = Sequential()
            model.add(Dense(params.get('mlp_units', 64), activation='relu', input_shape=(X_train.shape[1],)))
            model.add(Dense(32, activation='relu'))
            model.add(Dense(1, activation='sigmoid'))
            model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
            model.fit(X_train, y_train, epochs=params.get('mlp_epochs', 10), batch_size=32, verbose=0)
            score = model.predict(X_test)[-1][0]
            strategy = '买入（MLP预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def dl_cnn_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            train_size = int(len(X) * 0.8)
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
            X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
            model = Sequential()
            model.add(Conv1D(filters=params.get('cnn_filters', 32), kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
            model.add(MaxPooling1D(pool_size=2))
            model.add(Flatten())
            model.add(Dense(1, activation='sigmoid'))
            model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
            model.fit(X_train, y_train, epochs=params.get('cnn_epochs', 10), batch_size=32, verbose=0)
            score = model.predict(X_test)[-1][0]
            strategy = '买入（CNN预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]


def rl_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    # 简化版强化学习策略，基于收益模拟
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            returns = df['close'].pct_change().dropna()
            score = np.mean(returns[-20:]) * 100  # 模拟 Q 值
            strategy = '买入（强化学习模拟收益）' if score > 0 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round((score + 1) * 50, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def pca_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        logger.error("无法获取股票数据")
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None or len(X) < 20:  # 确保足够样本
                logger.warning(f"{stock['code']} 数据不足或无效，跳过")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（数据不足）'
                })
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:  # 确保训练和测试集有效
                logger.warning(f"{stock['code']} 训练集或测试集样本不足: train_size={train_size}, test_size={len(X) - train_size}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（样本不足）'
                })
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            pca = PCA(n_components=params.get('pca_n_components', 2))
            try:
                X_pca = pca.fit_transform(X)
                X_train_pca, X_test_pca = X_pca[:train_size], X_pca[train_size:]
                model = RandomForestClassifier(n_estimators=100, random_state=42)
                model.fit(X_train_pca, y_train)
                proba = model.predict_proba(X_test_pca)
                if proba.shape[0] == 0 or proba.shape[1] < 2:
                    logger.warning(f"{stock['code']} 预测概率异常: {proba.shape}")
                    score = 0.5
                else:
                    score = proba[-1][1]  # 取最后一个样本的正类概率
                strategy = '买入（PCA降维预测上涨）' if score > 0.5 else '观望'
                results.append({
                    'info': info,
                    'score': score,
                    'bullish_index': min(round(score * 100, 2), 100),
                    'strategy': strategy
                })
            except Exception as e:
                logger.error(f"{stock['code']} PCA策略失败: {str(e)}")
                results.append({
                    'info': info,
                    'score': 0.5,
                    'bullish_index': 50,
                    'strategy': '观望（模型训练失败）'
                })
        else:
            logger.warning(f"{stock['code']} 数据长度不足或未通过筛选")
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

def volatility_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            df = calculate_technical_indicators(df)
            latest_vol = df['Volatility'].iloc[-1]
            avg_vol = df['Volatility'].mean()
            score = latest_vol / avg_vol if avg_vol != 0 else 0
            strategy = '买入（波动率突破）' if score > 1.2 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 50, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 新增策略：深度学习（LSTM）
def dl_lstm_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df, look_back=params.get('lstm_look_back', 20), is_sequence=True)
            if X is None or y is None or len(X) < 20:
                logger.warning(f"{stock['code']} 数据不足，跳过")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（数据不足）'})
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:
                logger.warning(f"{stock['code']} 训练集或测试集样本不足")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（样本不足）'})
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            model = Sequential()
            model.add(LSTM(units=params.get('lstm_units', 50), return_sequences=False, input_shape=(X_train.shape[1], X_train.shape[2])))
            model.add(Dense(1, activation='sigmoid'))
            model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
            model.fit(X_train, y_train, epochs=params.get('lstm_epochs', 10), batch_size=32, verbose=0)
            score = model.predict(X_test)[-1][0]
            strategy = '买入（LSTM预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 新增策略：深度学习（GRU）
def dl_gru_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df, look_back=params.get('gru_look_back', 20), is_sequence=True)
            if X is None or y is None or len(X) < 20:
                logger.warning(f"{stock['code']} 数据不足，跳过")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（数据不足）'})
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:
                logger.warning(f"{stock['code']} 训练集或测试集样本不足")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（样本不足）'})
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            model = Sequential()
            model.add(GRU(units=params.get('gru_units', 50), return_sequences=False, input_shape=(X_train.shape[1], X_train.shape[2])))
            model.add(Dense(1, activation='sigmoid'))
            model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
            model.fit(X_train, y_train, epochs=params.get('gru_epochs', 10), batch_size=32, verbose=0)
            score = model.predict(X_test)[-1][0]
            strategy = '买入（GRU预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 新增策略：机器学习（XGBoost）
def ml_xgboost_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None or len(X) < 20:
                logger.warning(f"{stock['code']} 数据不足，跳过")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（数据不足）'})
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:
                logger.warning(f"{stock['code']} 训练集或测试集样本不足")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（样本不足）'})
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            model = xgb.XGBClassifier(max_depth=params.get('xgb_max_depth', 3), n_estimators=100, random_state=42)
            model.fit(X_train, y_train)
            proba = model.predict_proba(X_test)
            if proba.shape[0] == 0 or proba.shape[1] < 2:
                logger.warning(f"{stock['code']} 预测概率异常")
                score = 0.5
            else:
                score = proba[-1][1]
            strategy = '买入（XGBoost预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 新增策略：机器学习（随机森林）
def ml_rf_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None or len(X) < 20:
                logger.warning(f"{stock['code']} 数据不足，跳过")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（数据不足）'})
                continue
            train_size = int(len(X) * 0.8)
            if train_size < 10 or len(X) - train_size < 2:
                logger.warning(f"{stock['code']} 训练集或测试集样本不足")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（样本不足）'})
                continue
            X_train, X_test = X[:train_size], X[train_size:]
            y_train, y_test = y[:train_size], y[train_size:]
            model = RandomForestClassifier(n_estimators=params.get('rf_n_estimators', 100), max_depth=params.get('rf_max_depth', 10), random_state=42)
            model.fit(X_train, y_train)
            proba = model.predict_proba(X_test)
            if proba.shape[0] == 0 or proba.shape[1] < 2:
                logger.warning(f"{stock['code']} 预测概率异常")
                score = 0.5
            else:
                score = proba[-1][1]
            strategy = '买入（随机森林预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 新增策略：机器学习（K-means）
def ml_kmeans_strategy(stock_list, num_stocks, start_date, end_date, filters, params):
    results = []
    stock_data = get_stock_data([s['code'] for s in stock_list], start_date, end_date, multi_stock=True)
    if not stock_data:
        return []
    for stock in stock_list:
        df = stock_data.get(stock['code'])
        info = get_stock_info(stock['code'])
        if df is not None and len(df) >= 60 and apply_filters(info, filters):
            X, y, scaler = prepare_ml_data(df)
            if X is None or y is None or len(X) < 20:
                logger.warning(f"{stock['code']} 数据不足，跳过")
                results.append({'info': info, 'score': 0.5, 'bullish_index': 50, 'strategy': '观望（数据不足）'})
                continue
            kmeans = KMeans(n_clusters=params.get('kmeans_clusters', 2), random_state=42)
            clusters = kmeans.fit_predict(X)
            # 将最新数据点的簇标签与正类（上涨）相关联
            latest_cluster = clusters[-1]
            cluster_labels = np.zeros(len(clusters))
            for cluster in range(params.get('kmeans_clusters', 2)):
                cluster_mask = (clusters == cluster)
                if np.sum(cluster_mask) > 0:
                    cluster_labels[cluster_mask] = np.mean(y[cluster_mask])
            score = cluster_labels[-1]
            strategy = '买入（K-means簇预测上涨）' if score > 0.5 else '观望'
            results.append({
                'info': info,
                'score': score,
                'bullish_index': min(round(score * 100, 2), 100),
                'strategy': strategy
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)[:num_stocks]

# 选股平台路由
# 修改 stock_selection 路由以支持新策略
@app.route('/stock_selection', methods=['GET', 'POST'])
def stock_selection():
    default_start = (datetime.now() - timedelta(days=90)).strftime('%Y-%m-%d')
    default_end = datetime.now().strftime('%Y-%m-%d')
    default_num_stocks = 5
    default_strategy = 'fundamental'
    default_filters = {'min_pe': 0, 'min_market_cap': 0, 'min_volume': 0}
    default_params = {
        'dt_max_depth': 10, 'svm_c': 1.0, 'mlp_units': 64, 'mlp_epochs': 10,
        'cnn_filters': 32, 'cnn_epochs': 10, 'pca_n_components': 2,
        'lstm_units': 50, 'lstm_epochs': 10, 'lstm_look_back': 20,
        'gru_units': 50, 'gru_epochs': 10, 'gru_look_back': 20,
        'xgb_max_depth': 3, 'rf_n_estimators': 100, 'rf_max_depth': 10,
        'kmeans_clusters': 2
    }

    start_date = default_start
    end_date = default_end
    num_stocks = default_num_stocks
    strategy = default_strategy
    filters = default_filters.copy()
    params = default_params.copy()
    selected_stocks = []

    if request.method == 'POST':
        start_date = request.form.get('start_date', default_start)
        end_date = request.form.get('end_date', default_end)
        num_stocks = int(request.form.get('num_stocks', default_num_stocks))
        strategy = request.form.get('strategy', default_strategy)
        filters['min_pe'] = float(request.form.get('min_pe', 0))
        filters['min_market_cap'] = float(request.form.get('min_market_cap', 0)) * 1e9
        filters['min_volume'] = float(request.form.get('min_volume', 0)) * 1e6
        params['dt_max_depth'] = int(request.form.get('dt_max_depth', 10))
        params['svm_c'] = float(request.form.get('svm_c', 1.0))
        params['mlp_units'] = int(request.form.get('mlp_units', 64))
        params['mlp_epochs'] = int(request.form.get('mlp_epochs', 10))
        params['cnn_filters'] = int(request.form.get('cnn_filters', 32))
        params['cnn_epochs'] = int(request.form.get('cnn_epochs', 10))
        params['pca_n_components'] = int(request.form.get('pca_n_components', 2))
        params['lstm_units'] = int(request.form.get('lstm_units', 50))
        params['lstm_epochs'] = int(request.form.get('lstm_epochs', 10))
        params['lstm_look_back'] = int(request.form.get('lstm_look_back', 20))
        params['gru_units'] = int(request.form.get('gru_units', 50))
        params['gru_epochs'] = int(request.form.get('gru_epochs', 10))
        params['gru_look_back'] = int(request.form.get('gru_look_back', 20))
        params['xgb_max_depth'] = int(request.form.get('xgb_max_depth', 3))
        params['rf_n_estimators'] = int(request.form.get('rf_n_estimators', 100))
        params['rf_max_depth'] = int(request.form.get('rf_max_depth', 10))
        params['kmeans_clusters'] = int(request.form.get('kmeans_clusters', 2))

        strategy_map = {
            'fundamental': fundamental_strategy,
            'technical': technical_strategy,
            'ml_dt': ml_dt_strategy,
            'ml_svm': ml_svm_strategy,
            'dl_mlp': dl_mlp_strategy,
            'dl_cnn': dl_cnn_strategy,
            'rl': rl_strategy,
            'pca': pca_strategy,
            'volatility': volatility_strategy,
            'dl_lstm': dl_lstm_strategy,
            'dl_gru': dl_gru_strategy,
            'ml_xgboost': ml_xgboost_strategy,
            'ml_rf': ml_rf_strategy,
            'ml_kmeans': ml_kmeans_strategy
        }

        selected_strategy = strategy_map.get(strategy, fundamental_strategy)
        if strategy == 'fundamental':
            selected_stocks = selected_strategy(STOCK_OPTIONS, num_stocks, filters, params)
        else:
            selected_stocks = selected_strategy(STOCK_OPTIONS, num_stocks, start_date, end_date, filters, params)

    steps_templates = {
        'fundamental': [
            "获取所有候选股票的基本面数据（如市盈率、股息收益率）。",
            f"应用筛选条件：市盈率 >= {filters['min_pe']}，市值 >= {filters['min_market_cap']/1e9}B，成交量 >= {filters['min_volume']/1e6}M。",
            "计算综合得分：70%基于市盈率倒数，30%基于股息收益率。",
            f"按得分排序并选择前 {num_stocks} 只股票。"
        ],
        'technical': [
            "获取所有候选股票的历史价格数据。",
            f"应用筛选条件：市值 >= {filters['min_market_cap']/1e9}B，成交量 >= {filters['min_volume']/1e6}M。",
            "计算技术指标（RSI、MACD等），根据超买/超卖信号和交叉点评分。",
            f"按技术得分排序并选择前 {num_stocks} 只股票。"
        ],
        'ml_dt': [
            "获取历史数据并计算技术指标。",
            "准备特征数据（收盘价、成交量、移动平均线等）。",
            f"使用决策树模型（最大深度={params['dt_max_depth']}）进行训练。",
            f"预测未来价格趋势并按概率得分排序，选择前 {num_stocks} 只股票。"
        ],
        'ml_svm': [
            "获取历史数据并提取特征。",
            "数据标准化处理。",
            f"使用SVM模型（C值={params['svm_c']}）进行分类训练。",
            f"预测上涨概率并排序，选择前 {num_stocks} 只股票。"
        ],
        'dl_mlp': [
            "获取历史数据并计算技术指标。",
            "数据标准化并准备特征集。",
            f"使用MLP模型（神经元={params['mlp_units']}，Epochs={params['mlp_epochs']}）训练。",
            f"预测未来趋势并按得分排序，选择前 {num_stocks} 只股票。"
        ],
        'dl_cnn': [
            "获取历史数据并提取特征。",
            "将数据转换为时间序列格式。",
            f"使用CNN模型（滤波器={params['cnn_filters']}，Epochs={params['cnn_epochs']}）训练。",
            f"预测上涨概率并排序，选择前 {num_stocks} 只股票。"
        ],
        'rl': [
            "获取历史价格数据。",
            "计算近期收益率均值作为模拟收益。",
            "基于强化学习思路评估潜在回报。",
            f"按收益得分排序，选择前 {num_stocks} 只股票。"
        ],
        'pca': [
            "获取历史数据并计算特征。",
            f"使用PCA降维（成分数={params['pca_n_components']}）。",
            "使用随机森林模型训练降维后的数据。",
            f"预测上涨概率并排序，选择前 {num_stocks} 只股票。"
        ],
        'volatility': [
            "获取历史价格数据并计算波动率。",
            "比较最新波动率与平均波动率。",
            "识别波动率突破信号。",
            f"按波动率得分排序，选择前 {num_stocks} 只股票。"
        ],
        'dl_lstm': [
            "获取历史数据并计算技术指标。",
            f"将数据转换为时间序列（回看天数={params['lstm_look_back']}）。",
            f"使用LSTM模型（神经元={params['lstm_units']}，Epochs={params['lstm_epochs']}）训练。",
            f"预测未来趋势并按得分排序，选择前 {num_stocks} 只股票。"
        ],
        'dl_gru': [
            "获取历史数据并提取特征。",
            f"转换为时间序列格式（回看天数={params['gru_look_back']}）。",
            f"使用GRU模型（神经元={params['gru_units']}，Epochs={params['gru_epochs']}）训练。",
            f"预测上涨概率并排序，选择前 {num_stocks} 只股票。"
        ],
        'ml_xgboost': [
            "获取历史数据并计算技术指标。",
            "数据标准化处理。",
            f"使用XGBoost模型（最大深度={params['xgb_max_depth']}）训练。",
            f"预测上涨概率并排序，选择前 {num_stocks} 只股票。"
        ],
        'ml_rf': [
            "获取历史数据并提取特征。",
            "数据标准化。",
            f"使用随机森林模型（树数量={params['rf_n_estimators']}，最大深度={params['rf_max_depth']}）训练。",
            f"预测未来趋势并按得分排序，选择前 {num_stocks} 只股票。"
        ],
        'ml_kmeans': [
            "获取历史数据并计算技术指标。",
            f"使用K-means聚类（簇数={params['kmeans_clusters']}）对特征进行分组。",
            "根据簇标签与历史趋势关联预测未来表现。",
            f"按得分排序，选择前 {num_stocks} 只股票。"
        ]
    }

    steps = steps_templates.get(strategy, [])

    return render_template(
        'stock_selection.html',
        stock_options=STOCK_OPTIONS,
        selected_stocks=selected_stocks,
        default_start=start_date,
        default_end=end_date,
        default_num_stocks=num_stocks,
        strategy=strategy,
        steps=steps,
        filters=filters,
        params=params
    )

# 修改后的 stock_detail 路由以确保 K 线图正常返回
@app.route('/stock_detail/<stock_code>', methods=['GET'])
def stock_detail(stock_code):
    try:
        start_date = request.args.get('start_date', (datetime.now() - timedelta(days=90)).strftime('%Y-%m-%d'))
        end_date = request.args.get('end_date', datetime.now().strftime('%Y-%m-%d'))
        if pd.to_datetime(start_date) > pd.to_datetime(end_date):
            start_date, end_date = end_date, start_date
        logger.info(f"请求 {stock_code} 数据: {start_date} 至 {end_date}")

        df = get_stock_data(stock_code, start_date, end_date)
        info = get_stock_info(stock_code)
        strategy = request.args.get('strategy', '观望')

        if df is None or info is None or len(df) < 10:
            logger.error(f"无法获取 {stock_code} 的有效数据: df={df is not None}, info={info is not None}, len(df)={len(df) if df is not None else 'N/A'}")
            return jsonify({'error': '无法获取股票数据或数据不足'}), 400

        chart_json = create_candlestick_chart1(df, info, strategy)
        if not chart_json:
            logger.error(f"{stock_code} 图表生成失败")
            return jsonify({'error': '图表生成失败'}), 500

        analysis = get_detailed_analysis(stock_code, start_date, end_date)
        if analysis is None or 'error' in analysis:
            logger.warning(f"{stock_code} 分析数据不足")
            analysis = {'code': stock_code, 'error': analysis.get('error', '分析数据不足')}

        logger.debug(f"{stock_code} 图表和分析数据已生成")
        return jsonify({'chart': chart_json, 'analysis': analysis})

    except Exception as e:
        logger.error(f"处理 {stock_code} 请求时出错: {str(e)}")
        return jsonify({'error': f'服务器错误: {str(e)}'}), 500
@app.route('/forecast', methods=['GET', 'POST'])
def forecast():
    default_stock = 'AAPL'
    default_end = datetime.now().strftime('%Y-%m-%d')
    default_start = (datetime.now() - timedelta(days=365)).strftime('%Y-%m-%d')
    default_days = 30
    default_train_ratio = 0.8

    stock_code = default_stock
    start_date = default_start
    end_date = default_end
    days = default_days
    train_ratio = default_train_ratio
    model_type = 'lr'
    chart_json = None
    stock_info = None
    metrics = None
    future_table = None
    split_info = None

    # 默认参数
    default_params = {
        'train_ratio': default_train_ratio,
        'p': 5, 'd': 1, 'q': 0,  # ARIMA
        'garch_p': 1, 'garch_q': 1,  # GARCH
        'n_estimators': 100, 'max_depth': 10,  # RF
        'xgb_n_estimators': 100, 'xgb_max_depth': 6,  # XGBoost
        'kernel': 'rbf', 'C': 1.0,  # SVM
        'units': 50, 'epochs': 50,  # LSTM/RNN/GRU
        'filters': 32, 'kernel_size': 3  # CNN
    }
    params = default_params.copy()  # 初始化 params

    if request.method == 'POST':
        stock_code = request.form.get('stock_code', default_stock)
        start_date = request.form.get('start_date', default_start)
        end_date = request.form.get('end_date', default_end)
        days = int(request.form.get('days', default_days))
        train_ratio = float(request.form.get('train_ratio', default_train_ratio))
        model_type = request.form.get('model_type', 'lr')
        params.update({
            'train_ratio': train_ratio,
            'p': request.form.get('arima_p', 5),
            'd': request.form.get('arima_d', 1),
            'q': request.form.get('arima_q', 0),
            'garch_p': request.form.get('garch_p', 1),
            'garch_q': request.form.get('garch_q', 1),
            'n_estimators': request.form.get('rf_n_estimators', 100),
            'max_depth': request.form.get('rf_max_depth', 10),
            'xgb_n_estimators': request.form.get('xgb_n_estimators', 100),
            'xgb_max_depth': request.form.get('xgb_max_depth', 6),
            'kernel': request.form.get('svm_kernel', 'rbf'),
            'C': request.form.get('svm_C', 1.0),
            'units': request.form.get('nn_units', 50),
            'epochs': request.form.get('nn_epochs', 50),
            'filters': request.form.get('cnn_filters', 32),
            'kernel_size': request.form.get('cnn_kernel_size', 3)
        })

    df = get_stock_data(stock_code, start_date, end_date)
    if df is not None and not df.empty:
        stock_info = get_stock_info(stock_code)

        if model_type in ['arima', 'garch']:
            if model_type == 'arima':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_arima(df, params)
            else:
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_garch(df, params)
            last_sequence = df['open'].values[-60:]
            future_preds = model.forecast(start=len(df), end=len(df) + days - 1).values
            future_dates = [df['trade_date'].iloc[-1] + timedelta(days=i + 1) for i in range(days)]
            split_info = {
                'train_start': df['trade_date'][0].strftime('%Y-%m-%d'),
                'train_end': df['trade_date'][int(len(df) * train_ratio) - 1].strftime('%Y-%m-%d'),
                'train_size': int(len(df) * train_ratio),
                'test_start': df['trade_date'][int(len(df) * train_ratio)].strftime('%Y-%m-%d'),
                'test_end': df['trade_date'].iloc[-1].strftime('%Y-%m-%d'),
                'test_size': len(df) - int(len(df) * train_ratio)
            }
        else:
            X_train, X_test, y_train, y_test, scaler, data, split_info = prepare_data(df, train_ratio=train_ratio)
            y_test_raw = data[60 + len(y_train):, 0]

            if model_type == 'lr':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_linear_regression(X_train, X_test,
                                                                                                     y_train, y_test,
                                                                                                     scaler, y_test_raw,
                                                                                                     params)
            elif model_type == 'rf':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_random_forest(X_train, X_test,
                                                                                                 y_train, y_test,
                                                                                                 scaler, y_test_raw,
                                                                                                 params)
            elif model_type == 'xgb':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_xgboost(X_train, X_test, y_train,
                                                                                           y_test, scaler, y_test_raw,
                                                                                           params)
            elif model_type == 'svm':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_svm(X_train, X_test, y_train, y_test,
                                                                                       scaler, y_test_raw, params)
            elif model_type == 'lstm':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_lstm(X_train, X_test, y_train,
                                                                                        y_test, scaler, y_test_raw,
                                                                                        params)
            elif model_type == 'cnn':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_cnn(X_train, X_test, y_train, y_test,
                                                                                       scaler, y_test_raw, params)
            elif model_type == 'rnn':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_rnn(X_train, X_test, y_train, y_test,
                                                                                       scaler, y_test_raw, params)
            elif model_type == 'gru':
                model, y_pred_train, y_pred_test, y_train, y_test, metrics = train_gru(X_train, X_test, y_train, y_test,
                                                                                       scaler, y_test_raw, params)

            last_sequence = scaler.transform(df['open'].values[-60:].reshape(-1, 1)).flatten()
            future_preds = predict_future(model, last_sequence, scaler, days,
                                          is_sequence_model=model_type in ['lstm', 'cnn', 'rnn', 'gru'])
            future_dates = [df['trade_date'].iloc[-1] + timedelta(days=i + 1) for i in range(days)]

        chart_json = create_forecast_chart(df, y_train, y_pred_train, y_test, y_pred_test, future_preds, future_dates)
        future_table = [{'date': date.strftime('%Y-%m-%d'), 'open': round(pred, 2)}
                        for date, pred in zip(future_dates, future_preds)]

    return render_template(
        'forecast.html',
        chart_json=chart_json,
        stock_info=stock_info,
        metrics=metrics,
        future_table=future_table,
        split_info=split_info,
        stock_options=STOCK_OPTIONS,
        default_stock=stock_code,
        default_start=start_date,
        default_end=end_date,
        default_days=days,
        default_train_ratio=train_ratio,
        model_type=model_type
    )

@app.route('/')
def index():
    return render_template('index.html')





@app.route('/candlestick', methods=['GET', 'POST'])
def candlestick():
    default_stocks = ['AAPL']
    default_end = datetime.now().strftime('%Y-%m-%d')
    default_start = (datetime.now() - timedelta(days=180)).strftime('%Y-%m-%d')

    stock_codes = default_stocks
    start_date = default_start
    end_date = default_end
    chart_json = None
    stock_infos = {}

    if request.method == 'POST':
        stock_codes = request.form.getlist('stock_codes')
        start_date = request.form.get('start_date', default_start)
        end_date = request.form.get('end_date', default_end)

    stock_data_dict = {}
    for stock_code in stock_codes:
        df = get_stock_data(stock_code, start_date, end_date)
        if df is not None and not df.empty:
            stock_data_dict[stock_code] = df
            stock_infos[stock_code] = get_stock_info(stock_code)

    if stock_data_dict:
        chart_json = create_candlestick_chart(stock_data_dict)

    return render_template(
        'candlestick.html',
        chart_json=chart_json,
        stock_infos=stock_infos,
        stock_options=STOCK_OPTIONS,
        default_stocks=stock_codes,
        default_start=start_date,
        default_end=end_date
    )


# 量化策略仿真平台（添加交易日志）
@app.route('/simulation', methods=['GET', 'POST'])
def simulation():
    default_stock = ['AAPL']
    default_start = (datetime.now() - timedelta(days=365)).strftime('%Y-%m-%d')
    default_end = datetime.now().strftime('%Y-%m-%d')
    default_cash = 100000
    default_max_holding = 100

    stock_codes = default_stock
    start_date = default_start
    end_date = default_end
    initial_cash = default_cash
    max_holding = default_max_holding
    strategy = 'macd'
    chart_json = None
    metrics = None
    trade_log = []
    error_message = None

    default_params = {
        'macd_short': 12, 'macd_long': 26, 'macd_signal': 9,
        'momentum_period': 20,
        'volume_period': 20,
        'ma_short': 10, 'ma_long': 50,
        'rsi_period': 14,
        'bb_period': 20, 'bb_std': 2
    }
    params = default_params.copy()

    if request.method == 'POST':
        logger.debug("收到仿真 POST 请求")
        stock_codes = request.form.getlist('stock_code')
        start_date = request.form.get('start_date', default_start)
        end_date = request.form.get('end_date', default_end)
        initial_cash = float(request.form.get('initial_cash', default_cash))
        max_holding = int(request.form.get('max_holding', default_max_holding))
        strategy = request.form.get('strategy', 'macd')
        params.update({
            'macd_short': request.form.get('macd_short', 12),
            'macd_long': request.form.get('macd_long', 26),
            'macd_signal': request.form.get('macd_signal', 9),
            'momentum_period': request.form.get('momentum_period', 20),
            'volume_period': request.form.get('volume_period', 20),
            'ma_short': request.form.get('ma_short', 10),
            'ma_long': request.form.get('ma_long', 50),
            'rsi_period': request.form.get('rsi_period', 14),
            'bb_period': request.form.get('bb_period', 20),
            'bb_std': request.form.get('bb_std', 2)
        })
        logger.debug(
            f"仿真参数: stock_codes={stock_codes}, start_date={start_date}, end_date={end_date}, cash={initial_cash}, max_holding={max_holding}, strategy={strategy}, params={params}")

    stock_data = get_stock_data(stock_codes, start_date, end_date, multi_stock=True)
    if stock_data and len(stock_data) > 0:
        if len(stock_codes) == 1:
            df = stock_data[stock_codes[0]]
            if strategy == 'macd':
                df, trade_log = macd_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            elif strategy == 'multi_factor':
                df, trade_log = multi_factor_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            elif strategy == 'turnover_volume':
                df, trade_log = turnover_volume_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            elif strategy == 'ma_crossover':
                df, trade_log = ma_crossover_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            elif strategy == 'rsi':
                df, trade_log = rsi_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            elif strategy == 'bollinger':
                df, trade_log = bollinger_strategy(df, initial_cash, max_holding, params, stock_codes[0])
            else:
                error_message = f"未知策略: {strategy}"
                logger.warning(error_message)

            if 'Portfolio_Value' in df.columns:
                metrics = calculate_metrics(df, initial_cash=initial_cash, mode='simulation')
                fig = go.Figure()
                fig.add_trace(go.Scatter(x=df['trade_date'], y=df['Portfolio_Value'], name='投资组合价值'))
                fig.add_trace(
                    go.Scatter(x=df['trade_date'], y=df['close'], name='收盘价', line=dict(dash='dash'), yaxis='y2'))
                fig.update_layout(
                    title=f'{stock_codes[0]} 仿真结果 - {strategy.upper()} 策略',
                    xaxis_title='日期',
                    yaxis_title='投资组合价值',
                    yaxis2=dict(title='收盘价', overlaying='y', side='right')
                )
                chart_json = fig.to_json()
            else:
                error_message = "策略执行失败，无法生成投资组合价值"
        else:
            combined_value = []
            trade_dates = None
            all_trade_logs = []
            for code, df in stock_data.items():
                if strategy == 'macd':
                    df, log = macd_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                elif strategy == 'multi_factor':
                    df, log = multi_factor_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                elif strategy == 'turnover_volume':
                    df, log = turnover_volume_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                elif strategy == 'ma_crossover':
                    df, log = ma_crossover_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                elif strategy == 'rsi':
                    df, log = rsi_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                elif strategy == 'bollinger':
                    df, log = bollinger_strategy(df, initial_cash / len(stock_data), max_holding, params, code)
                else:
                    error_message = f"未知策略: {strategy}"
                    logger.warning(error_message)
                    break
                combined_value.append(df['Portfolio_Value'])
                trade_dates = df['trade_date']
                all_trade_logs.extend(log)
            if combined_value and trade_dates is not None:
                combined_df = pd.DataFrame({
                    'trade_date': trade_dates,
                    'Portfolio_Value': np.sum(combined_value, axis=0)
                })
                metrics = calculate_metrics(combined_df, initial_cash=initial_cash, mode='simulation')
                trade_log = sorted(all_trade_logs, key=lambda x: x['date'])  # 按时间排序
                fig = go.Figure()
                fig.add_trace(
                    go.Scatter(x=combined_df['trade_date'], y=combined_df['Portfolio_Value'], name='投资组合价值'))
                for code, df in stock_data.items():
                    fig.add_trace(
                        go.Scatter(x=df['trade_date'], y=df['close'], name=f'{code} 收盘价', line=dict(dash='dash'),
                                   yaxis='y2'))
                fig.update_layout(
                    title=f'多股票仿真结果 - {strategy.upper()} 策略',
                    xaxis_title='日期',
                    yaxis_title='投资组合价值',
                    yaxis2=dict(title='收盘价', overlaying='y', side='right')
                )
                chart_json = fig.to_json()
            else:
                error_message = "多股票仿真失败，可能策略未正确执行"
    else:
        error_message = "无法获取股票数据，请检查股票代码或日期范围"

    return render_template(
        'simulation.html',
        chart_json=chart_json,
        metrics=metrics,
        trade_log=trade_log,
        stock_options=STOCK_OPTIONS,
        default_stock=stock_codes,
        default_start=start_date,
        default_end=end_date,
        default_cash=initial_cash,
        default_max_holding=max_holding,
        strategy=strategy,
        params=params,
        error_message=error_message
    )



if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)