Upload 4 files

lstm_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c857878b0e754a7034e1e5c54eb540557264a01dbf050cb11820f7bb43b7ddcc
+size 141685

model_predictor.py

@@ -4,569 +4,378 @@
 Automatically generated by Colab.
 
 Original file is located at
-    https://colab.research.google.com/drive/1CaAPRdPsp3Jt5tQ3BLVcK19euWZmFme5
+    https://colab.research.google.com/drive/1zJ1bLFePNZEiz12aSub_bWwjS4CMtnH3
 """
 
 # model_predictor.py
-# 進階LSTM模型預測器，適用於HUGING_FACE_V4.2
+# Advanced LSTM predictor for stock price forecasting, designed for HUGING_FACE_V4.2(輕量AI版).py.
+# Trains model using provided CSVs and saves lstm_model.pth, scaler_X.pkl, scaler_y.pkl for deployment.
+# Features: volume, rate, DJI, NAS, SOX, S&P_500, RSI, MACD, MACDsign, MACDvol, K, D, +DI, -DI, ADX, business_climate, PMI.
+# Targets: close prices 1, 5, 10, 20, 60 days ahead.
+# For Hugging Face deployment, upload the generated model and scaler files.
+# Prediction uses yfinance for real-time features, falling back to last CSV row if unavailable.
 
 import os
-import numpy as np
 import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.preprocessing import StandardScaler
+import pickle
+from datetime import datetime
 import yfinance as yf
-from datetime import datetime, timedelta
-import joblib
-from sklearn.preprocessing import StandardScaler, RobustScaler
-from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
-import warnings
-warnings.filterwarnings('ignore')
-
-# TensorFlow/Keras 相關
-try:
-    import tensorflow as tf
-    from tensorflow.keras.models import Sequential, load_model
-    from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization, GRU, Bidirectional
-    from tensorflow.keras.optimizers import Adam
-    from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
-    from tensorflow.keras.regularizers import l1_l2
-    print("TensorFlow 載入成功")
-except ImportError:
-    print("警告：TensorFlow 未安裝，模型將無法正常運作")
-    tf = None
-
-class AdvancedStockPredictor:
-    def __init__(self, model_name='taiwan_stock_predictor'):
-        self.model_name = model_name
-        self.model = None
-        self.scaler_X = RobustScaler()
-        self.scaler_y = StandardScaler()
-        self.sequence_length = 60  # 使用60天的歷史數據
-        self.feature_names = [
-            'volume', 'rate', 'DJI', 'NAS', 'SOX', 'SP500', 'TSM_ADR',
-            'RSI', 'MACD', 'MACDsign', 'MACDvol', 'K', 'D',
-            '+DI', '-DI', 'ADX', 'business_climate', 'PMI'
-        ]
-        self.target_names = ['close_1d', 'close_5d', 'close_10d', 'close_20d', 'close_60d']
-        self.is_trained = False
-
-    def fetch_yfinance_data(self, start_date='2022-09-12', end_date='2025-09-08'):
-        """從 yfinance 獲取所需的市場數據"""
-        print("正在從 yfinance 獲取數據...")
-
-        # 定義股票代碼
-        symbols = {
-            'TAIEX': '^TWII',      # 台股指數
-            'DJI': '^DJI',         # 道瓊工業指數
-            'NAS': '^IXIC',        # 納斯達克
-            'SOX': '^SOX',         # 費城半導體指數
-            'SP500': '^GSPC',      # 標普500
-            'TSM_ADR': 'TSM'       # 台積電ADR
-        }
-
-        data_dict = {}
-
-        for name, symbol in symbols.items():
-            try:
-                stock = yf.Ticker(symbol)
-                hist = stock.history(start=start_date, end=end_date)
-                if not hist.empty:
-                    data_dict[name] = hist
-                    print(f"成功獲取 {name} 數據: {len(hist)} 筆記錄")
-                else:
-                    print(f"警告：無法獲取 {name} 數據")
-            except Exception as e:
-                print(f"錯誤：獲取 {name} 數據時發生錯誤: {e}")
-
-        return data_dict
-
-    def load_economic_data(self):
-        """載入經濟數據檔案"""
-        economic_data = {}
-
-        # 載入景氣燈號
-        try:
-            if os.path.exists('business_climate.csv'):
-                bc_df = pd.read_csv('business_climate.csv')
-                if len(bc_df.columns) >= 2:
-                    bc_df.columns = ['Date', 'business_climate']
-                    # 統一時區處理
-                    bc_df['Date'] = pd.to_datetime(bc_df['Date'], errors='coerce').dt.tz_localize(None)
-                    bc_df = bc_df.dropna(subset=['Date'])
-                    bc_df.set_index('Date', inplace=True)
-                    economic_data['business_climate'] = bc_df
-                    print(f"成功載入景氣燈號數據: {len(bc_df)} 筆記錄")
-        except Exception as e:
-            print(f"載入景氣燈號數據時發生錯誤: {e}")
-
-        # 載入 PMI 數據
-        try:
-            if os.path.exists('taiwan_pmi.csv'):
-                pmi_df = pd.read_csv('taiwan_pmi.csv')
-                if len(pmi_df.columns) >= 2:
-                    pmi_df.columns = ['Date', 'PMI']
-                    # 統一時區處理
-                    pmi_df['Date'] = pd.to_datetime(pmi_df['Date'], errors='coerce').dt.tz_localize(None)
-                    pmi_df = pmi_df.dropna(subset=['Date'])
-                    pmi_df.set_index('Date', inplace=True)
-                    economic_data['PMI'] = pmi_df
-                    print(f"成功載入 PMI 數據: {len(pmi_df)} 筆記錄")
-        except Exception as e:
-            print(f"載入 PMI 數據時發生錯誤: {e}")
-
-        return economic_data
-
-    def calculate_technical_indicators(self, df):
-        """計算技術指標"""
-        if df.empty:
-            return df
-
-        # 確保有足夠的數據計算技術指標
-        if len(df) < 60:
-            return pd.DataFrame()
-
-        try:
-            # 基本指標
-            df['volume'] = df['Volume']
-            df['rate'] = df['Close'].pct_change()
-
-            # 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))
-
-            # MACD
-            exp1 = df['Close'].ewm(span=12).mean()
-            exp2 = df['Close'].ewm(span=26).mean()
-            df['MACD'] = exp1 - exp2
-            df['MACDsign'] = df['MACD'].ewm(span=9).mean()
-            df['MACDvol'] = df['MACD'] - df['MACDsign']
-
-            # KD 指標
-            low_min = df['Low'].rolling(window=9).min()
-            high_max = df['High'].rolling(window=9).max()
-            rsv = (df['Close'] - low_min) / (high_max - low_min) * 100
-            df['K'] = rsv.ewm(com=2).mean()
-            df['D'] = df['K'].ewm(com=2).mean()
-
-            # DMI 指標
-            df['up_move'] = df['High'] - df['High'].shift(1)
-            df['down_move'] = df['Low'].shift(1) - df['Low']
-            df['+DM'] = np.where((df['up_move'] > df['down_move']) & (df['up_move'] > 0), df['up_move'], 0)
-            df['-DM'] = np.where((df['down_move'] > df['up_move']) & (df['down_move'] > 0), df['down_move'], 0)
-            df['TR'] = np.max([df['High'] - df['Low'],
-                              abs(df['High'] - df['Close'].shift(1)),
-                              abs(df['Low'] - df['Close'].shift(1))], axis=0)
-
-            df['+DI'] = (df['+DM'].ewm(com=13).mean() / df['TR'].ewm(com=13).mean()) * 100
-            df['-DI'] = (df['-DM'].ewm(com=13).mean() / df['TR'].ewm(com=13).mean()) * 100
-            df['DX'] = abs(df['+DI'] - df['-DI']) / (df['+DI'] + df['-DI']) * 100
-            df['ADX'] = df['DX'].ewm(com=13).mean()
-
-        except Exception as e:
-            print(f"計算技術指標時發生錯誤: {e}")
-            return pd.DataFrame()
-
-        return df
-
-    def prepare_training_data(self):
-        """準備訓練數據"""
-        print("開始準備訓練數據...")
-
-        # 獲取市場數據
-        market_data = self.fetch_yfinance_data()
-        economic_data = self.load_economic_data()
-
-        if 'TAIEX' not in market_data:
-            print("錯誤：無法獲取台股指數數據")
-            return None, None
-
-        # 以台股指數為主要數據
-        main_df = market_data['TAIEX'].copy()
-        # 統一時區處理 - 移除時區資訊
-        main_df.index = main_df.index.tz_localize(None)
-
-        main_df = self.calculate_technical_indicators(main_df)
-
-        if main_df.empty:
-            print("錯誤：技術指標計算失敗")
-            return None, None
-
-        # 合併其他市場數據
-        for name, data in market_data.items():
-            if name != 'TAIEX' and not data.empty:
-                # 統一時區處理
-                data.index = data.index.tz_localize(None)
-
-                # 重新命名欄位以避免衝突
-                if name == 'DJI':
-                    main_df['DJI'] = data['Close'].reindex(main_df.index)
-                elif name == 'NAS':
-                    main_df['NAS'] = data['Close'].reindex(main_df.index)
-                elif name == 'SOX':
-                    main_df['SOX'] = data['Close'].reindex(main_df.index)
-                elif name == 'SP500':
-                    main_df['SP500'] = data['Close'].reindex(main_df.index)
-                elif name == 'TSM_ADR':
-                    main_df['TSM_ADR'] = data['Close'].reindex(main_df.index)
-
-        # 合併經濟數據
-        for name, data in economic_data.items():
-            if name == 'business_climate':
-                main_df['business_climate'] = data['business_climate'].reindex(main_df.index, method='ffill')
-            elif name == 'PMI':
-                main_df['PMI'] = data['PMI'].reindex(main_df.index, method='ffill')
-
-        # 創建未來價格標籤
-        close_prices = main_df['Close']
-        for days in [1, 5, 10, 20, 60]:
-            main_df[f'close_{days}d'] = close_prices.shift(-days)
-
-        # 選擇特徵欄位
-        feature_columns = []
-        for feature in self.feature_names:
-            if feature in main_df.columns:
-                feature_columns.append(feature)
-            else:
-                print(f"警告：特徵 {feature} 不存在，使用預���值 0")
-                main_df[feature] = 0  # 使用預設值
-                feature_columns.append(feature)
-
-        # 移除包含 NaN 的行
-        print(f"處理前數據量: {len(main_df)}")
-        main_df = main_df.dropna()
-        print(f"處理後數據量: {len(main_df)}")
-
-        if len(main_df) < self.sequence_length + 60:  # 需要足夠的數據
-            print("錯誤：數據量不足以進行訓練")
-            return None, None
-
-        # 準備特徵和標籤
-        X = main_df[feature_columns].values
-        y = main_df[self.target_names].values
-
-        print(f"數據準備完成：X shape: {X.shape}, y shape: {y.shape}")
-        return X, y
-
-    def create_sequences(self, X, y):
-        """創建時間序列序列"""
-        X_seq, y_seq = [], []
-
-        for i in range(self.sequence_length, len(X)):
-            X_seq.append(X[i-self.sequence_length:i])
-            y_seq.append(y[i])
-
-        return np.array(X_seq), np.array(y_seq)
-
-    def build_model(self, input_shape, output_shape):
-        """建立進階LSTM模型"""
-        if tf is None:
-            raise ImportError("TensorFlow 未安裝，無法建立模型")
-
-        model = Sequential([
-            # 第一層 Bidirectional LSTM
-            Bidirectional(LSTM(128, return_sequences=True, dropout=0.2, recurrent_dropout=0.2),
-                         input_shape=input_shape),
-            BatchNormalization(),
-
-            # 第二層 LSTM
-            LSTM(64, return_sequences=True, dropout=0.2, recurrent_dropout=0.2),
-            BatchNormalization(),
-
-            # 第三層 LSTM
-            LSTM(32, dropout=0.2, recurrent_dropout=0.2),
-            BatchNormalization(),
-
-            # 全連接層
-            Dense(64, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01)),
-            Dropout(0.3),
-
-            Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01)),
-            Dropout(0.2),
-
-            # 輸出層
-            Dense(output_shape, activation='linear')
-        ])
-
-        # 編譯模型
-        model.compile(
-            optimizer=Adam(learning_rate=0.001),
-            loss='huber',
-            metrics=['mae', 'mse']
-        )
-
-        return model
-
-    def train(self, epochs=100, batch_size=32, validation_split=0.2):
-        """訓練模型"""
-        print("開始訓練模型...")
-
-        # 準備數據
-        X, y = self.prepare_training_data()
-        if X is None or y is None:
-            print("錯誤：無法準備訓練數據")
-            return False
-
-        # 數據標準化
-        X_scaled = self.scaler_X.fit_transform(X)
-        y_scaled = self.scaler_y.fit_transform(y)
-
-        # 創建序列
-        X_seq, y_seq = self.create_sequences(X_scaled, y_scaled)
-
-        if len(X_seq) == 0:
-            print("錯誤：無法創建有效序列")
-            return False
-
-        print(f"訓練數據形狀：X_seq: {X_seq.shape}, y_seq: {y_seq.shape}")
-
-        # 建立模型
-        self.model = self.build_model(
-            input_shape=(X_seq.shape[1], X_seq.shape[2]),
-            output_shape=y_seq.shape[1]
-        )
-
-        print("模型架構：")
-        self.model.summary()
-
-        # 設定回調函數
-        callbacks = [
-            EarlyStopping(patience=15, restore_best_weights=True, monitor='val_loss'),
-            ReduceLROnPlateau(factor=0.5, patience=8, min_lr=0.0001, monitor='val_loss'),
-            ModelCheckpoint(f'{self.model_name}.keras', save_best_only=True, monitor='val_loss')
-        ]
-
-        # 訓練模型
-        history = self.model.fit(
-            X_seq, y_seq,
-            epochs=epochs,
-            batch_size=batch_size,
-            validation_split=validation_split,
-            callbacks=callbacks,
-            verbose=1
-        )
-
-        # 儲存模型和縮放器
-        self.save_model()
 
-        # 評估模型
-        self.evaluate_model(X_seq, y_seq, validation_split)
-
-        self.is_trained = True
-        print("模型訓練完成!")
+# Define LSTM model
+class LSTMPredictor(nn.Module):
+    def __init__(self, input_size, hidden_size=50, num_layers=2, output_size=5):
+        super(LSTMPredictor, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        if x.dim() == 2:
+            x = x.unsqueeze(1)  # (batch, 1, features)
+        out, _ = self.lstm(x)
+        out = self.fc(out[:, -1, :])
+        return out
+
+# Global variables
+model = None
+scaler_X = None
+scaler_y = None
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def load_model_and_scalers():
+    """
+    Load pre-trained model and scalers.
+    Returns True if successful, False otherwise.
+    """
+    global model, scaler_X, scaler_y
+
+    if os.path.exists('lstm_model.pth') and os.path.exists('scaler_X.pkl') and os.path.exists('scaler_y.pkl'):
+        input_size = 16  # Number of features
+        model = LSTMPredictor(input_size).to(device)
+        model.load_state_dict(torch.load('lstm_model.pth', map_location=device))
+        model.eval()
+
+        with open('scaler_X.pkl', 'rb') as f:
+            scaler_X = pickle.load(f)
+        with open('scaler_y.pkl', 'rb') as f:
+            scaler_y = pickle.load(f)
+        print("Pre-trained model and scalers loaded successfully.")
         return True
 
-    def evaluate_model(self, X_seq, y_seq, validation_split):
-        """評估模型性能"""
-        print("\n模型評估結果：")
+    print("Pre-trained files not found. Cannot predict without training.")
+    return False
 
-        # 分割數據
-        split_idx = int(len(X_seq) * (1 - validation_split))
-        X_val, y_val = X_seq[split_idx:], y_seq[split_idx:]
-
-        # 預測
-        y_pred = self.model.predict(X_val)
-
-        # 反標準化
-        y_val_orig = self.scaler_y.inverse_transform(y_val)
-        y_pred_orig = self.scaler_y.inverse_transform(y_pred)
-
-        # 計算指標
-        for i, target in enumerate(self.target_names):
-            mae = mean_absolute_error(y_val_orig[:, i], y_pred_orig[:, i])
-            mse = mean_squared_error(y_val_orig[:, i], y_pred_orig[:, i])
-            r2 = r2_score(y_val_orig[:, i], y_pred_orig[:, i])
-            print(f"{target}: MAE={mae:.2f}, MSE={mse:.2f}, R2={r2:.4f}")
-
-    def save_model(self):
-        """儲存模型和縮放器"""
-        try:
-            if self.model is not None:
-                self.model.save(f'{self.model_name}.keras')
-                print(f"模型已儲存: {self.model_name}.keras")
+def prepare_data_from_csvs():
+    """
+    Prepare training data from CSVs.
+    Date range: 2022-09-12 to 2025-09-08.
+    Handles PMI column conflict by renaming PMI from taiwan_pmi.csv.
+    """
+    # Read main data
+    if not os.path.exists('新期末專案輸入資料20220912-20250909.csv'):
+        raise FileNotFoundError("Main CSV file not found. Please upload '新期末專案輸入資料20220912-20250909.csv'.")
+
+    main_data = pd.read_csv('新期末專案輸入資料20220912-20250909.csv', parse_dates=['date'])
+    start_date = pd.to_datetime('20220912')
+    end_date = pd.to_datetime('20250908')
+    main_data = main_data[(main_data['date'] >= start_date) & (main_data['date'] <= end_date)].copy()
+    main_data.set_index('date', inplace=True)
+    main_data.sort_index(inplace=True)
+
+    # Read business_climate
+    if not os.path.exists('business_climate.csv'):
+        raise FileNotFoundError("business_climate.csv not found.")
+    business_climate = pd.read_csv('business_climate.csv')
+    business_climate['Date'] = pd.to_datetime(business_climate['Date'] + '-01')
+    business_climate.set_index('Date', inplace=True)
+    business_climate.sort_index(inplace=True)
+
+    # Read PMI and rename to avoid conflict
+    if not os.path.exists('taiwan_pmi.csv'):
+        raise FileNotFoundError("taiwan_pmi.csv not found.")
+    taiwan_pmi = pd.read_csv('taiwan_pmi.csv')
+    taiwan_pmi['DATE'] = pd.to_datetime(taiwan_pmi['DATE'] + '-01')
+    taiwan_pmi.set_index('DATE', inplace=True)
+    taiwan_pmi.rename(columns={'INDEX': 'PMI_external'}, inplace=True)  # Rename to avoid conflict
+    taiwan_pmi.sort_index(inplace=True)
+
+    # Merge
+    main_data = main_data.join(business_climate, how='left')
+    main_data = main_data.join(taiwan_pmi['PMI_external'], how='left')
+
+    # Fill missing values
+    main_data['business_climate'] = main_data['business_climate'].fillna(method='ffill').fillna(method='bfill').fillna(main_data['business_climate'].mean())
+    main_data['PMI_external'] = main_data['PMI_external'].fillna(method='ffill').fillna(method='bfill').fillna(main_data['PMI_external'].mean())
+
+    # Drop TSM_ADR if empty
+    if 'TSM_ADR' in main_data.columns:
+        main_data.drop(columns=['TSM_ADR'], inplace=True)
+
+    # Feature columns (use PMI from main_data)
+    feature_columns = ['volume', 'rate', 'DJI', 'NAS', 'SOX', 'S&P_500', 'RSI', 'MACD', 'MACDsign', 'MACDvol', 'K', 'D', '+DI', '-DI', 'ADX', 'business_climate', 'PMI']
+
+    # Remove rows with NaN in features or close
+    main_data = main_data.dropna(subset=feature_columns + ['close'])
+
+    # Create targets
+    for days in [1, 5, 10, 20, 60]:
+        main_data[f'close_{days}d'] = main_data['close'].shift(-days)
+
+    # Remove rows where targets are NaN
+    main_data = main_data[:-60]
+
+    # X and y
+    X = main_data[feature_columns].values.astype(np.float32)
+    y = main_data[[f'close_{days}d' for days in [1, 5, 10, 20, 60]]].values.astype(np.float32)
+
+    return X, y, feature_columns
 
-            joblib.dump(self.scaler_X, f'{self.model_name}_scaler_X.pkl')
-            joblib.dump(self.scaler_y, f'{self.model_name}_scaler_y.pkl')
-            print("縮放器已儲存")
+def train_model():
+    """
+    Train LSTM model and save model/scalers.
+    Returns True if successful.
+    """
+    global model, scaler_X, scaler_y
 
-        except Exception as e:
-            print(f"儲存模型時發生錯誤: {e}")
+    try:
+        X, y, feature_columns = prepare_data_from_csvs()
+
+        # Scale
+        scaler_X = StandardScaler()
+        scaler_y = StandardScaler()
+        X_scaled = scaler_X.fit_transform(X)
+        y_scaled = scaler_y.fit_transform(y)
+
+        # Save scalers
+        with open('scaler_X.pkl', 'wb') as f:
+            pickle.dump(scaler_X, f)
+        with open('scaler_y.pkl', 'wb') as f:
+            pickle.dump(scaler_y, f)
+
+        # To tensors
+        X_tensor = torch.tensor(X_scaled, dtype=torch.float32)
+        y_tensor = torch.tensor(y_scaled, dtype=torch.float32)
+
+        # Dataset and loaders
+        from torch.utils.data import TensorDataset, DataLoader
+        from sklearn.model_selection import train_test_split
+
+        dataset = TensorDataset(X_tensor, y_tensor)
+        train_size = int(0.8 * len(dataset))
+        val_size = len(dataset) - train_size
+        train_dataset, val_dataset = torch.utils.data.random_split(dataset, [train_size, val_size])
+
+        train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
+
+        # Model
+        input_size = X.shape[1]
+        model = LSTMPredictor(input_size).to(device)
+
+        # Loss and optimizer
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+        # Train
+        num_epochs = 50
+        for epoch in range(num_epochs):
+            model.train()
+            train_loss = 0.0
+            for batch_X, batch_y in train_loader:
+                batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                optimizer.zero_grad()
+                outputs = model(batch_X)
+                loss = criterion(outputs, batch_y)
+                loss.backward()
+                optimizer.step()
+                train_loss += loss.item() * batch_X.size(0)
+
+            train_loss /= len(train_dataset)
+
+            # Validation
+            model.eval()
+            val_loss = 0.0
+            with torch.no_grad():
+                for batch_X, batch_y in val_loader:
+                    batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                    outputs = model(batch_X)
+                    loss = criterion(outputs, batch_y)
+                    val_loss += loss.item() * batch_X.size(0)
+
+            val_loss /= len(val_dataset)
+
+            if (epoch + 1) % 10 == 0:
+                print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')
+
+        # Save model
+        torch.save(model.state_dict(), 'lstm_model.pth')
 
-    def load_model(self):
-        """載入已訓練的模型"""
-        try:
-            if tf is not None and os.path.exists(f'{self.model_name}.keras'):
-                self.model = load_model(f'{self.model_name}.keras')
-                print("模型載入成功")
+        return True
 
-            if os.path.exists(f'{self.model_name}_scaler_X.pkl'):
-                self.scaler_X = joblib.load(f'{self.model_name}_scaler_X.pkl')
-                print("X 縮放器載入成功")
+    except Exception as e:
+        print(f"Training error: {e}")
+        return False
 
-            if os.path.exists(f'{self.model_name}_scaler_y.pkl'):
-                self.scaler_y = joblib.load(f'{self.model_name}_scaler_y.pkl')
-                print("y 縮放器載入成功")
+def get_current_features():
+    """
+    Fetch current features for prediction using yfinance.
+    Fallback to last row of CSV if yfinance fails.
+    business_climate and PMI from CSVs.
+    """
+    feature_columns = ['volume', 'rate', 'DJI', 'NAS', 'SOX', 'S&P_500', 'RSI', 'MACD', 'MACDsign', 'MACDvol', 'K', 'D', '+DI', '-DI', 'ADX', 'business_climate', 'PMI']
 
-            self.is_trained = True
-            return True
+    try:
+        # Fetch indices
+        tickers = {'DJI': '^DJI', 'NAS': '^IXIC', 'SOX': '^SOX', 'S&P_500': '^GSPC'}
+        data = {}
+        for key, ticker in tickers.items():
+            stock = yf.Ticker(ticker)
+            hist = stock.history(period='1d')
+            if not hist.empty:
+                data[key] = hist['Close'].iloc[-1]
+            else:
+                raise Exception(f"Failed to fetch {key}")
+
+        # Assume rate is constant or from last CSV (not provided in yfinance)
+        main_data = pd.read_csv('新期末專案輸入資料20220912-20250909.csv', parse_dates=['date'])
+        last_row = main_data.iloc[-1]
+        rate = last_row['rate']
+
+        # Volume and technical indicators from ^TWII
+        twii = yf.Ticker('^TWII')
+        hist = twii.history(period='60d')
+        if hist.empty:
+            raise Exception("Failed to fetch ^TWII")
+
+        hist['MA5'] = hist['Close'].rolling(window=5).mean()
+        hist['MA20'] = hist['Close'].rolling(window=20).mean()
+        delta = hist['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
+        rsi = 100 - (100 / (1 + rs))
+        exp1 = hist['Close'].ewm(span=12).mean()
+        exp2 = hist['Close'].ewm(span=26).mean()
+        macd = exp1 - exp2
+        macd_signal = macd.ewm(span=9).mean()
+        macd_hist = macd - macd_signal
+        low_min = hist['Low'].rolling(window=9).min()
+        high_max = hist['High'].rolling(window=9).max()
+        rsv = (hist['Close'] - low_min) / (high_max - low_min) * 100
+        k = rsv.ewm(com=2).mean()
+        d = k.ewm(com=2).mean()
+        up_move = hist['High'] - hist['High'].shift(1)
+        down_move = hist['Low'].shift(1) - hist['Low']
+        plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)
+        minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)
+        tr = np.max([hist['High'] - hist['Low'], abs(hist['High'] - hist['Close'].shift(1)), abs(hist['Low'] - hist['Close'].shift(1))], axis=0)
+        plus_di = (pd.Series(plus_dm).ewm(com=13, adjust=False).mean() / pd.Series(tr).ewm(com=13, adjust=False).mean()) * 100
+        minus_di = (pd.Series(minus_dm).ewm(com=13, adjust=False).mean() / pd.Series(tr).ewm(com=13, adjust=False).mean()) * 100
+        dx = abs(plus_di - minus_di) / (plus_di + minus_di) * 100
+        adx = dx.ewm(com=13, adjust=False).mean()
+
+        # Latest values
+        volume = hist['Volume'].iloc[-1]
+        rsi = rsi.iloc[-1]
+        macd = macd.iloc[-1]
+        macd_signal = macd_signal.iloc[-1]
+        macd_vol = macd_hist.iloc[-1]
+        k = k.iloc[-1]
+        d = d.iloc[-1]
+        plus_di = plus_di.iloc[-1]
+        minus_di = minus_di.iloc[-1]
+        adx = adx.iloc[-1]
+
+        # business_climate and PMI from CSVs
+        business_climate = pd.read_csv('business_climate.csv')
+        pmi = pd.read_csv('taiwan_pmi.csv')
+        last_bc = business_climate['Index'].iloc[-1]
+        last_pmi = pmi['INDEX'].iloc[-1]
+
+        features = [
+            volume, rate, data['DJI'], data['NAS'], data['SOX'], data['S&P_500'],
+            rsi, macd, macd_signal, macd_vol, k, d, plus_di, minus_di, adx,
+            last_bc, last_pmi
+        ]
 
-        except Exception as e:
-            print(f"載入模型時發生錯誤: {e}")
-            return False
+        return np.array(features).reshape(1, -1).astype(np.float32)
 
-    def predict(self, predict_days=5):
-        """進行預測"""
-        if not self.is_trained and not self.load_model():
-            print("錯誤：模型未訓練且無法載入已訓練的模型")
-            return None
+    except Exception as e:
+        print(f"yfinance fetch failed: {e}. Using last CSV row.")
+        main_data = pd.read_csv('新期末專案輸入資料20220912-20250909.csv', parse_dates=['date'])
+        last_row = main_data.iloc[-1]
+        business_climate = pd.read_csv('business_climate.csv')
+        pmi = pd.read_csv('taiwan_pmi.csv')
+        last_bc = business_climate['Index'].iloc[-1]
+        last_pmi = pmi['INDEX'].iloc[-1]
+
+        features = [
+            last_row['volume'], last_row['rate'], last_row['DJI'], last_row['NAS'], last_row['SOX'],
+            last_row['S&P_500'], last_row['RSI'], last_row['MACD'], last_row['MACDsign'],
+            last_row['MACDvol'], last_row['K'], last_row['D'], last_row['+DI'], last_row['-DI'],
+            last_row['ADX'], last_bc, last_pmi
+        ]
 
-        if self.model is None:
-            print("錯誤：模型未載入")
-            return None
+        return np.array(features).reshape(1, -1).astype(np.float32)
 
-        try:
-            # 獲取最新數據
-            print("正在獲取最新數據進行預測...")
-            market_data = self.fetch_yfinance_data(
-                start_date=(datetime.now() - timedelta(days=120)).strftime('%Y-%m-%d'),
-                end_date=datetime.now().strftime('%Y-%m-%d')
-            )
-            economic_data = self.load_economic_data()
-
-            if 'TAIEX' not in market_data:
-                print("錯誤：無法獲取最新台股數據")
-                return None
-
-            # 處理數據（與訓練時相同的流程）
-            main_df = market_data['TAIEX'].copy()
-            # 統一時區處理
-            main_df.index = main_df.index.tz_localize(None)
-
-            main_df = self.calculate_technical_indicators(main_df)
-
-            if main_df.empty or len(main_df) < self.sequence_length:
-                print("錯誤：數據不足以進行預測")
-                return None
-
-            # 合併其他數據
-            for name, data in market_data.items():
-                if name != 'TAIEX' and not data.empty:
-                    # 統一時區處理
-                    data.index = data.index.tz_localize(None)
-
-                    if name == 'DJI':
-                        main_df['DJI'] = data['Close'].reindex(main_df.index)
-                    elif name == 'NAS':
-                        main_df['NAS'] = data['Close'].reindex(main_df.index)
-                    elif name == 'SOX':
-                        main_df['SOX'] = data['Close'].reindex(main_df.index)
-                    elif name == 'SP500':
-                        main_df['SP500'] = data['Close'].reindex(main_df.index)
-                    elif name == 'TSM_ADR':
-                        main_df['TSM_ADR'] = data['Close'].reindex(main_df.index)
-
-            for name, data in economic_data.items():
-                if name == 'business_climate':
-                    main_df['business_climate'] = data['business_climate'].reindex(main_df.index, method='ffill')
-                elif name == 'PMI':
-                    main_df['PMI'] = data['PMI'].reindex(main_df.index, method='ffill')
-
-            # 填充缺失特徵
-            for feature in self.feature_names:
-                if feature not in main_df.columns:
-                    main_df[feature] = 0
-
-            # 使用 fillna 替代已棄用的 method 參數
-            main_df = main_df.fillna(method='ffill').fillna(0)
-
-            # 準備預測數據
-            X = main_df[self.feature_names].values
-            if len(X) < self.sequence_length:
-                print("錯誤：歷史數據不足")
-                return None
-
-            # 使用最後的sequence_length天數據
-            X_recent = X[-self.sequence_length:]
-            X_scaled = self.scaler_X.transform(X_recent.reshape(1, -1))
-            X_scaled = X_scaled.reshape(1, self.sequence_length, -1)
-
-            # 進行預測
-            y_pred_scaled = self.model.predict(X_scaled)
-            y_pred = self.scaler_y.inverse_transform(y_pred_scaled)
-
-            # 獲取當前價格
-            current_price = main_df['Close'].iloc[-1]
-
-            # 根據預測天數選擇對應的預測值
-            day_mapping = {1: 0, 5: 1, 10: 2, 20: 3, 60: 4}
-
-            if predict_days in day_mapping:
-                predicted_price = y_pred[0][day_mapping[predict_days]]
-                change_pct = ((predicted_price - current_price) / current_price) * 100
-
-                # 計算信心度（簡化版本）
-                confidence = min(0.9, max(0.6, 1 - abs(change_pct) / 100))
-
-                result = {
-                    'predicted_price': float(predicted_price),
-                    'change_pct': float(change_pct),
-                    'confidence': float(confidence),
-                    'current_price': float(current_price),
-                    'prediction_days': predict_days
-                }
-
-                print(f"預測結果：{predict_days}天後價格 = {predicted_price:.2f}, 變化 = {change_pct:+.2f}%")
-                return result
-            else:
-                print(f"不支援的預測天數：{predict_days}")
-                return None
+def advanced_lstm_predict(predict_days=5):
+    """
+    Predict stock closes for 1, 5, 10, 20, 60 days ahead.
+    Returns dict with predicted_price, change_pct, confidence for specified horizon.
+    Includes all_predictions for compatibility.
+    """
+    global model, scaler_X, scaler_y
 
-        except Exception as e:
-            print(f"預測時發生錯誤: {e}")
+    if model is None or scaler_X is None or scaler_y is None:
+        if not load_model_and_scalers():
             return None
 
-# 全域預測器實例
-_predictor = None
+    try:
+        current_features = get_current_features()
+        current_scaled = scaler_X.transform(current_features)
+        current_tensor = torch.tensor(current_scaled, dtype=torch.float32).to(device)
 
-def get_predictor():
-    """獲取全域預測器實例"""
-    global _predictor
-    if _predictor is None:
-        _predictor = AdvancedStockPredictor()
-    return _predictor
+        model.eval()
+        with torch.no_grad():
+            pred_scaled = model(current_tensor)
 
-def advanced_lstm_predict(predict_days=5):
-    """
-    供 HUGING_FACE_V4.2 調用的預測函數
+        pred = scaler_y.inverse_transform(pred_scaled.cpu().numpy())
 
-    Args:
-        predict_days (int): 預測天數 (1, 5, 10, 20, 60)
+        # Current close from ^TWII or last CSV
+        try:
+            twii = yf.Ticker('^TWII')
+            current_close = twii.history(period='1d')['Close'].iloc[-1]
+        except:
+            main_data = pd.read_csv('新期末專案輸入資料20220912-20250909.csv')
+            current_close = main_data['close'].iloc[-1]
+
+        horizons = [1, 5, 10, 20, 60]
+        predictions = {}
+        for i, days in enumerate(horizons):
+            pred_price = pred[0, i]
+            change_pct = ((pred_price - current_close) / current_close) * 100
+            predictions[f'{days}d'] = {
+                'predicted_price': pred_price,
+                'change_pct': change_pct,
+                'confidence': 0.8  # Placeholder
+            }
+
+        selected = predictions.get(f'{predict_days}d', predictions['1d'])
+        selected['all_predictions'] = predictions
+
+        return selected
 
-    Returns:
-        dict or None: 預測結果字典，包含 predicted_price, change_pct, confidence
-    """
-    try:
-        predictor = get_predictor()
-        return predictor.predict(predict_days)
     except Exception as e:
-        print(f"advanced_lstm_predict 錯誤: {e}")
+        print(f"Prediction error: {e}")
         return None
 
-def train_model():
-    """
-    訓練模型的主函數
-    """
-    print("開始訓練進階LSTM模型...")
-    predictor = AdvancedStockPredictor()
-
-    if predictor.train(epochs=50, batch_size=16):
-        print("模型訓練成功！")
-        return True
+# Train and save model/scalers for deployment
+if __name__ == '__main__':
+    print("Training model...")
+    if train_model():
+        print("Model and scalers saved successfully.")
     else:
-        print("模型訓練失敗！")
-        return False
-
-if __name__ == "__main__":
-    # 直接執行時進行模型訓練
-    train_model()
+        print("Training failed.")

scaler_X.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfa2a7e0e256257525b7949a92aa59e2385d01f65afe1431441c73bff85098a3
+size 858

scaler_y.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fdd5b70d72852c4486dcc93c276dd3975ea81a98fbc54095bac900631fc418b
+size 570