Update app.py

app.py

@@ -2,36 +2,24 @@ import streamlit as st
 import numpy as np
 import pandas as pd
 import os
-import tempfile
 import joblib
 import pickle
-
-# Try to import keras only if available (for .h5 models)
 try:
     from tensorflow.keras.models import load_model as keras_load_model
     KERAS_AVAILABLE = True
 except Exception:
     KERAS_AVAILABLE = False
 
-st.set_page_config(page_title="House Price Predictor", layout="centered")
-
+st.set_page_config(page_title="House Price Predictor (fixed model)", layout="centered")
 st.title("🏠 Simple House Price Predictor")
-st.write("Load a saved regression model (joblib/pickle or Keras .h5) and predict house price from features.")
-
-# Sidebar: model selection / upload
-st.sidebar.header("Model")
-DEFAULT_MODEL_NAMES = ["model.joblib", "model.pkl", "model.h5"]
+st.write("This app loads a fixed model file: `house_price_model.h5` and predicts house price from features.")
 
-selected_local = None
-for name in DEFAULT_MODEL_NAMES:
-    if os.path.exists(name):
-        selected_local = name
-        break
+# -----------------------
+# HARD-CODED MODEL PATH
+# -----------------------
+MODEL_PATH = "house_price_model.h5"  # <-- hard-coded model filename
 
-uploaded_model = st.sidebar.file_uploader("Upload your saved model file (joblib/pkl/h5)", type=["joblib","pkl","h5"])
-use_local = st.sidebar.checkbox("Use model file from repository (if present)", value=(selected_local is not None))
-
-@st.cache_resource
+# Utility: load model from path (supports .h5, .joblib, .pkl)
 def load_model_from_path(path):
     """Load model from a local path (joblib/pickle/keras .h5)."""
     ext = os.path.splitext(path)[1].lower()
@@ -43,69 +31,33 @@ def load_model_from_path(path):
                 return pickle.load(f)
     if ext == ".h5":
         if not KERAS_AVAILABLE:
-            raise RuntimeError("Keras/TensorFlow not available in this environment to load .h5 model.")
+            raise RuntimeError("TensorFlow/Keras not available. Add `tensorflow` to requirements.txt.")
         return keras_load_model(path)
     raise ValueError("Unsupported model extension: " + ext)
 
-def load_model_from_uploaded(uploaded_file):
-    """Save uploaded file to a temp file and load similarly to local path."""
-    if uploaded_file is None:
-        return None
-    suffix = os.path.splitext(uploaded_file.name)[1].lower()
-    # write to temp file
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
-    tmp.write(uploaded_file.getbuffer())
-    tmp.flush()
-    tmp.close()
-    model = load_model_from_path(tmp.name)
-    try:
-        os.unlink(tmp.name)
-    except Exception:
-        pass
-    return model
+# Cached loader so HF/Streamlit won't reload unnecessarily
+@st.cache_resource
+def load_fixed_model():
+    return load_model_from_path(MODEL_PATH)
 
-# Attempt to load model based on user choices
+# Attempt to load the fixed model
 model = None
-if use_local and selected_local:
+if os.path.exists(MODEL_PATH):
     try:
-        model = load_model_from_path(selected_local)
-        st.sidebar.success(f"Loaded local model: {selected_local}")
+        model = load_fixed_model()
+        st.sidebar.success(f"Loaded model: {MODEL_PATH}")
     except Exception as e:
-        st.sidebar.error(f"Failed to load local model: {e}")
-
-if model is None and uploaded_model is not None:
-    try:
-        model = load_model_from_uploaded(uploaded_model)
-        st.sidebar.success(f"Loaded uploaded model: {uploaded_model.name}")
-    except Exception as e:
-        st.sidebar.error(f"Failed to load uploaded model: {e}")
-
-if model is None:
-    st.sidebar.info("No model loaded yet. Place model.joblib/model.pkl/model.h5 in repo or upload one.")
-    st.markdown(
-        """
-        **How to get a model:**\n
-        - If using scikit-learn: `joblib.dump(your_model, 'model.joblib')` or `pickle.dump(your_model, open('model.pkl','wb'))`\n
-        - If using Keras: `model.save('model.h5')` (requires TensorFlow in the environment).
-        """
-    )
+        st.sidebar.error(f"Failed to load {MODEL_PATH}: {e}")
+        model = None
+else:
+    st.sidebar.warning(f"Model file not found: {MODEL_PATH}")
+    st.sidebar.info("Add `house_price_model.h5` to the repo root (or your HF Space files) and re-run the app.")
 
 st.markdown("---")
 st.header("Input features")
 
-# NOTE: keep a small sensible feature set. Adjust to match the features your model expects.
-# Common simple house price features:
-# - OverallQual (1-10)
-# - GrLivArea (square feet)
-# - GarageCars (count)
-# - TotalBsmtSF (sq ft)
-# - FullBath (count)
-# - YearBuilt (year)
-#
-# Make sure your trained model was trained on exactly these features in this order.
-
+# Feature inputs (keep these in same order your model expects)
 col1, col2 = st.columns(2)
-
 with col1:
     overall_qual = st.slider("Overall Quality (1 - 10)", 1, 10, 6)
     gr_liv_area = st.number_input("Ground living area (sq ft)", min_value=100, max_value=10000, value=1500, step=50)
@@ -123,19 +75,15 @@ predict_button = st.button("Predict House Price")
 
 def model_predict(model_obj, features_array):
     """Unify prediction call for sklearn-like and keras models."""
-    # reshape
     X = np.array(features_array).reshape(1, -1)
-    # For Keras models: they may output a 2D array
+    # Try sklearn-like predict first
     try:
-        # scikit-learn like .predict
         if hasattr(model_obj, "predict") and not (KERAS_AVAILABLE and hasattr(model_obj, "save")):
             preds = model_obj.predict(X)
-            # sklearn regressors usually return array of shape (1,)
             if isinstance(preds, (list, np.ndarray)):
                 return float(np.squeeze(preds))
             return float(preds)
-    except Exception as e:
-        # fallthrough to try keras
+    except Exception:
         pass
 
     # Try Keras model
@@ -150,23 +98,11 @@ def model_predict(model_obj, features_array):
 
 if predict_button:
     if model is None:
-        st.error("No model loaded. Upload a model or enable local model usage in the sidebar.")
+        st.error("Model not loaded. Ensure `house_price_model.h5` exists in repo and that `tensorflow` is installed.")
     else:
         try:
             pred = model_predict(model, input_vector)
-            # If your model predicts log(price) or scaled value, adjust accordingly.
             st.success(f"Predicted house price: {pred:,.2f} (units same as model target)")
-            st.info("If the value seems off, check that the model expects these exact features and order.")
+            st.info("If value seems off, ensure model expects these features in this order and any scalers/pipelines are included.")
         except Exception as e:
             st.exception(f"Prediction failed: {e}")
-
-st.markdown("---")
-st.markdown("### Tips / Troubleshooting")
-st.markdown(
-    """
-- Ensure the model was trained on exactly **these features in the same order**.\n
-- If you trained using scaling/encoders (StandardScaler, OneHotEncoder), save and load those transformers and apply them to inputs before predicting.\n
-- To include encoders/scalers, save a pipeline object (e.g., sklearn Pipeline) so the app only needs to call `pipeline.predict(X)`.\n
-- If your model predicts a transformed target (e.g., log(price)), inverse-transform before displaying.\n
-"""
-)