Upload folder using huggingface_hub

DockerFile

@@ -1,17 +1,20 @@
 
-# Use a standard Python image
+# Use a slim Python base image for smaller size
 FROM python:3.9-slim
 
-# Set the working directory
+# Set the working directory in the container
 WORKDIR /app
 
 # Copy the requirements file and install dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy the application script
+# Copy the application file
 COPY app.py .
 
-# Command to run the Streamlit app
-# This is the industry standard for HF Streamlit Docker deployments
-CMD ["streamlit", "run", "app.py"]
+# Expose the port (Gradio/Hugging Face Spaces default to 7860)
+EXPOSE 7860
+
+# Command to run the application
+# Gradio applications are typically run with host 0.0.0.0 for container compatibility
+CMD ["python", "app.py"]

app.py

@@ -1,101 +1,84 @@
 
-import streamlit as st
-import pandas as pd
+import gradio as gr
 import joblib
+import pandas as pd
+import numpy as np
 from huggingface_hub import hf_hub_download
 
-# --- Configuration ---
+# --- Hugging Face Model Repository Details ---
+# Assuming your model and scaler are stored in this repo
 REPO_ID_MODEL = "RajendrakumarPachaiappan/engine-predictive-model"
-MODEL_FILE = "final_random_forest_model.joblib"
-SCALER_FILE = "standard_scaler.joblib"
-
-# The feature columns must match the order expected by the scaler (validated against joblib file)
-FEATURE_COLS = ['Engine_RPM', 'Lub_Oil_Pressure', 'Fuel_Pressure',
-                'Coolant_Pressure', 'Lub_Oil_Temperature', 'Coolant_Temperature']
-
-# --- Resource Loading Function ---
-@st.cache_resource(show_spinner=False) # Suppress default spinner since we use custom status messages
-def load_model_and_scaler():
-    """
-    Downloads and loads the model and scaler from Hugging Face Hub.
-    Does NOT use st. commands inside to avoid initial warnings.
-    """
-    try:
-        # Download files from Hugging Face
-        model_path = hf_hub_download(repo_id=REPO_ID_MODEL, filename=MODEL_FILE)
-        model = joblib.load(model_path)
-        scaler_path = hf_hub_download(repo_id=REPO_ID_MODEL, filename=SCALER_FILE)
-        scaler = joblib.load(scaler_path)
-        return model, scaler
-    except Exception as e:
-        # Re-raise a descriptive exception for the main script to catch
-        raise Exception(f"Failed to load required artifacts: {e}")
+MODEL_FILENAME = "final_random_forest_model.joblib"
+SCALER_FILENAME = "standard_scaler.joblib"
 
-# --- Streamlit UI and Prediction Logic ---
+# The six feature columns for input
+FEATURE_COLS = [
+    'Engine_RPM', 'Lub_Oil_Pressure', 'Fuel_Pressure',
+    'Coolant_Pressure', 'Lub_Oil_Temperature', 'Coolant_Temperature'
+]
 
-st.set_page_config(page_title="Predictive Maintenance", layout="wide")
-st.title("Engine Health Predictor ⚙️")
-
-# 1. Load Resources and Display Status
-st.info("Loading predictive model and scaler from Hugging Face Hub...")
+# --- Load Model and Scaler ---
 try:
-    # This call triggers the download/caching
-    model, scaler = load_model_and_scaler()
-    st.success("Artifacts loaded successfully! Ready for prediction.")
+    # Download and load the model
+    model_path = hf_hub_download(repo_id=REPO_ID_MODEL, filename=MODEL_FILENAME, repo_type="model")
+    model = joblib.load(model_path)
+    print(f"Model loaded successfully from {model_path}")
 
-    st.markdown("Use the sliders to simulate real-time sensor data and predict the **Engine Condition** (0=Healthy, 1=Faulty).")
+    # Download and load the scaler
+    scaler_path = hf_hub_download(repo_id=REPO_ID_MODEL, filename=SCALER_FILENAME, repo_type="model")
+    scaler = joblib.load(scaler_path)
+    print(f"Scaler loaded successfully from {scaler_path}")
 
 except Exception as e:
-    # Display error and halt execution if resources fail to load
-    st.error(f"🔴 Error loading resources: {e}")
-    st.stop()
-
+    print(f"CRITICAL ERROR: Failed to load model or scaler. Check your repository ID and filenames. Error: {e}")
+    # In a real app, you might raise an error or use a dummy model
+    model, scaler = None, None
 
-# 2. Input Sliders
-# Use columns for a cleaner layout
-col1, col2, col3 = st.columns(3)
-
-with col1:
-    Engine_RPM = st.slider("Engine RPM (rev/min)", min_value=60, max_value=2300, value=791, step=10)
-    Lub_Oil_Pressure = st.slider("Lub Oil Pressure (bar)", min_value=0.0, max_value=7.3, value=3.3, step=0.1)
-    Fuel_Pressure = st.slider("Fuel Pressure (bar)", min_value=0.0, max_value=22.0, value=6.7, step=0.1)
-
-with col2:
-    Coolant_Pressure = st.slider("Coolant Pressure (bar)", min_value=0.0, max_value=7.5, value=2.3, step=0.1)
-    Lub_Oil_Temperature = st.slider("Lub Oil Temp (°C)", min_value=71.0, max_value=90.0, value=78.0, step=0.1)
-    Coolant_Temperature = st.slider("Coolant Temp (°C)", min_value=60.0, max_value=200.0, value=78.5, step=0.5)
-
-# 3. Prediction
-if st.button("Predict Engine Condition", type="primary"):
+# --- Prediction Function ---
+def predict_engine_condition(*args):
+    """
+    Takes 6 float values as input, scales them, and predicts the engine condition.
+    """
+    if model is None or scaler is None:
+        return "ERROR: Model not loaded. Check server logs."
 
-    # a. Prepare Input
-    input_data = pd.DataFrame({
-        'Engine_RPM': [Engine_RPM],
-        'Lub_Oil_Pressure': [Lub_Oil_Pressure],
-        'Fuel_Pressure': [Fuel_Pressure],
-        'Coolant_Pressure': [Coolant_Pressure],
-        'Lub_Oil_Temperature': [Lub_Oil_Temperature],
-        'Coolant_Temperature': [Coolant_Temperature]
-    })
+    # Convert inputs to a DataFrame for scaling
+    input_data = pd.DataFrame([list(args)], columns=FEATURE_COLS)
 
-    # b. Scale Input
-    # Important: Use FEATURE_COLS to ensure correct order for the scaler
-    input_scaled = scaler.transform(input_data[FEATURE_COLS])
+    # Scale the input data using the loaded StandardScaler
+    input_scaled = scaler.transform(input_data)
 
-    # c. Make Prediction
+    # Make prediction
     prediction = model.predict(input_scaled)[0]
-    # Get the probability of the *faulty* class (1)
-    prediction_proba = model.predict_proba(input_scaled)[:, 1][0] 
-
-    # d. Display Results
-    st.divider()
-    st.subheader("Prediction Result:")
     
+    # Map the numerical prediction to a descriptive label
     if prediction == 1:
-        st.error(f"Engine Condition: **FAULTY** (Probability of Fault: {prediction_proba:.2f}) ⚠️")
-        st.write("Immediate maintenance is recommended to prevent breakdown.")
+        return "FAULTY (1) - Immediate Maintenance Required!"
     else:
-        st.success(f"Engine Condition: **HEALTHY** (Probability of Fault: {prediction_proba:.2f}) ✅")
-        st.write("Engine is operating normally. Continue regular monitoring.")
-
-    st.caption("Note: Probability of fault close to 0.5 indicates uncertainty.")
+        return "NORMAL (0) - Operating within expected parameters."
+
+# --- Gradio Interface Setup ---
+
+# Create a list of Gradio Number components for the 6 features
+input_components = [
+    gr.Number(label="Engine RPM (rev/min)", value=750),
+    gr.Number(label="Lub Oil Pressure (bar/kPa)", value=3.0),
+    gr.Number(label="Fuel Pressure (bar/kPa)", value=10.0),
+    gr.Number(label="Coolant Pressure (bar/kPa)", value=2.5),
+    gr.Number(label="Lub Oil Temperature (°C)", value=80.0),
+    gr.Number(label="Coolant Temperature (°C)", value=80.0),
+]
+
+# Define the Gradio Interface
+iface = gr.Interface(
+    fn=predict_engine_condition,
+    inputs=input_components,
+    outputs=gr.Label(label="Engine Condition Prediction", show_label=True),
+    title="Engine Predictive Maintenance Model",
+    description="Input the engine sensor readings to predict if the engine is operating normally (0) or is faulty (1). The inputs will be scaled using the pre-trained standard scaler before prediction.",
+    allow_flagging="never"
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

requirements.txt

@@ -1,6 +1,6 @@
 pandas
+numpy
 scikit-learn
 joblib
-streamlit
+gradio
 huggingface-hub
-numpy