Deploy Predictive Maintenance application

Dockerfile

@@ -1,20 +1,34 @@
-FROM python:3.13.5-slim
 
-WORKDIR /app
+FROM python:3.9-slim
+
+WORKDIR /code
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
 
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
+    software-properties-common \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN groupadd -r appuser && useradd -r -g appuser appuser && \
+    chown -R appuser:appuser /code
 
-RUN pip3 install -r requirements.txt
+USER appuser
 
-EXPOSE 8501
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:7860/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,27 @@
 ---
 title: Predictive Maintenance
-emoji: 🚀
+emoji: 🔧
 colorFrom: red
-colorTo: red
+colorTo: gray
 sdk: docker
-app_port: 8501
-tags:
-- streamlit
+app_port: 7860
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
+license: mit
 ---
 
-# Welcome to Streamlit!
+# Predictive Maintenance — Engine Health Monitor 🔧
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+An intelligent ML-powered system that monitors engine sensor data and predicts failure risk in real time.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Features
+- **Real-time Predictions**: Instant engine health scoring
+- **Interactive Interface**: User-friendly Streamlit web application
+- **Multiple Algorithms**: Best model selected from 6 different algorithms
+- **MLOps Integration**: Complete pipeline with experiment tracking
+
+## Technical Stack
+- **Backend**: Python, Scikit-learn, XGBoost
+- **Frontend**: Streamlit
+- **ML Tracking**: MLflow
+- **Deployment**: Docker, HuggingFace Spaces

app.py

@@ -0,0 +1,144 @@
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from huggingface_hub import hf_hub_download
+import plotly.graph_objects as go
+
+st.set_page_config(
+    page_title="Predictive Maintenance",
+    page_icon="🔧",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+st.markdown("""
+<style>
+    .main-header { font-size: 2.5rem; font-weight: bold; text-align: center; color: #e85d04; margin-bottom: 2rem; }
+    .prediction-box { padding: 1rem; margin: 1rem 0; border-radius: 10px; text-align: center; }
+    .failure-prediction { background-color: #f8d7da; color: #721c24; border: 2px solid #f5c6cb; }
+    .healthy-prediction { background-color: #d4edda; color: #155724; border: 2px solid #c3e6cb; }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_resource
+def load_model():
+    try:
+        model_path = hf_hub_download(
+            repo_id="shashidj/Predictive-Maintenance-Model",
+            filename="model.pkl"
+        )
+        return joblib.load(model_path)
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+def predict_engine_condition(model, input_data):
+    try:
+        prediction = model.predict(input_data)[0]
+        prediction_proba = model.predict_proba(input_data)[0] if hasattr(model, 'predict_proba') else [0.5, 0.5]
+        return prediction, prediction_proba
+    except Exception as e:
+        st.error(f"Prediction error: {e}")
+        return None, None
+
+def main():
+    st.markdown('<div class="main-header">🔧 Predictive Maintenance — Engine Health Monitor</div>', unsafe_allow_html=True)
+
+    model = load_model()
+    if model is None:
+        st.error("Failed to load model. Please check your configuration.")
+        return
+
+    st.sidebar.header("📊 Model Information")
+    st.sidebar.info("""
+    **Algorithm**: Best performing model from 6 algorithms  
+    **Features**: Engine sensor readings  
+    **Purpose**: Predict engine failure risk  
+    **Accuracy**: Optimized through hyperparameter tuning
+    """)
+
+    st.header("Engine Sensor Readings")
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("🔩 Mechanical Parameters")
+        engine_rpm = st.number_input("Engine RPM", min_value=0.0, max_value=5000.0, value=700.0, step=10.0)
+        lub_oil_pressure = st.number_input("Lub Oil Pressure (bar)", min_value=0.0, max_value=20.0, value=2.5, step=0.1)
+        fuel_pressure = st.number_input("Fuel Pressure (bar)", min_value=0.0, max_value=50.0, value=11.8, step=0.1)
+
+    with col2:
+        st.subheader("🌡️ Temperature & Cooling")
+        coolant_pressure = st.number_input("Coolant Pressure (bar)", min_value=0.0, max_value=10.0, value=3.2, step=0.1)
+        lub_oil_temp = st.number_input("Lub Oil Temperature (°C)", min_value=0.0, max_value=200.0, value=84.0, step=0.5)
+        coolant_temp = st.number_input("Coolant Temperature (°C)", min_value=0.0, max_value=200.0, value=81.6, step=0.5)
+
+    if st.button("🔮 Predict Engine Condition", type="primary"):
+        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]
+        })
+
+        prediction, prediction_proba = predict_engine_condition(model, input_data)
+
+        if prediction is not None:
+            st.header("🎯 Prediction Results")
+            if prediction == 1:
+                st.markdown(f"""
+                <div class="prediction-box failure-prediction">
+                    <h3>⚠️ ENGINE FAILURE RISK DETECTED</h3>
+                    <p><strong>Failure Probability:</strong> {prediction_proba[1]:.2%}</p>
+                    <p>Immediate maintenance inspection is recommended!</p>
+                </div>
+                """, unsafe_allow_html=True)
+                st.error("💡 Action Required: Schedule maintenance before next operation cycle.")
+            else:
+                st.markdown(f"""
+                <div class="prediction-box healthy-prediction">
+                    <h3>✅ ENGINE IS HEALTHY</h3>
+                    <p><strong>Healthy Probability:</strong> {prediction_proba[0]:.2%}</p>
+                    <p>Engine is operating within normal parameters.</p>
+                </div>
+                """, unsafe_allow_html=True)
+                st.success("💡 No immediate action required. Continue scheduled monitoring.")
+
+            fig = go.Figure(data=[go.Bar(
+                x=['Healthy', 'Failure Risk'],
+                y=[prediction_proba[0], prediction_proba[1]],
+                marker_color=['#90ee90', '#ff7f7f']
+            )])
+            fig.update_layout(
+                title="Engine Condition Probability Distribution",
+                xaxis_title="Condition",
+                yaxis_title="Probability",
+                yaxis=dict(range=[0, 1], tickformat='.0%')
+            )
+            st.plotly_chart(fig, use_container_width=True)
+
+            st.subheader("📋 Sensor Reading Summary")
+            summary_df = pd.DataFrame({
+                'Sensor': ['Engine RPM', 'Lub Oil Pressure', 'Fuel Pressure',
+                           'Coolant Pressure', 'Lub Oil Temp', 'Coolant Temp'],
+                'Value': [f"{engine_rpm:.1f} RPM", f"{lub_oil_pressure:.2f} bar",
+                          f"{fuel_pressure:.2f} bar", f"{coolant_pressure:.2f} bar",
+                          f"{lub_oil_temp:.1f} °C", f"{coolant_temp:.1f} °C"]
+            })
+            st.table(summary_df)
+
+    st.markdown("---")
+    st.markdown("""
+    **About this Application:**  
+    This Predictive Maintenance system uses machine learning to monitor engine sensor data and predict failure risk in real time.  
+    Built with MLOps best practices including experiment tracking, model versioning, and automated deployment.
+
+    **🔧 Technical Stack:** Python • Scikit-learn • MLflow • HuggingFace • Streamlit • Docker
+    """)
+
+if __name__ == "__main__":
+    main()

deploy_to_hf_space.py

@@ -0,0 +1,81 @@
+
+import os
+from pathlib import Path
+from huggingface_hub import HfApi, create_repo
+from huggingface_hub.utils import RepositoryNotFoundError
+
+def deploy_to_huggingface_space():
+    SPACE_NAME = "Predictive-Maintenance"
+    REPO_ID = f"shashidj/{SPACE_NAME}"
+
+    print("🚀 Starting deployment to HuggingFace Spaces...")
+    print(f"📦 Target Space: {REPO_ID}")
+
+    api = HfApi(token=os.getenv("HF_TOKEN"))
+
+    try:
+        api.repo_info(repo_id=REPO_ID, repo_type="space")
+        print(f"📍 Space '{REPO_ID}' already exists")
+    except RepositoryNotFoundError:
+        print(f"🆕 Creating new space '{REPO_ID}'...")
+        create_repo(repo_id=REPO_ID, repo_type="space", space_sdk="docker", private=False)
+        print("✅ Space created successfully")
+
+    deployment_dir = Path("predictive_maintenance_mlops/deployment")
+    required_files = ["Dockerfile", "app.py", "requirements.txt"]
+
+    print("\n🔍 Verifying deployment files...")
+    for file_name in required_files:
+        if (deployment_dir / file_name).exists():
+            print(f"✅ {file_name} found")
+        else:
+            print(f"❌ {file_name} missing")
+            return False
+
+    readme_content = """---
+title: Predictive Maintenance
+emoji: 🔧
+colorFrom: red
+colorTo: gray
+sdk: docker
+app_port: 7860
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Predictive Maintenance — Engine Health Monitor 🔧
+
+An intelligent ML-powered system that monitors engine sensor data and predicts failure risk in real time.
+
+## Features
+- **Real-time Predictions**: Instant engine health scoring
+- **Interactive Interface**: User-friendly Streamlit web application
+- **Multiple Algorithms**: Best model selected from 6 different algorithms
+- **MLOps Integration**: Complete pipeline with experiment tracking
+
+## Technical Stack
+- **Backend**: Python, Scikit-learn, XGBoost
+- **Frontend**: Streamlit
+- **ML Tracking**: MLflow
+- **Deployment**: Docker, HuggingFace Spaces
+"""
+    (deployment_dir / "README.md").write_text(readme_content)
+    print("✅ README.md created")
+
+    print("\n📤 Uploading files to HuggingFace Space...")
+    api.upload_folder(
+        folder_path=str(deployment_dir),
+        repo_id=REPO_ID,
+        repo_type="space",
+        commit_message="Deploy Predictive Maintenance application"
+    )
+    print(f"\n🎉 Deployment completed!")
+    print(f"🌐 https://huggingface.co/spaces/{REPO_ID}")
+    return True
+
+if __name__ == "__main__":
+    if not os.getenv("HF_TOKEN"):
+        print("❌ HF_TOKEN environment variable not set!")
+    else:
+        deploy_to_huggingface_space()

requirements.txt

@@ -1,3 +1,15 @@
-altair
-pandas
-streamlit
+
+streamlit==1.28.1
+pandas==2.0.3
+numpy==1.24.3
+scikit-learn==1.3.0
+joblib==1.3.2
+xgboost==1.7.6
+huggingface-hub==0.17.3
+plotly==5.15.0
+matplotlib==3.7.2
+seaborn==0.12.2
+requests==2.31.0
+python-dotenv==1.0.0
+streamlit-option-menu==0.3.6
+psutil==5.9.5