Update app.py

app.py

@@ -1,91 +1,76 @@
 import os
-import gradio as gr
-import tensorflow as tf
-import joblib
-import numpy as np
 import pandas as pd
-from huggingface_hub import hf_hub_download
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+import numpy as np
+import joblib
+import tensorflow as tf
+from fuzzywuzzy import process
+import gradio as gr
 
-MODEL_REPO = "munem420/stock-forecaster-lstm"
-MODEL_FILENAME = "model_lstm.h5"
-SCALER_FILENAME = "scalers.joblib"
+# --- Load data ---
+DATA_PATH = "/kaggle/working/all_stocks_long.csv"  # update if needed
+MODEL_DIR = "/kaggle/working/stock-forecaster-lstm"
+MODEL_FILE = "model_lstm.h5"
+SCALER_FILE = "scalers.joblib"
 
-print("--- Downloading model and scalers ---")
-try:
-    model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILENAME)
-    scalers_path = hf_hub_download(repo_id=MODEL_REPO, filename=SCALER_FILENAME)
-    print("✅ Files downloaded successfully.")
-except Exception as e:
-    print(f"❌ Error downloading files: {e}")
-    model_path, scalers_path = None, None
+combined_fe = pd.read_csv(DATA_PATH, parse_dates=['date'])
+combined_fe['ticker'] = combined_fe['ticker'].str.upper()
 
-loaded_model_lstm = None
-loaded_scalers = None
+# --- Load model ---
+model_path = os.path.join(MODEL_DIR, MODEL_FILE)
+scaler_path = os.path.join(MODEL_DIR, SCALER_FILE)
 
-if model_path and os.path.exists(model_path):
-    try:
-        loaded_model_lstm = tf.keras.models.load_model(
-            model_path,
-            custom_objects={"mse": tf.keras.losses.MeanSquaredError()}
-        )
-        print("✅ Model loaded successfully.")
-    except Exception as e:
-        print(f"❌ Error loading model: {e}")
+loaded_model = tf.keras.models.load_model(model_path)
+loaded_scalers = joblib.load(scaler_path)
 
-if scalers_path and os.path.exists(scalers_path):
-    try:
-        loaded_scalers = joblib.load(scalers_path)
-        print("✅ Scalers loaded successfully.")
-    except Exception as e:
-        print(f"❌ Error loading scalers: {e}")
+# --- Build ticker <-> company mappings ---
+top_tickers = combined_fe['ticker'].unique()
+ticker_to_name = {t: t for t in top_tickers}  # can update with real names if available
+name_to_ticker = {v: k for k,v in ticker_to_name.items()}
 
-ticker_to_name = {'ZURVY': 'Zurich Insurance Group AG'}
+# --- Prediction helpers ---
+def get_ticker_from_input(input_str):
+    if input_str.upper() in ticker_to_name:
+        return input_str.upper()
+    if input_str in name_to_ticker:
+        return name_to_ticker[input_str]
+    best_match, score = process.extractOne(input_str, name_to_ticker.keys())
+    if score > 80:
+        return name_to_ticker[best_match]
+    return None
 
-def get_ticker_from_input(input_name):
-    return input_name.upper()
+def make_windows(series, input_width=60, horizon=1):
+    arr = series.values.astype(np.float32)
+    X, y = [], []
+    for i in range(input_width, len(arr)-horizon+1):
+        X.append(arr[i-input_width:i])
+        y.append(arr[i + (horizon-1)])
+    return np.array(X), np.array(y)
 
-def forecast_stock(input_name, model, scalers_dict, input_width=60):
-    if not model or not scalers_dict:
-        return "Error: Model or scalers not loaded. The backend may have failed to start."
+def forecast_stock(input_name):
     ticker = get_ticker_from_input(input_name)
     if not ticker:
-        return "Error: Invalid stock ticker."
-    print(f"\n--- Generating forecast for {ticker} ---")
+        return f"Could not find ticker for '{input_name}'"
+    
+    recent_data = combined_fe[combined_fe['ticker']==ticker].sort_values('date').tail(60)
+    if len(recent_data) < 60:
+        return f"Not enough historical data for {ticker}."
     
-    if len(data_df) < input_width:
-        return f"Error: Not enough historical data. Need {input_width} days, but only have {len(data_df)}."
-    recent_data = data_df.tail(input_width)
-    close_prices = recent_data['Close'].values.reshape(-input, 1)
-    scaler = scalers_dict.get(ticker)
-    if not scaler:
-        print(f"Warning: No specific scaler found for {ticker}. Using ZURVY's scaler as a fallback.")
-        scaler = scalers_dict.get('ZURVY')
-        if not scaler:
-            return "Error: Default scaler 'ZURVY' not found."
+    close_prices = recent_data['close'].values.reshape(-1, 1)
+    scaler = loaded_scalers[ticker]
     scaled_data = scaler.transform(close_prices)
-    X_pred = scaled_data.reshape(1, input_width, 1)
-    prediction_scaled = model.predict(X_pred, verbose=0)[0][0]
-    prediction_actual = scaler.inverse_transform(np.array([[prediction_scaled]]))[0][0]
-    last_close = recent_data['Close'].iloc[-1]
-    result = (
-        f"Last known close for {ticker}: ${last_close:.2f}\n"
-        f"Predicted next day's close price: ${prediction_actual:.2f}"
-    )
-    print(result)
-    return result
-
-def predict_api(ticker_symbol):
-    return forecast_stock(ticker_symbol, loaded_model_lstm, loaded_scalers)
-
-with gr.Blocks() as app:
-    gr.Markdown("This is the backend for the React Stock Forecaster App.")
-    ticker_input = gr.Textbox(label="Stock Ticker", visible=False)
-    output_text = gr.Textbox(label="Forecast", visible=False)
-    ticker_input.submit(predict_api, inputs=[ticker_input], outputs=[output_text], api_name="predict")
+    X_pred = scaled_data.reshape(1, 60, 1)
+    
+    prediction_scaled = loaded_model.predict(X_pred, verbose=0)[0][0]
+    prediction_actual = scaler.inverse_transform([[prediction_scaled]])[0][0]
+    return round(prediction_actual, 2)
 
-app = gr.mount_static_directory(app, "build")
+# --- Gradio Interface ---
+iface = gr.Interface(
+    fn=forecast_stock,
+    inputs=gr.Textbox(label="Enter Ticker or Company Name"),
+    outputs=gr.Textbox(label="Predicted Next Day Close"),
+    title="Stock Price Forecaster (LSTM)",
+    description="Enter a stock ticker or company name to predict the next day's close price."
+)
 
-if __name__ == "__main__":
-    app.launch()
+iface.launch()