Deploy Engine Condition Predictor

Dockerfile

@@ -1,53 +1,19 @@
-# Docker runtime for HF Space
-# # Use a slim Python base
-# FROM python:3.11-slim
-
-# # Basic hygiene
-# ENV PIP_NO_CACHE_DIR=1 #     PYTHONDONTWRITEBYTECODE=1 #     PYTHONUNBUFFERED=1
-
-# # Working directory
-# WORKDIR /app
-
-# # Copy and install Python deps first
-# RUN pip install scikit-learn==1.5.0
-# COPY requirements.txt /app/
-
-# # Install packages without dependencies to avoid conflicts
-# RUN pip install --upgrade pip && #     pip install --no-deps -r requirements.txt && #     pip install streamlit==1.39.0 pandas==2.2.2 numpy==1.26.4 scikit-learn==1.4.2 scipy==1.11.4 joblib==1.4.2 huggingface_hub==0.25.1
-
-# # Copy app code
-# COPY streamlit_app.py /app/
-# COPY README.md /app/
-
-# # Hugging Face caches
-# ENV HF_HOME=/tmp/huggingface
-# RUN mkdir -p /tmp/huggingface/hub
-
-# # Expose port
-# EXPOSE 7860
-
-# # Run Streamlit
-# CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
-
 FROM python:3.11-slim
 
 WORKDIR /app
 
 # Install system dependencies
-RUN apt-get update && apt-get install -y     gcc     g++     && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements
 COPY requirements.txt .
 
-# Install Python packages with specific versions
+# Install Python packages
 RUN pip install --upgrade pip
-RUN pip install streamlit==1.39.0
-RUN pip install pandas==2.2.2
-RUN pip install numpy==1.26.4
-RUN pip install scikit-learn==1.5.0
-RUN pip install scipy==1.14.0
-RUN pip install joblib==1.4.2
-RUN pip install huggingface_hub==0.25.1
+RUN pip install -r requirements.txt
 
 # Copy app
 COPY streamlit_app.py .

README.md

@@ -6,5 +6,4 @@ colorTo: blue
 sdk: docker
 pinned: false
 ---
-This Space runs a Streamlit app inside a custom Docker image.
-If the model repo is **private**, add a Space Secret **HF_TOKEN** (read token) and restart the Space.
+This Space runs a Streamlit app that predicts engine condition from sensor data.

requirements.txt

@@ -2,6 +2,5 @@ streamlit==1.39.0
 pandas==2.2.2
 numpy==1.26.4
 scikit-learn==1.5.0
-scipy==1.11.4
 joblib==1.4.2
 huggingface_hub==0.25.1

streamlit_app.py

@@ -1,116 +1,119 @@
-# Streamlit UI that downloads a scikit-learn pipeline from HF
-import os, sys, logging, joblib, numpy as np, pandas as pd
+
+import streamlit as st
+import joblib
+import pandas as pd
+import numpy as np
 from huggingface_hub import hf_hub_download
-from sklearn.exceptions import InconsistentVersionWarning
-import warnings
+import os
 
-warnings.filterwarnings("ignore", category=InconsistentVersionWarning)
+# Configuration
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "dhani10/engine-condition-model")
+MODEL_FILE = os.getenv("MODEL_FILE", "best_engine_model.joblib")
 
-# Silence noisy logs when not run via `streamlit run`
-if "streamlit" not in " ".join(sys.argv).lower():
-    for name in ("streamlit.runtime.scriptrunner.script_run_context",
-                 "streamlit.runtime.scriptrunner","streamlit"):
-        lg = logging.getLogger(name); lg.setLevel(logging.CRITICAL); lg.propagate=False; lg.disabled=True
+# Expected features (match your training data exactly)
+EXPECTED_COLS = [
+    'Engine rpm', 'Lub oil pressure', 'Fuel pressure',
+    'Coolant pressure', 'lub oil temp', 'Coolant temp'
+]
 
-HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "dhani10/engine-condition-model")
-MODEL_FILE    = os.getenv("MODEL_FILE", "best_engine_model.joblib")
-HF_TOKEN      = os.getenv("HF_TOKEN")  # add as Space Secret if model repo is private
-
-HF_CACHE_ROOT = os.getenv("HF_HOME", "/tmp/huggingface")
-os.environ["HF_HOME"] = HF_CACHE_ROOT
-os.environ["HF_HUB_CACHE"] = os.path.join(HF_CACHE_ROOT, "hub")
-os.makedirs(os.environ["HF_HUB_CACHE"], exist_ok=True)
-
-def _load_model_impl():
-    path = hf_hub_download(
-        repo_id=HF_MODEL_REPO,
-        filename=MODEL_FILE,
-        repo_type="model",
-        token=HF_TOKEN,                    # None if public
-        cache_dir=os.environ["HF_HUB_CACHE"],
-    )
-    return joblib.load(path)
-
-def get_expected_input_columns(clf):
-    pre = getattr(getattr(clf, "named_steps", {}), "get", lambda *_: None)("preprocessor")
-    if pre is not None:
-        transformers = getattr(pre, "transformers_", getattr(pre, "transformers", []))
-        cols = []
-        for _, __, selected in transformers:
-            if selected in (None, "drop"): continue
-            if isinstance(selected, list): cols.extend(selected)
-            elif hasattr(selected, "__iter__"): cols.extend(list(selected))
-        cols = list(dict.fromkeys(cols))
-        if cols: return cols
-    fni = getattr(clf, "feature_names_in_", None)
-    return list(fni) if fni is not None else [
-        "engine_rpm","lub_oil_pressure","fuel_pressure",
-        "coolant_pressure","lub_oil_temp","coolant_temp"
-    ]
-
-def coerce_numeric_df(df: pd.DataFrame) -> pd.DataFrame:
-    out = df.copy()
-    for c in out.columns: out[c] = pd.to_numeric(out[c], errors="ignore")
-    return out
-
-def predict_with_pipeline(model, X: pd.DataFrame):
-    y = model.predict(X); p = None
-    if hasattr(model, "predict_proba"):
-        try:
-            P = model.predict_proba(X); p = P[:,1] if (P.ndim==2 and P.shape[1]>=2) else P.ravel()
-        except Exception: pass
-    return y, p
+@st.cache_resource
+def load_model():
+    """Load the model from Hugging Face Hub"""
+    try:
+        model_path = hf_hub_download(
+            repo_id=HF_MODEL_REPO,
+            filename=MODEL_FILE,
+            repo_type="model",
+            token=os.getenv("HF_TOKEN")
+        )
+        model = joblib.load(model_path)
+        st.success("Model loaded successfully!")
+        return model
+    except Exception as e:
+        st.error(f"Failed to load model: {e}")
+        return None
 
 def main():
-    import streamlit as st
-    st.set_page_config(page_title="Engine Condition Predictor", layout="centered")
+    st.set_page_config(
+        page_title="Engine Condition Predictor",
+        layout="centered",
+        page_icon="🏭"
+    )
+
     st.title("Predictive Maintenance — Engine Condition")
-    st.caption(f"Model: {HF_MODEL_REPO} → {MODEL_FILE}")
+    st.markdown("Monitor engine health using real-time sensor data")
+    st.caption(f"Model: {HF_MODEL_REPO}")
+
+    # Load model
+    with st.spinner("Loading AI model..."):
+        model = load_model()
 
-    @st.cache_resource(show_spinner=True)
-    def load_model(): return _load_model_impl()
+    if model is None:
+        st.stop()
 
-    model = load_model()
-    EXPECTED_COLS = get_expected_input_columns(model)
+    # Input form
+    st.header("🔧 Engine Sensor Readings")
 
-    with st.form("predict_form"):
+    with st.form("prediction_form"):
         col1, col2 = st.columns(2)
+
         with col1:
-            engine_rpm       = st.number_input("Engine RPM", min_value=0, max_value=5000, value=1200, step=10)
-            lub_oil_pressure = st.number_input("Lubricating Oil Pressure (bar)", value=3.0, step=0.1)
-            fuel_pressure    = st.number_input("Fuel Pressure (bar)", value=5.0, step=0.1)
+            engine_rpm = st.slider("Engine RPM", 100, 2500, 1200)
+            lub_oil_pressure = st.slider("Lub Oil Pressure (bar)", 0.5, 7.0, 3.0, 0.1)
+            fuel_pressure = st.slider("Fuel Pressure (bar)", 0.5, 20.0, 6.0, 0.1)
+
         with col2:
-            coolant_pressure = st.number_input("Coolant Pressure (bar)", value=2.0, step=0.1)
-            lub_oil_temp     = st.number_input("Lubricating Oil Temperature (°C)", value=80.0, step=0.1)
-            coolant_temp     = st.number_input("Coolant Temperature (°C)", value=75.0, step=0.1)
-        submitted = st.form_submit_button("Predict")
+            coolant_pressure = st.slider("Coolant Pressure (bar)", 0.5, 7.0, 2.0, 0.1)
+            lub_oil_temp = st.slider("Lub Oil Temp (°C)", 70.0, 110.0, 80.0, 0.1)
+            coolant_temp = st.slider("Coolant Temp (°C)", 60.0, 100.0, 75.0, 0.1)
+
+        submitted = st.form_submit_button("Analyze Engine Condition", type="primary")
 
     if submitted:
-        row = pd.DataFrame({c:[np.nan] for c in EXPECTED_COLS})
-        for k,v in {
-            "engine_rpm":engine_rpm,"lub_oil_pressure":lub_oil_pressure,"fuel_pressure":fuel_pressure,
-            "coolant_pressure":coolant_pressure,"lub_oil_temp":lub_oil_temp,"coolant_temp":coolant_temp
-        }.items():
-            if k in row.columns: row.at[0,k]=v
+        # Create input data with EXACT column names from training
+        input_data = pd.DataFrame([{
+            'Engine rpm': engine_rpm,
+            'Lub oil pressure': lub_oil_pressure,
+            'Fuel pressure': fuel_pressure,
+            'Coolant pressure': coolant_pressure,
+            'lub oil temp': lub_oil_temp,
+            'Coolant temp': coolant_temp
+        }])
+
         try:
-            X = coerce_numeric_df(row)
-            y, p = predict_with_pipeline(model, X)
-            pred = int(y[0])
-            if pred==1:
-                msg = "⚠️ Faulty Engine Detected"
-                if p is not None: msg += f" (Confidence: {float(p[0]):.2f})"
-                import streamlit as st; st.error(msg)
+            # Make prediction
+            prediction = model.predict(input_data)[0]
+            probability = model.predict_proba(input_data)[0]
+
+            # Display results
+            st.header("Analysis Results")
+
+            if prediction == 1:
+                st.error("**FAULTY ENGINE DETECTED**")
+                st.progress(probability[1])
+                st.warning(f"**Risk Probability:** {probability[1]*100:.1f}%")
+                st.markdown("""
+                **Recommended Actions:**
+                - Schedule immediate maintenance
+                - Inspect lubrication system
+                - Check cooling system
+                """)
             else:
-                msg = "✅ Engine is Healthy"
-                if p is not None: msg += f" (Confidence: {1 - float(p[0]):.2f})"
-                import streamlit as st; st.success(msg)
-            with st.expander("Inputs sent to the model"):
-                st.dataframe(X)
+                st.success("**ENGINE OPERATING NORMALLY**")
+                st.progress(probability[0])
+                st.info(f"**Health Score:** {probability[0]*100:.1f}%")
+                st.markdown("""
+                **Status:** Continue routine monitoring
+                **Next maintenance:** As scheduled
+                """)
+
+            # Show input data
+            with st.expander("View Input Data"):
+                st.dataframe(input_data)
+
         except Exception as e:
-            import streamlit as st
-            st.error(f"Prediction failed: {e}")
-            st.write("Expected columns:", EXPECTED_COLS)
+            st.error(f"Prediction error: {str(e)}")
+            st.info("Please check that the model expects the correct feature names")
 
 if __name__ == "__main__":
-    if "streamlit" in " ".join(sys.argv).lower(): main()
-    else: print("Tip: run this app with: streamlit run streamlit_app.py")
+    main()