Initialization

.gitignore

@@ -0,0 +1,5 @@
+.env
+models/__pycache__
+utils/__pycache__
+dataset/*
+.python-version

.gradio/flagged/dataset1.csv

@@ -0,0 +1,2 @@
+📥 Load File (MW) CSV,🌡️ Temperature File (MaxTemp) CSV,ΔTemp (°C),📊 Simulated Output (MaxTemp ➜ Load MW),timestamp
+,,1,"{""headers"": [""1"", ""2"", ""3""], ""data"": [], ""metadata"": null}",2025-07-17 23:49:54.330002

app.py

@@ -0,0 +1,92 @@
+# app.py
+import gradio as gr
+import pandas as pd
+from fastapi import FastAPI
+from gradio.routes import mount_gradio_app
+import uvicorn
+import os
+import numpy as np
+
+from utils.preprocessing import preprocess_load_data, preprocess_temperature_data
+from utils.merge_data import merge_load_temp
+from models.forecast import TimeSeriesForecaster
+from models.regression import LoadLimitRegressor
+from utils.simulate import simulate_with_model
+
+# --- FastAPI app ---
+app = FastAPI()
+
+# --- Globals ---
+df_merged = None  # เก็บข้อมูล merge เอาไว้
+forecast_model = None
+reg_model = None
+
+# --- Model option lists ---
+forecast_models = ['PatchTST', 'LSTM', 'BiLSTM', 'GRU', 'RNN', 'ARIMA', 'Prophet']
+regression_models = ['linear', 'xgb', 'mlp']
+
+def forecast_ui(load_file, temp_file, 
+                forecast_model_type, regression_model_type,
+                forecast_horizon, delta_temp):
+    global df_merged, forecast_model, reg_model
+
+    # 1. อ่านไฟล์
+    df_load_raw = pd.read_csv(load_file.name)
+    df_temp_raw = pd.read_csv(temp_file.name)
+
+    # 2. preprocess
+    df_load = preprocess_load_data(df_load_raw)
+    df_temp = preprocess_temperature_data(df_temp_raw)
+
+    # 3. merge
+    df_merged = merge_load_temp(df_load, df_temp)
+
+    # 4. สร้างและ train forecasting model (forecast max load)
+    forecast_model = TimeSeriesForecaster(model_type=forecast_model_type, horizon=forecast_horizon)
+    forecast_model.fit(df_merged, value_col='mw_max')
+    forecast_pred = forecast_model.predict(future_steps=forecast_horizon)
+
+    # 5. train regression model (max temp -> max load limit)
+    reg_model = LoadLimitRegressor(model_type=regression_model_type)
+    reg_model.fit(df_merged, temp_col='MaxTemp', load_col='mw_max')
+
+    # 6. simulate load limit with delta_temp
+    df_simulated = simulate_with_model(df_merged, delta_temp=delta_temp, model=reg_model)
+
+    # 7. เตรียมผลลัพธ์สำหรับแสดง
+    # forecast results dataframe
+    last_date = df_merged['date'].max() if 'date' in df_merged.columns else pd.to_datetime('today')
+    forecast_df = pd.DataFrame({
+        'Step': np.arange(1, forecast_horizon + 1),
+        'Forecast Load MW': forecast_pred
+    })
+
+    # simulation dataframe (limit model)
+    # แสดงแค่ columns สำคัญ
+    sim_df_show = df_simulated[['MaxTemp', 'mw_max', 'MaxTemp_simulated', 'Load_simulated']]
+
+    return forecast_df, sim_df_show
+
+# --- Gradio UI ---
+demo = gr.Interface(
+    fn=forecast_ui,
+    inputs=[
+        gr.File(label="📥 Load File (MW) CSV"),
+        gr.File(label="🌡️ Temperature File (MaxTemp) CSV"),
+        gr.Dropdown(choices=forecast_models, label="Forecast Model", value='PatchTST'),
+        gr.Dropdown(choices=regression_models, label="Regression Model", value='xgb'),
+        gr.Slider(minimum=1, maximum=30, step=1, label="Forecast Horizon (days)", value=7),
+        gr.Slider(minimum=-5.0, maximum=5.0, step=0.5, label="ΔTemp (°C)", value=1.0)
+    ],
+    outputs=[
+        gr.Dataframe(label="📈 Forecast Load MW"),
+        gr.Dataframe(label="📊 Simulated Load Limit")
+    ],
+    title="Submarine Load Forecast & Safety Margin Simulation",
+    description="Upload load and temperature CSV data, choose forecasting and regression models, set forecast horizon, and simulate temperature impact on load limit."
+)
+
+demo.launch(
+    server_name=os.getenv("SERVER_NAME", "0.0.0.0"),
+    server_port=int(os.getenv("PORT", 7860)),
+)

dockerfile

@@ -0,0 +1,23 @@
+# Dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# 1. Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git build-essential libglib2.0-0 libsm6 libxext6 libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 3. Copy all source code
+COPY . .
+
+# 4. Expose port
+ENV PORT=7860
+EXPOSE $PORT
+
+# 5. Run app
+CMD ["python", "app.py"]

models/forecast.py

@@ -0,0 +1,81 @@
+# models/forecasting.py
+
+import pandas as pd
+import numpy as np
+from tsai.all import *
+from typing import Literal, Tuple
+from sklearn.preprocessing import MinMaxScaler
+
+ForecastModelType = Literal['PatchTST', 'LSTM', 'BiLSTM', 'GRU', 'RNN', 'ARIMA', 'Prophet']
+
+class TimeSeriesForecaster:
+    def __init__(self, model_type: ForecastModelType = 'PatchTST', horizon: int = 7):
+        self.model_type = model_type
+        self.horizon = horizon
+        self.scaler = MinMaxScaler()
+        self.model = None
+        self.dls = None
+        self.X_cols = None
+
+    def preprocess(self, df: pd.DataFrame, value_col: str) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        รับ dataframe และคอลัมน์เป้าหมาย แล้วแปลงให้เป็น (X, y) สำหรับ tsai
+        """
+        df = df.copy()
+        df[value_col] = self.scaler.fit_transform(df[[value_col]])
+        ts = df[value_col].values.astype(np.float32)
+        X, y = SlidingWindow(window_len=self.horizon, horizon=self.horizon)(ts)
+        return X, y
+
+    def fit(self, df: pd.DataFrame, value_col: str):
+        """
+        เทรนโมเดลตาม model_type ที่เลือก
+        """
+        if self.model_type in ['PatchTST', 'LSTM', 'BiLSTM', 'GRU', 'RNN']:
+            X, y = self.preprocess(df, value_col)
+            self.dls = get_ts_dls(X, y, bs=32, splits=TSStandardSplit()(X))
+            if self.model_type == 'PatchTST':
+                self.model = PatchTST(self.dls.vars, self.dls.len, self.dls.c)
+            elif self.model_type == 'LSTM':
+                self.model = LSTM(self.dls.vars, self.dls.len, self.dls.c)
+            elif self.model_type == 'BiLSTM':
+                self.model = LSTM(self.dls.vars, self.dls.len, self.dls.c, bidirectional=True)
+            elif self.model_type == 'GRU':
+                self.model = GRU(self.dls.vars, self.dls.len, self.dls.c)
+            elif self.model_type == 'RNN':
+                self.model = RNN(self.dls.vars, self.dls.len, self.dls.c)
+            learn = Learner(self.dls, self.model, loss_func=MSELossFlat(), metrics=[mae, rmse])
+            learn.fit_one_cycle(20, 1e-3)
+            self.learn = learn
+        elif self.model_type == 'ARIMA':
+            from statsmodels.tsa.arima.model import ARIMA
+            self.model = ARIMA(df[value_col], order=(7, 1, 0)).fit()
+        elif self.model_type == 'Prophet':
+            from prophet import Prophet
+            prophet_df = df[['datetime', value_col]].rename(columns={'datetime': 'ds', value_col: 'y'})
+            self.model = Prophet()
+            self.model.fit(prophet_df)
+        else:
+            raise ValueError(f"Unsupported model type: {self.model_type}")
+
+    def predict(self, future_steps: int = None) -> np.ndarray:
+        """
+        พยากรณ์ค่าข้างหน้า future_steps (หรือ horizon)
+        """
+        if future_steps is None:
+            future_steps = self.horizon
+
+        if self.model_type in ['PatchTST', 'LSTM', 'BiLSTM', 'GRU', 'RNN']:
+            x_last = self.dls.items[-1][None, :]
+            pred = self.learn.model(x_last).detach().cpu().numpy().flatten()
+            pred = self.scaler.inverse_transform(pred.reshape(-1, 1)).flatten()
+            return pred[:future_steps]
+        elif self.model_type == 'ARIMA':
+            forecast = self.model.forecast(steps=future_steps)
+            return forecast.values if hasattr(forecast, 'values') else forecast
+        elif self.model_type == 'Prophet':
+            future = self.model.make_future_dataframe(periods=future_steps)
+            forecast = self.model.predict(future)
+            return forecast['yhat'][-future_steps:].values
+        else:
+            raise ValueError("Model not trained or unsupported type")

models/regression.py

@@ -0,0 +1,61 @@
+# models/regression.py
+
+import pandas as pd
+import numpy as np
+from typing import Literal
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.neural_network import MLPRegressor
+from sklearn.metrics import mean_squared_error, r2_score
+from sklearn.preprocessing import MinMaxScaler
+
+RegressionModelType = Literal['linear', 'xgb', 'mlp']
+
+class LoadLimitRegressor:
+    def __init__(self, model_type: RegressionModelType = 'xgb'):
+        self.model_type = model_type
+        self.scaler_X = MinMaxScaler()
+        self.scaler_y = MinMaxScaler()
+        self.model = None
+
+    def fit(self, df: pd.DataFrame, temp_col: str = 'MaxTemp', load_col: str = 'mw_max'):
+        """
+        เทรน regression model เพื่อหา relationship ระหว่างอุณหภูมิ ➜ โหลดสูงสุด
+        """
+        X = df[[temp_col]].values
+        y = df[[load_col]].values
+
+        X_scaled = self.scaler_X.fit_transform(X)
+        y_scaled = self.scaler_y.fit_transform(y)
+
+        if self.model_type == 'linear':
+            self.model = LinearRegression()
+        elif self.model_type == 'xgb':
+            self.model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)
+        elif self.model_type == 'mlp':
+            self.model = MLPRegressor(hidden_layer_sizes=(64, 32), max_iter=1000)
+        else:
+            raise ValueError(f"Unsupported model type: {self.model_type}")
+
+        self.model.fit(X_scaled, y_scaled.ravel())
+
+    def predict(self, max_temp_values: np.ndarray) -> np.ndarray:
+        """
+        พยากรณ์โหลดสูงสุดที่เป็นไปได้ จากค่าความร้อน
+        """
+        X_scaled = self.scaler_X.transform(max_temp_values.reshape(-1, 1))
+        y_scaled = self.model.predict(X_scaled).reshape(-1, 1)
+        y = self.scaler_y.inverse_transform(y_scaled)
+        return y.flatten()
+
+    def evaluate(self, df: pd.DataFrame, temp_col: str = 'MaxTemp', load_col: str = 'mw_max') -> dict:
+        """
+        ประเมินผลโมเดล regression
+        """
+        y_true = df[load_col].values
+        y_pred = self.predict(df[temp_col].values)
+
+        return {
+            'rmse': np.sqrt(mean_squared_error(y_true, y_pred)),
+            'r2': r2_score(y_true, y_pred)
+        }

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+gradio
+uvicorn
+pandas
+scikit-learn
+xgboost
+numpy
+python-dotenv
+tsai==0.4.0
+fastai==2.7.19
+fastcore==1.7.29
+ipykernel

utils/merge_data.py

@@ -0,0 +1,40 @@
+# utils/merge_data.py
+import pandas as pd
+
+def aggregate_daily_max(df_load_15min: pd.DataFrame) -> pd.DataFrame:
+    """
+    จากข้อมูลที่ resample มาแล้ว (ทุก 15 นาที) รวมให้เหลือแค่ daily max load
+    """
+    df = df_load_15min.copy()
+    df['date'] = df['datetime'].dt.date  # เป็น datetime.date ไม่เอาเวลา
+    df_daily = df.groupby('date')['mw'].agg(['max', 'mean']).reset_index()
+    df_daily = df_daily.rename(columns={'max': 'mw_max', 'mean': 'mw_mean'})
+    return df_daily
+
+def merge_load_temp(df_daily_load: pd.DataFrame, df_temp: pd.DataFrame) -> pd.DataFrame:
+    """
+    รวมข้อมูล Load (daily) กับ Temperature (daily) โดยใช้ date เป็น key
+    df_temp ต้องมีคอลัมน์ 'date' ที่เป็น datetime64[ns] หรือ datetime.date
+    """
+    df_temp = df_temp.copy()
+    # ถ้าไม่มี 'date' คอลัมน์ ให้สร้างจาก year,month,day
+    if 'date' not in df_temp.columns:
+        df_temp['date'] = pd.to_datetime(df_temp[['year', 'month', 'day']]).dt.date
+
+    # มึงอย่าไปแปลงเป็น datetime แล้วเอาเวลาออกอีกที ให้มันมี datatype เดียวกันระหว่าง 2 df นี่แหละดีที่สุด
+
+    df_merged = pd.merge(df_daily_load, df_temp[['date', 'MaxTemp']], on='date', how='inner')
+    return df_merged
+
+# ตัวอย่างใช้
+if __name__ == '__main__':
+    load_fp = 'load_15min.csv'
+    temp_fp = 'temp.csv'
+
+    df_load_15min = pd.read_csv(load_fp, parse_dates=['datetime'])
+    df_temp = pd.read_csv(temp_fp)
+
+    df_daily = aggregate_daily_max(df_load_15min)
+    df_merged = merge_load_temp(df_daily, df_temp)
+
+    print(df_merged.head())

utils/preprocessing.py

@@ -0,0 +1,73 @@
+# utils/preprocessing.py
+import pandas as pd
+
+def preprocess_load_data(df_load: pd.DataFrame) -> pd.DataFrame:
+    """
+    รับ DataFrame load ดิบ แปลง datetime, sort, resample 15 นาที เติม missing
+    """
+    df_load = df_load.copy()
+
+    # ลบ space รอบคอลัมน์เผื่อมีมั่ว
+    df_load.columns = df_load.columns.str.strip()
+
+    # รวม date + time เป็น datetime พร้อม dayfirst=True (วัน/เดือน/ปี)
+    df_load['datetime'] = pd.to_datetime(df_load['date'].astype(str) + ' ' + df_load['time'].astype(str), dayfirst=True)
+
+    # Drop คอลัมน์เดิม
+    df_load = df_load.drop(columns=['date', 'time'])
+
+    # Sort และตั้ง index เป็น datetime
+    df_load = df_load.sort_values('datetime').set_index('datetime')
+
+    # สร้าง full range datetime ทุก 15 นาที ตั้งแต่วันแรกถึงวันสุดท้าย
+    start = df_load.index.min().normalize()
+    end = df_load.index.max().normalize() + pd.Timedelta(days=1) - pd.Timedelta(minutes=15)
+    full_idx = pd.date_range(start=start, end=end, freq='15T')
+
+    # Reindex เติมช่วงเวลาทั้งหมด
+    df_load = df_load.reindex(full_idx)
+
+    # เติม missing ด้วย linear interpolation แล้ว forward fill / back fill อีกที
+    df_load['mw'] = df_load['mw'].interpolate(method='time').fillna(method='ffill').fillna(method='bfill')
+
+    # Reset index กลับเป็นคอลัมน์ datetime
+    df_load = df_load.reset_index().rename(columns={'index': 'datetime'})
+
+    return df_load
+
+
+def preprocess_temperature_data(df_temp: pd.DataFrame) -> pd.DataFrame:
+    """
+    รับ DataFrame temp ดิบที่มี year, month, day, MaxTemp
+    รวม 3 คอลัมน์ปีเดือนวันเป็น datetime แล้ว sort
+    """
+    df_temp = df_temp.copy()
+
+    # ลบ space รอบคอลัมน์เผื่อมั่ว
+    df_temp.columns = df_temp.columns.str.strip()
+
+    # แปลงเป็น datetime
+    df_temp['date'] = pd.to_datetime(df_temp[['year', 'month', 'day']])
+
+    # Sort ตามวันที่
+    df_temp = df_temp.sort_values('date').reset_index(drop=True)
+
+    return df_temp
+
+
+if __name__ == '__main__':
+    # ทดสอบง่าย ๆ
+    df_load = pd.DataFrame({
+        'date': ['2024-03-01', '2024-03-01', '2024-03-01', '2024-03-02'],
+        'time': ['00:00', '00:15', '01:00', '00:00'],
+        'mw': [10, 12, 15, 11]
+    })
+    print(preprocess_load_data(df_load).head(10))
+
+    df_temp = pd.DataFrame({
+        'year': [2024, 2024, 2024],
+        'month': [3, 3, 3],
+        'day': [1, 2, 3],
+        'MaxTemp': [19.0, 18.5, 19.5]
+    })
+    print(preprocess_temperature_data(df_temp))

utils/simulate.py

@@ -0,0 +1,28 @@
+# utils/simulate.py
+
+import pandas as pd
+import numpy as np
+from models.regression import LoadLimitRegressor
+
+def simulate_temperature_change(df: pd.DataFrame, delta_temp: float) -> pd.DataFrame:
+    """
+    จำลองสถานการณ์เพิ่ม/ลด MaxTemp ทีละ delta_temp
+    แบบ simple linear approximation
+    """
+    df_sim = df.copy()
+    df_sim['MaxTemp_simulated'] = df_sim['MaxTemp'] + delta_temp
+
+    a, b = np.polyfit(df_sim['MaxTemp'], df_sim['mw_max'], 1)
+    df_sim['Load_simulated'] = a * df_sim['MaxTemp_simulated'] + b
+
+    return df_sim
+
+def simulate_with_model(df: pd.DataFrame, delta_temp: float, model: LoadLimitRegressor) -> pd.DataFrame:
+    """
+    จำลองสถานการณ์ โดยใช้ regression model ที่ฝึกมาแล้ว
+    """
+    df_sim = df.copy()
+    df_sim['MaxTemp_simulated'] = df_sim['MaxTemp'] + delta_temp
+    df_sim['Load_simulated'] = model.predict(df_sim['MaxTemp_simulated'].values)
+
+    return df_sim