Initial deploy

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+env/
+venv/
+.venv/
+.DS_Store
+*.csv
+*.pkl
+*.joblib

README.md

@@ -1,12 +1,14 @@
 ---
-title: Predictive Maintenance
-emoji: 🏢
-colorFrom: green
-colorTo: indigo
+title: Engine Maintenance Prediction
+emoji: 🔧
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 3.35.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Engine Maintenance Prediction
+
+Predict engine condition using ML.

app.py

@@ -0,0 +1,66 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import os
+import sys
+
+sys.path.append('.')
+
+try:
+    from model_loader import load_engine_model
+    print("✅ Model loader imported!")
+except ImportError as e:
+    print(f"Import error for model_loader: {e}")
+    class MockModel:
+        def predict(self, X):
+            return {'prediction': 0, 'probability': 0.50, 'condition': 'Normal'}
+        def predict_proba(self, X):
+            return np.array([[0.50, 0.50]])
+    def load_engine_model(model_name="dhani10/engine-condition-model"):
+        print("⚠️ Using Mock Model.")
+        return MockModel()
+
+# Default model repo (adjust if needed)
+MODEL_REPO = os.getenv("MODEL_REPO", "dhani10/engine-condition-model")
+model = load_engine_model(MODEL_REPO)
+print(f"Model loaded: {type(model)}")
+
+def predict_condition(engine_rpm, oil_pressure, fuel_pressure, coolant_pressure, oil_temp, coolant_temp):
+    input_data = {
+        'Engine rpm': engine_rpm,
+        'Lub oil pressure': oil_pressure,
+        'Fuel pressure': fuel_pressure,
+        'Coolant pressure': coolant_pressure,
+        'lub oil temp': oil_temp,
+        'Coolant temp': coolant_temp
+    }
+    result = model.predict(input_data)
+    color = "green" if result.get('condition','Error') == 'Normal' else "red"
+    emoji = "✅" if result.get('condition','Error') == 'Normal' else "⚠️"
+    proba = result.get('probability', 0.0)
+    return f"<h2 style='color:{color};'>{emoji} {result.get('condition','Error')}</h2><p>Confidence: {proba:.2%}</p>"
+
+with gr.Blocks(title="Engine Maintenance Prediction") as demo:
+    gr.Markdown("# 🚀 Engine Maintenance Prediction")
+    gr.Markdown("Enter sensor readings to predict engine condition.")
+
+    with gr.Row():
+        with gr.Column():
+            engine_rpm       = gr.Number(label="Engine RPM", value=791.0, step=1.0)
+            oil_pressure     = gr.Number(label="Lub Oil Pressure (bar)", value=3.3, step=0.01)
+            fuel_pressure    = gr.Number(label="Fuel Pressure (bar)", value=6.6, step=0.01)
+            coolant_pressure = gr.Number(label="Coolant Pressure (bar)", value=2.3, step=0.01)
+            oil_temp         = gr.Number(label="Lub Oil Temp (°C)", value=77.6, step=0.1)
+            coolant_temp     = gr.Number(label="Coolant Temp (°C)", value=78.4, step=0.1)
+            btn = gr.Button("Predict", variant="primary")
+        with gr.Column():
+            output = gr.HTML(label="Prediction Result")
+
+    btn.click(
+        predict_condition,
+        inputs=[engine_rpm, oil_pressure, fuel_pressure, coolant_pressure, oil_temp, coolant_temp],
+        outputs=output
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

model_loader.py

@@ -0,0 +1,86 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from huggingface_hub import hf_hub_download, login
+
+class EngineConditionModel:
+    def __init__(self, model_name):
+        self.model_name = model_name
+        self.model = None
+        self.scaler = None
+        self.features = [
+            'Engine rpm', 'Lub oil pressure', 'Fuel pressure',
+            'Coolant pressure', 'lub oil temp', 'Coolant temp'
+        ]
+        self.load_model()
+
+    def load_model(self):
+        try:
+            hf_token = os.getenv("HF_TOKEN")
+            if hf_token:
+                try:
+                    login(token=hf_token)
+                except Exception as e:
+                    print(f"HF login warning: {e}")
+
+            model_path = hf_hub_download(
+                repo_id=self.model_name,
+                filename="model/best_engine_model.joblib",  # adjust if different
+                repo_type="model",
+                token=hf_token
+            )
+            self.model = joblib.load(model_path)
+            print("✅ Loaded model artifact.")
+
+            # Optional scaler
+            try:
+                scaler_path = hf_hub_download(
+                    repo_id=self.model_name,
+                    filename="scaler.joblib",
+                    repo_type="model",
+                    token=hf_token
+                )
+                self.scaler = joblib.load(scaler_path)
+                print("✅ Loaded scaler.")
+            except Exception:
+                self.scaler = None
+        except Exception as e:
+            print(f"❌ HF Hub load error: {e}
+⚠️ Falling back to dummy model.")
+            from sklearn.ensemble import RandomForestClassifier
+            self.model = RandomForestClassifier(n_estimators=10, random_state=42)
+            X_dummy = np.random.rand(10, len(self.features))
+            y_dummy = np.random.randint(0, 2, 10)
+            self.model.fit(X_dummy, y_dummy)
+            self.scaler = None
+
+    def preprocess(self, data):
+        df = pd.DataFrame([data]) if isinstance(data, dict) else data.copy()
+        X = df[self.features]
+        if self.scaler is not None:
+            return self.scaler.transform(X)
+        return X.values
+
+    def predict(self, data):
+        try:
+            X = self.preprocess(data)
+            pred = int(self.model.predict(X)[0])
+            if hasattr(self.model, "predict_proba"):
+                proba = self.model.predict_proba(X)
+                conf = float(proba[0, 1]) if proba.shape[1] > 1 else float(proba[0, 0])
+            else:
+                conf = 0.5
+            condition = 'Maintenance Required' if pred == 1 else 'Normal'
+            return {"prediction": pred, "probability": conf, "condition": condition}
+        except Exception as e:
+            print(f"❌ Prediction error: {e}")
+            return {"prediction": -1, "probability": 0.0, "condition": "Error"}
+
+_engine_model_instance = None
+
+def load_engine_model(model_name="dhani10/engine-condition-model"):
+    global _engine_model_instance
+    if _engine_model_instance is None:
+        _engine_model_instance = EngineConditionModel(model_name)
+    return _engine_model_instance

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=3.35.0
+pandas>=1.5.0
+numpy>=1.21.0
+scikit-learn>=1.0.0
+joblib>=1.2.0
+huggingface-hub>=0.20.0