app changes

app.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI
-from pydantic import BaseModel
+
+import gradio as gr
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -11,6 +11,8 @@ import json
 import math
 from typing import Union
 from deployment.config import load_model_config, get_input_size
+from fastapi import FastAPI, Mount
+from gradio.themes.base import Base
 
 # --- Helper function to get model device ---
 def get_model_device(model):
@@ -669,9 +671,6 @@ class xLSTMPredictor(nn.Module):
 
         return predictions, states
 
-# --- FastAPI App ---
-app = FastAPI()
-
 # --- Load Models ---
 MODELS_DIR = "deployment/models"
 models = {}
@@ -737,45 +736,122 @@ with open(os.path.join(MODELS_DIR, "RandomForest_model.pkl"), "rb") as f:
     models["random_forest"] = rf_model
 
 
-# --- API Endpoints ---
-class InferenceRequest(BaseModel):
-    model_name: str
-    features: list
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+import matplotlib.pyplot as plt
 
-class InferenceResponse(BaseModel):
-    prediction: float
-
-@app.post("/predict", response_model=InferenceResponse)
-async def predict(request: InferenceRequest):
-    model = models.get(request.model_name)
+def predict(model_name, file):
+    model = models.get(model_name)
     if not model:
-        return {"error": "Model not found"}
-
-    features = np.array(request.features)
-
-    if request.model_name in ["hawk", "mamba", "xlstm"]:
-        # PyTorch models expect a batch of sequences, so reshape to (1, seq_len, num_features)
-        # Assuming features are already a sequence for a single sample
-        # The actual seq_len and num_features should match the model's training
-        # For now, assuming features is a 2D array (seq_len, num_features)
-        # and we add a batch dimension.
-        # This is a critical assumption and might need adjustment based on actual data.
-        features = torch.FloatTensor(features).unsqueeze(0).to(device)
+        return "Model not found", None, None
+
+    df = pd.read_csv(file.name)
+
+    config = load_model_config(model_name, models_dir="deployment/models")
+    feature_cols = config["feature_cols"]
+    target_col = config["target_col"]
+    seq_length = config["seq_length"]
+
+    # Data preparation (assuming the uploaded file is the test set)
+    scaler = StandardScaler()
+    # Fit on a dummy array to avoid errors, in a real scenario you would load a fitted scaler
+    scaler.fit(np.random.rand(100, len(feature_cols)))
+    features = scaler.transform(df[feature_cols].values)
+    targets = df[target_col].values
+
+    X_test = []
+    y_test = []
+
+    for i in range(len(features) - seq_length):
+        X_test.append(features[i : i + seq_length])
+        y_test.append(targets[i : i + seq_length])
+
+    X_test = torch.FloatTensor(np.array(X_test))
+    y_test = np.array(y_test)
+
+    # Prediction
+    if model_name in ["hawk", "mamba", "xlstm"]:
+        X_test = X_test.to(device)
         with torch.no_grad():
-            # PyTorch models return (batch_size, seq_len, 1), we need the last prediction
-            prediction = model(features)[0][0, -1, 0].item()
+            predictions, _ = model(X_test)
+            predictions = predictions.cpu().numpy()
     else: # scikit-learn models
-        # Scikit-learn models expect a 2D array (n_samples, n_features)
-        # If features is a single sample (1D array), reshape to (1, -1)
-        # If features is already a sequence (2D array), it needs to be flattened
-        # to match how classical models were trained (create_sequences flattens).
-        # This is another critical assumption. For now, assuming features is a 1D array
-        # representing flattened sequence or single-step features.
-        features = features.reshape(1, -1)
-        prediction = model.predict(features)[0]
+        # For sklearn models, you might need to flatten the sequences
+        X_test_reshaped = X_test.reshape(len(X_test), -1)
+        predictions = model.predict(X_test_reshaped)
+        # The output shape of sklearn models might differ, you might need to adjust this
+        # For this example, let's assume it's a 1D array and we need to make it match the y_test shape
+        predictions = np.repeat(predictions[:, np.newaxis], y_test.shape[1], axis=1)
+
+
+    # For PyTorch models, predictions have an extra dimension
+    if model_name in ["hawk", "mamba", "xlstm"]:
+        y_pred_for_metrics = predictions[:, -1, 0]
+    else:
+        y_pred_for_metrics = predictions[:, -1]
+
+    # Calculate metrics
+    y_true_for_metrics = y_test[:, -1]
+    metrics = {
+        "MSE": mean_squared_error(y_true_for_metrics, y_pred_for_metrics),
+        "RMSE": np.sqrt(mean_squared_error(y_true_for_metrics, y_pred_for_metrics)),
+        "MAE": mean_absolute_error(y_true_for_metrics, y_pred_for_metrics),
+        "R2": r2_score(y_true_for_metrics, y_pred_for_metrics),
+    }
+    metrics_str = json.dumps(metrics, indent=4)
+
+    # Create plot
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.plot(y_true_for_metrics, label="Actual")
+    ax.plot(y_pred_for_metrics, label="Predicted")
+    ax.set_title("Predictions vs Actual")
+    ax.set_xlabel("Time Step")
+    ax.set_ylabel("Value")
+    ax.legend()
+    ax.grid(True)
+
+    # For this example, we'll just return the last prediction of the last sequence
+    last_prediction = predictions[-1, -1, 0] if model_name in ["hawk", "mamba", "xlstm"] else predictions[-1, -1]
+
+
+    return f"{last_prediction:.4f}", metrics_str, fig
+
+
+# --- Gradio Interface ---
+with gr.Blocks(theme=Base(), title="Stock Predictor") as demo:
+    gr.Markdown(
+        """
+    # Stock Price Predictor
+    Select a model and upload a CSV file with the required features to get a prediction.
+    """
+    )
+    with gr.Row():
+        with gr.Column():
+            model_name = gr.Dropdown(
+                label="Select Model", choices=list(models.keys())
+            )
+            feature_input = gr.File(
+                label="Upload CSV with features",
+            )
+            predict_btn = gr.Button("Predict")
+        with gr.Column():
+            prediction_output = gr.Textbox(label="Prediction")
+            metrics_output = gr.Textbox(label="Metrics")
+            plot_output = gr.Plot(label="Plots")
+
+    predict_btn.click(
+        fn=predict,
+        inputs=[model_name, feature_input],
+        outputs=[prediction_output, metrics_output, plot_output],
+    )
 
-    return {"prediction": prediction}
+# --- FastAPI App ---
+app = FastAPI()
+
+from fastapi.responses import RedirectResponse
 
 @app.get("/")
 def read_root():
-    return {"message": "Stock prediction API"}
+    return RedirectResponse(url="/gradio")
+
+app = gr.mount_gradio_app(app, demo, path="/gradio")