v1.0 check

.gitignore

@@ -0,0 +1,2 @@
+artifacts/
+__pycache__/

README.md

@@ -1,5 +1,5 @@
 ---
-title: StockSense
+title: StockSenseSpace
 emoji: 🐠
 colorFrom: gray
 colorTo: pink

app.py

@@ -0,0 +1,58 @@
+import gradio as gr
+from train import train as train_fn
+from testing import evaluate as eval_fn
+from inference import predict_next as predict_fn
+
+def train_api(symbol, seq_len=60, epochs=5, batch_size=32, start="", end=""):
+    return train_fn(
+        symbol,
+        seq_len=int(seq_len),
+        epochs=int(epochs),
+        batch_size=int(batch_size),
+        start=start or None,
+        end=end or None,
+    )
+
+def test_api(symbol):
+    return eval_fn(symbol)
+
+def predict_api(symbol, days=1):
+    return predict_fn(symbol, n_days=int(days))
+
+def hello_api(name="world"):
+    return {"message": f"hello {name}"}
+
+with gr.Blocks() as demo:
+    gr.Markdown("## LSTM Stock Predictor (PyTorch • Train / Test / Predict)")
+    with gr.Tab("Train"):
+        sym_t = gr.Textbox(label="Symbol", value="AAPL")
+        seq = gr.Number(label="Seq length", value=60, precision=0)
+        ep = gr.Number(label="Epochs", value=5, precision=0)
+        bs = gr.Number(label="Batch size", value=32, precision=0)
+        start = gr.Textbox(label="Start (YYYY-MM-DD)", placeholder="optional")
+        end = gr.Textbox(label="End (YYYY-MM-DD)", placeholder="optional")
+        btn_t = gr.Button("Train")
+        out_t = gr.JSON()
+        btn_t.click(train_api, [sym_t, seq, ep, bs, start, end], out_t, api_name="train")
+
+    with gr.Tab("Test"):
+        sym_e = gr.Textbox(label="Symbol", value="AAPL")
+        btn_e = gr.Button("Run Test")
+        out_e = gr.JSON()
+        btn_e.click(test_api, [sym_e], out_e, api_name="test")
+
+    with gr.Tab("Predict"):
+        sym_p = gr.Textbox(label="Symbol", value="AAPL")
+        days = gr.Number(label="Days to predict", value=1, precision=0)
+        btn_p = gr.Button("Predict")
+        out_p = gr.JSON()
+        btn_p.click(predict_api, [sym_p, days], out_p, api_name="predict")
+    
+    with gr.Tab("Hello"):
+        who = gr.Textbox(label="Name", value="world")
+        btn_h = gr.Button("Say Hello")
+        out_h = gr.JSON()
+        btn_h.click(hello_api, [who], out_h, api_name="hello")
+
+if __name__ == "__main__":
+    demo.launch()

apptest.py

@@ -0,0 +1,58 @@
+import gradio as gr
+from train import train as train_fn
+from testing import evaluate as eval_fn
+from inference import predict_next as predict_fn
+
+def train_api(symbol, seq_len=60, epochs=5, batch_size=32, start="", end=""):
+    return train_fn(
+        symbol,
+        seq_len=int(seq_len),
+        epochs=int(epochs),
+        batch_size=int(batch_size),
+        start=start or None,
+        end=end or None,
+    )
+
+def test_api(symbol):
+    return eval_fn(symbol)
+
+def predict_api(symbol, days=1):
+    return predict_fn(symbol, n_days=int(days))
+
+def hello_api(name="world"):
+    return {"message": f"hello {name}"}
+
+with gr.Blocks() as demo:
+    gr.Markdown("## LSTM Stock Predictor (PyTorch • Train / Test / Predict)")
+    with gr.Tab("Train"):
+        sym_t = gr.Textbox(label="Symbol", value="AAPL")
+        seq = gr.Number(label="Seq length", value=60, precision=0)
+        ep = gr.Number(label="Epochs", value=5, precision=0)
+        bs = gr.Number(label="Batch size", value=32, precision=0)
+        start = gr.Textbox(label="Start (YYYY-MM-DD)", placeholder="optional")
+        end = gr.Textbox(label="End (YYYY-MM-DD)", placeholder="optional")
+        btn_t = gr.Button("Train")
+        out_t = gr.JSON()
+        btn_t.click(train_api, [sym_t, seq, ep, bs, start, end], out_t, api_name="train")
+
+    with gr.Tab("Test"):
+        sym_e = gr.Textbox(label="Symbol", value="AAPL")
+        btn_e = gr.Button("Run Test")
+        out_e = gr.JSON()
+        btn_e.click(test_api, [sym_e], out_e, api_name="test")
+
+    with gr.Tab("Predict"):
+        sym_p = gr.Textbox(label="Symbol", value="AAPL")
+        days = gr.Number(label="Days to predict", value=1, precision=0)
+        btn_p = gr.Button("Predict")
+        out_p = gr.JSON()
+        btn_p.click(predict_api, [sym_p, days], out_p, api_name="predict")
+    
+    with gr.Tab("Hello"):
+        who = gr.Textbox(label="Name", value="world")
+        btn_h = gr.Button("Say Hello")
+        out_h = gr.JSON()
+        btn_h.click(hello_api, [who], out_h, api_name="hello")
+
+if __name__ == "__main__":
+    demo.launch()

inference.py

@@ -0,0 +1,64 @@
+import os, json, pickle
+from datetime import datetime, timedelta
+import numpy as np
+import yfinance as yf
+import torch
+
+from models import StockLSTM
+
+ARTIFACTS_DIR = "artifacts"
+
+def _paths(symbol: str):
+    base = os.path.join(ARTIFACTS_DIR, symbol.upper())
+    return {
+        "model": os.path.join(base, "model.pt"),
+        "scaler": os.path.join(base, "scaler.pkl"),
+        "meta": os.path.join(base, "meta.json"),
+    }
+
+def _load_artifacts(symbol: str):
+    p = _paths(symbol)
+    if not (os.path.exists(p["model"]) and os.path.exists(p["scaler"])):
+        raise FileNotFoundError(f"Model/scaler not found for {symbol}. Train first.")
+    with open(p["meta"], "r") as f:
+        meta = json.load(f)
+    with open(p["scaler"], "rb") as f:
+        scaler = pickle.load(f)
+
+    model = StockLSTM(input_dim=1, hidden_dim=64, num_layers=2, dropout=0.2)
+    model.load_state_dict(torch.load(p["model"], map_location="cpu"))
+    model.eval()
+    return model, scaler, meta
+
+def _last_close_series(symbol: str, days: int = 400):
+    end = datetime.utcnow().date()
+    start = end - timedelta(days=days)
+    df = yf.download(symbol, start=start.isoformat(), end=end.isoformat(), progress=False, auto_adjust=True)
+    if df.empty:
+        raise ValueError(f"No data for {symbol}")
+    return df["Close"].values.reshape(-1, 1)
+
+@torch.no_grad()
+def predict_next(symbol: str, n_days: int = 1):
+    model, scaler, meta = _load_artifacts(symbol)
+    seq_len = meta["seq_len"]
+
+    closes = _last_close_series(symbol, days=max(400, seq_len*5))
+    scaled = scaler.transform(closes)
+
+    # seed window
+    window = scaled[-seq_len:].reshape(1, seq_len, 1).astype(np.float32)
+    window_t = torch.from_numpy(window)
+
+    preds_scaled = []
+    for _ in range(n_days):
+        yhat = model(window_t).numpy()          # [1,1] in scaled space
+        preds_scaled.append(yhat[0, 0])
+        # roll
+        next_window = np.concatenate([window[:, 1:, :], yhat.reshape(1, 1, 1)], axis=1)
+        window = next_window
+        window_t = torch.from_numpy(window.astype(np.float32))
+
+    preds_scaled = np.array(preds_scaled, dtype=np.float32).reshape(-1, 1)
+    preds_unscaled = scaler.inverse_transform(preds_scaled).flatten().tolist()
+    return {"symbol": symbol.upper(), "days": n_days, "predictions": preds_unscaled, "seq_len": seq_len, "meta": meta}

models.py

@@ -0,0 +1,24 @@
+import torch
+import torch.nn as nn
+
+class StockLSTM(nn.Module):
+    def __init__(self, input_dim=1, hidden_dim=64, num_layers=2, dropout=0.2):
+        super().__init__()
+        self.lstm = nn.LSTM(
+            input_size=input_dim,
+            hidden_size=hidden_dim,
+            num_layers=num_layers,
+            dropout=dropout if num_layers > 1 else 0.0,
+            batch_first=True,
+        )
+        self.head = nn.Sequential(
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, 1)
+        )
+
+    def forward(self, x):
+        # x: [B, T, 1]
+        out, (h_n, c_n) = self.lstm(x)  # out: [B, T, H]
+        last = out[:, -1, :]            # [B, H]
+        y = self.head(last)             # [B, 1]
+        return y

requirements.txt

@@ -0,0 +1,6 @@
+numpy==2.3.5
+pandas==2.3.3
+scikit_learn==1.8.0
+tensorflow==2.20.0
+yfinance==0.2.65
+torch==2.9.1

testing.py

@@ -0,0 +1,49 @@
+import os, json, math, pickle
+from datetime import datetime, timedelta
+import numpy as np
+import yfinance as yf
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+import torch
+
+from models import StockLSTM
+
+ARTIFACTS_DIR = "artifacts"
+
+@torch.no_grad()
+def evaluate(symbol: str):
+    base = os.path.join(ARTIFACTS_DIR, symbol.upper())
+    model = StockLSTM(input_dim=1, hidden_dim=64, num_layers=2, dropout=0.2)
+    model.load_state_dict(torch.load(os.path.join(base, "model.pt"), map_location="cpu"))
+    model.eval()
+    with open(os.path.join(base, "scaler.pkl"), "rb") as f:
+        scaler = pickle.load(f)
+    with open(os.path.join(base, "meta.json"), "r") as f:
+        meta = json.load(f)
+
+    seq_len = meta["seq_len"]
+
+    end = datetime.utcnow().date()
+    start = end - timedelta(days=5*365)
+    df = yf.download(symbol, start=start.isoformat(), end=end.isoformat(), progress=False, auto_adjust=True)
+    data = df[["Close"]].dropna().values
+
+    scaled = scaler.transform(data)
+    split_idx = int(len(scaled) * 0.8)
+    test_scaled = scaled[split_idx - seq_len:]  # include tail of train for continuity
+
+    # build sequences
+    X, y = [], []
+    for i in range(seq_len, len(test_scaled)):
+        X.append(test_scaled[i-seq_len:i])
+        y.append(test_scaled[i])
+    X = np.array(X, dtype=np.float32)
+    y = np.array(y, dtype=np.float32)
+
+    X_t = torch.from_numpy(X)       # [N, T, 1]
+    pred_scaled = model(X_t).numpy()
+    pred = scaler.inverse_transform(pred_scaled)
+    y_true = scaler.inverse_transform(y)
+
+    rmse = math.sqrt(mean_squared_error(y_true, pred))
+    mae = mean_absolute_error(y_true, pred)
+    return {"symbol": symbol.upper(), "rmse": rmse, "mae": mae, "n": len(y_true)}

train.py

@@ -0,0 +1,140 @@
+import os, json, math, pickle
+from datetime import datetime, timedelta
+import numpy as np
+import pandas as pd
+import yfinance as yf
+
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+import torch
+from torch.utils.data import TensorDataset, DataLoader, random_split
+import torch.nn as nn
+import torch.optim as optim
+
+from models import StockLSTM
+
+ARTIFACTS_DIR = "artifacts"
+os.makedirs(ARTIFACTS_DIR, exist_ok=True)
+
+def fetch_data(symbol: str, start: str = None, end: str = None) -> pd.DataFrame:
+    if end is None:
+        end = datetime.utcnow().date().isoformat()
+    if start is None:
+        start = (datetime.utcnow().date() - timedelta(days=5*365)).isoformat()
+    df = yf.download(symbol, start=start, end=end, progress=False, auto_adjust=True)
+    if df.empty:
+        raise ValueError(f"No data for symbol {symbol}")
+    return df[['Close']].dropna()
+
+def make_sequences(values: np.ndarray, seq_len: int):
+    X, y = [], []
+    for i in range(seq_len, len(values)):
+        X.append(values[i-seq_len:i])
+        y.append(values[i])
+    X = np.array(X)            # [N, T, 1]
+    y = np.array(y)            # [N, 1]
+    return X, y
+
+def to_tensor_loader(X, y, batch_size=32):
+    X_t = torch.from_numpy(X).float()
+    y_t = torch.from_numpy(y).float()
+    ds = TensorDataset(X_t, y_t)
+    return ds
+
+def train(symbol: str, seq_len: int = 60, epochs: int = 5, batch_size: int = 32,
+          start: str = None, end: str = None, lr: float = 1e-3):
+    device = torch.device("cpu")
+
+    # --- data ---
+    df = fetch_data(symbol, start, end)
+    data = df['Close'].values.reshape(-1, 1)
+
+    scaler = MinMaxScaler((0, 1))
+    scaled = scaler.fit_transform(data)
+
+    split_idx = int(len(scaled) * 0.8)
+    train_scaled, test_scaled = scaled[:split_idx], scaled[split_idx:]
+
+    X_train, y_train = make_sequences(train_scaled, seq_len)
+    # Ensure continuity at split boundary
+    X_test_like_train, y_test_like_train = make_sequences(
+        np.vstack([train_scaled[-seq_len:], test_scaled]), seq_len
+    )
+
+    # Train/val split on the training portion
+    full_train_ds = to_tensor_loader(X_train, y_train)
+    val_size = max(1, int(0.1 * len(full_train_ds)))
+    train_size = len(full_train_ds) - val_size
+    train_ds, val_ds = random_split(full_train_ds, [train_size, val_size])
+
+    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
+    val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False)
+
+    # --- model ---
+    model = StockLSTM(input_dim=1, hidden_dim=64, num_layers=2, dropout=0.2).to(device)
+    criterion = nn.MSELoss()
+    optimizer = optim.Adam(model.parameters(), lr=lr)
+
+    # --- training ---
+    model.train()
+    for ep in range(epochs):
+        train_loss = 0.0
+        for xb, yb in train_loader:
+            xb, yb = xb.to(device), yb.to(device)
+            optimizer.zero_grad()
+            pred = model(xb)
+            loss = criterion(pred, yb)
+            loss.backward()
+            optimizer.step()
+            train_loss += loss.item() * xb.size(0)
+        train_loss /= len(train_loader.dataset)
+
+        # quick val
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for xb, yb in val_loader:
+                xb, yb = xb.to(device), yb.to(device)
+                pred = model(xb)
+                val_loss += criterion(pred, yb).item() * xb.size(0)
+        val_loss /= len(val_loader.dataset)
+        model.train()
+
+    # --- evaluation on held-out tail (like test) in original scale ---
+    model.eval()
+    with torch.no_grad():
+        X_t = torch.from_numpy(X_test_like_train).float().to(device)
+        preds_scaled = model(X_t).cpu().numpy()  # scaled space
+    preds = scaler.inverse_transform(preds_scaled)
+    y_true = scaler.inverse_transform(y_test_like_train)
+
+    rmse = math.sqrt(mean_squared_error(y_true, preds))
+    mae = mean_absolute_error(y_true, preds)
+
+    # --- save artifacts ---
+    base = os.path.join(ARTIFACTS_DIR, symbol.upper())
+    os.makedirs(base, exist_ok=True)
+    model_path = os.path.join(base, "model.pt")
+    scaler_path = os.path.join(base, "scaler.pkl")
+    meta_path = os.path.join(base, "meta.json")
+
+    torch.save(model.state_dict(), model_path)
+    with open(scaler_path, "wb") as f:
+        pickle.dump(scaler, f)
+    with open(meta_path, "w") as f:
+        json.dump({
+            "symbol": symbol.upper(),
+            "seq_len": seq_len,
+            "epochs": epochs,
+            "batch_size": batch_size,
+            "train_size": split_idx,
+            "timestamps": {
+                "start": df.index.min().strftime("%Y-%m-%d"),
+                "end": df.index.max().strftime("%Y-%m-%d"),
+                "trained_at_utc": datetime.utcnow().isoformat()
+            },
+            "metrics": {"rmse": rmse, "mae": mae}
+        }, f, indent=2)
+
+    return {"rmse": rmse, "mae": mae, "rows": len(df), "symbol": symbol.upper()}