Update src

app.py

@@ -0,0 +1,100 @@
+import gradio as gr
+import plotly.graph_objects as go
+from inference import predict_next_day
+
+def generate_dashboard(ticker, model_name):
+    try:
+        preds, last_close, last_date, hist_30 = predict_next_day(ticker, model_name)
+    except Exception as e:
+        return f"<h3 style='color:red;'>Lỗi: {str(e)}</h3>", None
+    
+    # Bóc tách kết quả cho việc hiển thị HTML/Markdown
+    display_model = "SVR" if model_name == "SVR" else "Linear Regression"
+    main_pred = preds[display_model]
+    
+    pct_change = main_pred['pred_return'] * 100
+    recommendation = "TĂNG 📈" if pct_change > 0 else "GIẢM 📉"
+    color = "green" if pct_change > 0 else "red"
+    
+    html_stats = f"""
+    <div style="display: flex; gap: 20px; justify-content: space-around; text-align: center; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
+        <div>
+            <p style="margin:0; font-size: 16px; color: gray;">Last Close ({last_date})</p>
+            <h2 style="margin:0; color: black;">${last_close:.2f}</h2>
+        </div>
+        <div>
+            <p style="margin:0; font-size: 16px; color: gray;">Dự đoán ngày mai ({display_model})</p>
+            <h2 style="margin:0; color: {color};">${main_pred['pred_price']:.2f}</h2>
+        </div>
+        <div>
+            <p style="margin:0; font-size: 16px; color: gray;">Tỷ lệ biến động</p>
+            <h2 style="margin:0; color: {color};">{pct_change:+.2f}%</h2>
+        </div>
+        <div>
+            <p style="margin:0; font-size: 16px; color: gray;">Khuyến nghị</p>
+            <h2 style="margin:0; color: {color}; font-weight: bold;">{recommendation}</h2>
+        </div>
+    </div>
+    """
+
+    # --- Vẽ biểu đồ Plotly ---
+    fig = go.Figure()
+    
+    # 1. Đường giá thực tế
+    fig.add_trace(go.Scatter(
+        x=hist_30['Date'], y=hist_30['Close'],
+        mode='lines+markers', name='Thực tế', line=dict(color='blue')
+    ))
+
+    # Xử lý điểm dự đoán cho ngày mai (tạm gọi là last_date + 1 Business day)
+    import pandas as pd
+    next_day = pd.to_datetime(last_date) + pd.offsets.BDay(1)
+    
+    # 2. Vẽ marker nổi bật từ điểm cuối
+    if model_name in ["Linear Regression", "Cả Hai"]:
+        fig.add_trace(go.Scatter(
+            x=[hist_30['Date'].iloc[-1], next_day],
+            y=[last_close, preds["Linear Regression"]['pred_price']],
+            mode='lines+markers', name='Dự đoán LR',
+            line=dict(color='orange', dash='dash'),
+            marker=dict(size=12, symbol='star')
+        ))
+        
+    if model_name in ["SVR", "Cả Hai"]:
+        fig.add_trace(go.Scatter(
+            x=[hist_30['Date'].iloc[-1], next_day],
+            y=[last_close, preds["SVR"]['pred_price']],
+            mode='lines+markers', name='Dự đoán SVR',
+            line=dict(color='purple', dash='dash'),
+            marker=dict(size=12, symbol='star')
+        ))
+
+    fig.update_layout(title=f"Lịch sử 30 phiên và Dự báo {ticker}",
+                      xaxis_title="Thời gian",
+                      yaxis_title="Giá (USD)",
+                      template="plotly_white")
+
+    return html_stats, fig
+
+# --- Giao diện Gradio ---
+with gr.Blocks(title="Stock Prediction Machine Learning") as demo:
+    gr.Markdown("# 📈 Hệ thống Dự báo Giá Cổ phiếu với Machine Learning")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            ticker_dd = gr.Dropdown(choices=["AAPL", "MSFT", "GOOGL", "AMZN"], value="AAPL", label="Chọn Mã cổ phiếu (Ticker)")
+            model_dd = gr.Dropdown(choices=["SVR", "Linear Regression", "Cả Hai"], value="Cả Hai", label="Chọn Mô hình")
+            btn_predict = gr.Button("Dự đoán phiên tiếp theo", variant="primary")
+            
+        with gr.Column(scale=3):
+            stats_html = gr.HTML()
+            plot_chart = gr.Plot()
+
+    btn_predict.click(
+        fn=generate_dashboard,
+        inputs=[ticker_dd, model_dd],
+        outputs=[stats_html, plot_chart]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,9 @@
+pandas
+numpy
+yfinance
+scikit-learn
+optuna
+joblib
+huggingface-hub
+gradio
+plotly

src/data_processing.py

@@ -0,0 +1,135 @@
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import warnings
+
+warnings.filterwarnings('ignore')
+
+SMA_WINDOWS = [5, 10, 20, 50, 100]
+EMA_WINDOWS = [5, 10, 20, 50]
+RSI_WINDOWS = [7, 14, 21]
+BB_WINDOWS = [10, 20, 50]
+ATR_WINDOWS = [14, 20]
+VOL_WINDOWS = [20, 50]
+LAGS = 3
+
+def load_data(symbols, market_symbol, start_date, end_date):
+    print(f"Downloading data from {start_date} to {end_date}...")
+    df_market = yf.download(market_symbol, start=start_date, end=end_date, auto_adjust=True, progress=False)
+    if isinstance(df_market.columns, pd.MultiIndex):
+        df_market.columns = df_market.columns.droplevel(1)
+    
+    df_market = df_market.reset_index()[['Date', 'Close']].rename(columns={'Close': 'Market_Close'})
+    dfs = []
+    
+    for symbol in symbols:
+        try:
+            df = yf.download(symbol, start=start_date, end=end_date, auto_adjust=True, progress=False)
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.droplevel(1)
+            df = df.reset_index()[['Date', 'Open', 'High', 'Low', 'Close', 'Volume']]
+            df['Ticker'] = symbol
+            df = pd.merge(df, df_market, on='Date', how='left')
+            dfs.append(df)
+        except Exception as e:
+            print(f"Lỗi khi tải dữ liệu {symbol}: {e}")
+
+    df_concat = pd.concat(dfs, ignore_index=True)
+    df_concat = df_concat.sort_values(['Ticker', 'Date']).reset_index(drop=True)
+    return df_concat
+
+def clean_data(df):
+    cleaned_dfs = []
+    for ticker, group in df.groupby('Ticker'):
+        group = group.set_index('Date').sort_index()
+        start_dt, end_dt = group.index.min(), group.index.max()
+        all_business_days = pd.date_range(start=start_dt, end=end_dt, freq="B")
+        group = group.reindex(all_business_days).ffill().reset_index().rename(columns={'index': 'Date'})
+        group['Ticker'] = ticker
+        cleaned_dfs.append(group)
+    
+    df_cleaned = pd.concat(cleaned_dfs, ignore_index=True).sort_values(['Ticker', 'Date']).reset_index(drop=True)
+    return df_cleaned
+
+def validate_data(df, stage="pre_feature"):
+    num_cols = df.select_dtypes(include=[np.number]).columns
+    if df[num_cols].isna().sum().sum() > 0:
+        print(f"WARNING: Có NaN values tại {stage}")
+    return df
+
+def generate_technical_features(df, is_inference=False):
+    data = df.copy()
+
+    def add_features(group):
+        g = group.copy()
+        g['Daily_Return'] = g['Close'].pct_change()
+        g['Log_Return'] = np.log(1 + g['Daily_Return'])
+        g['Market_Return'] = g['Market_Close'].pct_change()
+        g['Market_Log_Return'] = np.log(1 + g['Market_Return'])
+    
+        for i in range(1, LAGS + 1):
+            g[f'Return_Lag_{i}'] = g['Daily_Return'].shift(i)
+            g[f'Market_Return_Lag_{i}'] = g['Market_Return'].shift(i)
+    
+        for w in SMA_WINDOWS:
+            sma = g['Close'].rolling(window=w).mean()
+            g[f'SMA_{w}_Ratio'] = g['Close'] / sma
+            g[f'SMA_{w}_Distance_pct'] = (g['Close'] - sma) / sma * 100
+        
+        for w in EMA_WINDOWS:
+            ema = g['Close'].ewm(span=w, adjust=False).mean()
+            g[f'EMA_{w}_Ratio'] = g['Close'] / ema
+            g[f'EMA_{w}_Distance_pct'] = (g['Close'] - ema) / ema * 100
+    
+        for w in RSI_WINDOWS:
+            delta = g['Close'].diff()
+            gain = delta.where(delta > 0, 0).rolling(w).mean()
+            loss = -delta.where(delta < 0, 0).rolling(w).mean()
+            rs = gain / loss
+            g[f'RSI_{w}'] = 100 - (100 / (1 + rs))
+    
+        ema_fast = g['Close'].ewm(span=12, adjust=False).mean()
+        ema_slow = g['Close'].ewm(span=26, adjust=False).mean()
+        g['MACD_Line'] = ema_fast - ema_slow
+        g['MACD_Signal'] = g['MACD_Line'].ewm(span=9, adjust=False).mean()
+        g['MACD_Hist'] = (g['MACD_Line'] - g['MACD_Signal'])
+        g['MACD_Hist_Normalized'] = g['MACD_Hist'] / g['Close'] * 100
+    
+        for w in BB_WINDOWS:
+            middle = g['Close'].rolling(w).mean()
+            std_dev = g['Close'].rolling(w).std()
+            bb_range = (middle + 2 * std_dev) - (middle - 2 * std_dev)
+            g[f'BB_Width_{w}_pct'] = (bb_range / middle * 100)
+            g[f'BB_Position_{w}'] = (g['Close'] - (middle - 2 * std_dev)) / bb_range.where(bb_range > 0, 1)
+        
+        tr = pd.concat([g['High'] - g['Low'], 
+                        abs(g['High'] - g['Close'].shift(1)), 
+                        abs(g['Low'] - g['Close'].shift(1))], axis=1).max(axis=1)
+        
+        for w in ATR_WINDOWS:
+            atr = tr.rolling(w).mean()
+            g[f'ATR_Normalized_{w}'] = atr / g['Close']
+            g[f'ATR_{w}'] = atr
+        
+        for w in VOL_WINDOWS:
+            g[f'Market_Rolling_Vol_{w}'] = g['Market_Return'].rolling(w).std()
+            g[f'AAPL_Rolling_Vol_{w}'] = g['Daily_Return'].rolling(w).std()
+        
+        g['Rel_Volume_20'] = g['Volume'] / g['Volume'].rolling(20).mean()
+        return g
+        
+    data_list = [add_features(group) for _, group in data.groupby('Ticker')]
+    data = pd.concat(data_list, ignore_index=True)
+    
+    if not is_inference:
+        data['Target_Return'] = data.groupby('Ticker')['Daily_Return'].shift(-1)
+        data = data.dropna().reset_index(drop=True)
+        data = validate_data(data, stage="post_feature")
+        X = data.drop(columns=['Date', 'Ticker', 'Market_Close', 'Target_Return'], errors='ignore')
+        y = data['Target_Return']
+        return data, X, y
+    else:
+        # Nếu là predict, dòng cuối cùng của mỗi ticker sẽ chứa feature đầy đủ và không bị loại bỏ do thiếu target
+        data = data.dropna().reset_index(drop=True)
+        X = data.drop(columns=['Date', 'Ticker', 'Market_Close'], errors='ignore')
+        return data, X, None

src/inference.py

@@ -0,0 +1,61 @@
+import os
+import joblib
+import pandas as pd
+from datetime import datetime, timedelta
+from huggingface_hub import hf_hub_download
+from data_processing import load_data, clean_data, generate_technical_features
+
+REPO_ID = "Reality8081/Predict_Stock_SVR_Linear" # << THAY ĐỔI DÒNG NÀY TƯƠNG TỰ
+MARKET_SYMBOL = "^GSPC"
+
+# Tự động tải models từ Hugging Face nếu chưa có tại local
+def download_model_if_not_exists(filename):
+    local_path = os.path.join("models", filename)
+    if not os.path.exists(local_path):
+        os.makedirs("models", exist_ok=True)
+        path = hf_hub_download(repo_id=REPO_ID, filename=filename, local_dir="models")
+        return path
+    return local_path
+
+def predict_next_day(ticker, model_name):
+    # Lấy data 150 ngày gần nhất để tính đủ các window (SMA 100 cần ít nhất 100 nến)
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=150)
+    
+    df_raw = load_data([ticker], MARKET_SYMBOL, start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d'))
+    df_clean = clean_data(df_raw)
+    df_features, X, _ = generate_technical_features(df_clean, is_inference=True)
+    
+    if len(X) == 0:
+        raise ValueError(f"Không đủ dữ liệu cho {ticker} để tạo đặc trưng.")
+
+    # Lấy dòng cuối cùng (ngày giao dịch gần nhất)
+    latest_X = X.iloc[[-1]]
+    latest_data = df_features.iloc[-1]
+    last_close = latest_data['Close']
+    last_date = latest_data['Date'].strftime('%Y-%m-%d')
+    
+    predictions = {}
+    
+    if model_name in ["Linear Regression", "Cả Hai"]:
+        scaler_lr = joblib.load(download_model_if_not_exists('scaler_lr.pkl'))
+        model_lr = joblib.load(download_model_if_not_exists('model_lr.pkl'))
+        pred_return_lr = model_lr.predict(scaler_lr.transform(latest_X))[0]
+        predictions["Linear Regression"] = {
+            "pred_return": pred_return_lr,
+            "pred_price": last_close * (1 + pred_return_lr)
+        }
+        
+    if model_name in ["SVR", "Cả Hai"]:
+        scaler_svr = joblib.load(download_model_if_not_exists('scaler_svr.pkl'))
+        model_svr = joblib.load(download_model_if_not_exists('model_svr.pkl'))
+        pred_return_svr = model_svr.predict(scaler_svr.transform(latest_X))[0]
+        predictions["SVR"] = {
+            "pred_return": pred_return_svr,
+            "pred_price": last_close * (1 + pred_return_svr)
+        }
+
+    # Lịch sử giá 30 phiên để vẽ biểu đồ
+    historical_30 = df_features[['Date', 'Close']].tail(30)
+    
+    return predictions, last_close, last_date, historical_30

src/train.py

@@ -0,0 +1,113 @@
+import os
+import joblib
+import optuna
+import numpy as np
+from datetime import datetime
+from sklearn.svm import SVR
+from sklearn.linear_model import Ridge
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import TimeSeriesSplit
+from huggingface_hub import HfApi
+
+from data_processing import load_data, clean_data, generate_technical_features
+
+SYMBOLS = ["AAPL", 'MSFT', 'GOOGL', 'AMZN']
+MARKET_SYMBOL = "^GSPC"
+START_DATE = "2010-01-01"
+END_DATE = datetime.now().strftime('%Y-%m-%d')
+REPO_ID = "Reality8081/Predict_Stock_SVR_Linear" # << THAY ĐỔI DÒNG NÀY
+
+def main():
+    print("1. Đang tải và làm sạch dữ liệu...")
+    df_raw = load_data(SYMBOLS, MARKET_SYMBOL, START_DATE, END_DATE)
+    df_clean = clean_data(df_raw)
+    
+    print("2. Tạo đặc trưng (Features)...")
+    _, X, y = generate_technical_features(df_clean, is_inference=False)
+    
+    tscv = TimeSeriesSplit(n_splits=5)
+    
+    # === TỐI ƯU LINEAR REGRESSION (RIDGE) ===
+    print("3. Tối ưu siêu tham số Ridge Regression...")
+    def objective_lr(trial):
+        alpha = trial.suggest_float('alpha', 1e-4, 1e4, log=True)
+        fold_scores = []
+        for train_idx, val_idx in tscv.split(X):
+            X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
+            y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]
+            
+            scaler = StandardScaler()
+            X_train_scaled = scaler.fit_transform(X_train)
+            X_val_scaled = scaler.transform(X_val)
+            
+            model = Ridge(alpha=alpha, random_state=42)
+            model.fit(X_train_scaled, y_train)
+            preds = model.predict(X_val_scaled)
+            fold_scores.append(np.sqrt(mean_squared_error(y_val, preds)))
+        return np.mean(fold_scores)
+
+    study_lr = optuna.create_study(direction='minimize')
+    study_lr.optimize(objective_lr, n_trials=20)
+    best_alpha = study_lr.best_params['alpha']
+
+    # === TỐI ƯU SVR ===
+    print("4. Tối ưu siêu tham số SVR...")
+    def objective_svr(trial):
+        C = trial.suggest_float('C', 1e-3, 10.0, log=True)
+        epsilon = trial.suggest_float('epsilon', 1e-3, 1.0, log=True)
+        fold_scores = []
+        for train_idx, val_idx in tscv.split(X):
+            X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
+            y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]
+            
+            scaler = StandardScaler()
+            X_train_scaled = scaler.fit_transform(X_train)
+            X_val_scaled = scaler.transform(X_val)
+            
+            # Khống chế max_iter để SVR chạy nhanh hơn trong quá trình tìm kiếm
+            model = SVR(kernel='rbf', C=C, epsilon=epsilon, gamma='scale', max_iter=2000)
+            model.fit(X_train_scaled, y_train)
+            preds = model.predict(X_val_scaled)
+            fold_scores.append(np.sqrt(mean_squared_error(y_val, preds)))
+        return np.mean(fold_scores)
+
+    study_svr = optuna.create_study(direction='minimize')
+    study_svr.optimize(objective_svr, n_trials=10) # Set số trial vừa phải
+    
+    # === HUẤN LUYỆN MODEL CUỐI CÙNG & LƯU LẠI ===
+    print("5. Huấn luyện mô hình cuối và lưu trữ...")
+    os.makedirs("models", exist_ok=True)
+    
+    # Ridge
+    scaler_lr = StandardScaler()
+    X_scaled_lr = scaler_lr.fit_transform(X)
+    model_lr = Ridge(alpha=best_alpha, random_state=42)
+    model_lr.fit(X_scaled_lr, y)
+    joblib.dump(scaler_lr, 'models/scaler_lr.pkl')
+    joblib.dump(model_lr, 'models/model_lr.pkl')
+    
+    # SVR
+    scaler_svr = StandardScaler()
+    X_scaled_svr = scaler_svr.fit_transform(X)
+    model_svr = SVR(kernel='rbf', C=study_svr.best_params['C'], epsilon=study_svr.best_params['epsilon'], gamma='scale')
+    model_svr.fit(X_scaled_svr, y)
+    joblib.dump(scaler_svr, 'models/scaler_svr.pkl')
+    joblib.dump(model_svr, 'models/model_svr.pkl')
+
+    print("6. Tải mô hình lên Hugging Face Hub...")
+    hf_token = os.environ.get("HF_TOKEN")
+    if hf_token:
+        api = HfApi()
+        api.upload_folder(
+            folder_path="models",
+            repo_id=REPO_ID,
+            repo_type="model",
+            token=hf_token
+        )
+        print("Upload thành công!")
+    else:
+        print("Thiếu HF_TOKEN, bỏ qua bước upload.")
+
+if __name__ == "__main__":
+    main()