Upload folder using huggingface_hub

Dockerfile

@@ -1,20 +1,23 @@
-FROM python:3.13.5-slim
+FROM python:3.10-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Copy requirements and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy application file
+COPY app.py .
 
-RUN pip3 install -r requirements.txt
+# Expose Streamlit default port
+EXPOSE 7860
 
-EXPOSE 8501
+# Set environment variables for Streamlit
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run the application
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,315 @@
+"""
+Streamlit Application for Engine Predictive Maintenance
+Production-ready deployment with proper error handling
+"""
+
+import streamlit as st
+import pandas as pd
+from huggingface_hub import hf_hub_download, login
+import joblib
+import os
+
+# Page Configuration
+st.set_page_config(
+    page_title="Engine Predictive Maintenance",
+    page_icon="🔧",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+.main-header {
+    font-size: 42px;
+    font-weight: bold;
+    color: #1f77b4;
+    text-align: center;
+    margin-bottom: 10px;
+}
+.sub-header {
+    font-size: 18px;
+    color: #555;
+    text-align: center;
+    margin-bottom: 30px;
+}
+.prediction-box {
+    padding: 20px;
+    border-radius: 10px;
+    text-align: center;
+    font-size: 24px;
+    font-weight: bold;
+    margin-top: 20px;
+}
+.normal {
+    background-color: #d4edda;
+    color: #155724;
+    border: 2px solid #c3e6cb;
+}
+.maintenance {
+    background-color: #f8d7da;
+    color: #721c24;
+    border: 2px solid #f5c6cb;
+}
+.metric-card {
+    background-color: #f8f9fa;
+    padding: 15px;
+    border-radius: 8px;
+    border-left: 4px solid #1f77b4;
+}
+</style>
+""", unsafe_allow_html=True)
+
+
+@st.cache_resource
+def load_model():
+    """Load model from Hugging Face with authentication"""
+    try:
+        # Authenticate
+        hf_token = os.environ.get("HF_TOKEN")
+        if hf_token:
+            login(token=hf_token)
+        
+        # Download model
+        model_path = hf_hub_download(
+            repo_id="Quantum9999/xgb-predictive-maintenance",
+            filename="xgb_tuned_model.joblib",
+            token=hf_token
+        )
+        
+        # Load model
+        model = joblib.load(model_path)
+        return model, None
+        
+    except Exception as e:
+        return None, str(e)
+
+
+def main():
+    # Header
+    st.markdown(
+        '<div class="main-header">🔧 Engine Predictive Maintenance System</div>',
+        unsafe_allow_html=True
+    )
+    st.markdown(
+        '<div class="sub-header">AI-powered engine health monitoring & failure prediction</div>',
+        unsafe_allow_html=True
+    )
+
+    # Load model
+    model, error = load_model()
+    
+    if model is None:
+        st.error(f"❌ Failed to load prediction model: {error}")
+        st.info("Please check Hugging Face configuration and ensure HF_TOKEN is set correctly.")
+        return
+
+    # Sidebar
+    with st.sidebar:
+        st.header("ℹ️ About")
+        st.write(
+            "This application predicts engine maintenance needs using "
+            "machine learning analysis of 6 critical sensor parameters."
+        )
+        
+        st.header("📊 Model Information")
+        st.markdown("""
+        - **Algorithm**: XGBoost Classifier
+        - **Features**: 6 sensor readings
+        - **Target Classes**: 
+          - 0: Normal Operation
+          - 1: Maintenance Required
+        - **Training Data**: 19,535 records
+        - **Test Accuracy**: ~92%
+        """)
+        
+        st.header("🎯 How to Use")
+        st.markdown("""
+        1. Enter current sensor readings in the input fields
+        2. Click **'Predict Engine Condition'**
+        3. Review prediction and confidence scores
+        4. Take action based on results
+        """)
+        
+        st.header("📈 Sensor Ranges")
+        st.markdown("""
+        **Normal Operating Ranges:**
+        - RPM: 161 - 2,239
+        - Lub Oil Pressure: 0.003 - 7.3 bar
+        - Fuel Pressure: 0.003 - 21.1 bar
+        - Coolant Pressure: 0.002 - 7.5 bar
+        - Lub Oil Temp: 71 - 90 °C
+        - Coolant Temp: 62 - 196 °C
+        """)
+
+    # Main content
+    st.header("📝 Enter Engine Sensor Readings")
+    st.markdown("---")
+
+    # Create two columns for input
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("⚙️ Speed & Pressure Sensors")
+        
+        engine_rpm = st.number_input(
+            "Engine RPM (Revolutions per Minute)",
+            min_value=100.0,
+            max_value=2500.0,
+            value=791.0,
+            step=10.0,
+            help="Engine speed - Normal range: 161-2,239 RPM"
+        )
+        
+        lub_oil_pressure = st.number_input(
+            "Lubrication Oil Pressure (bar)",
+            min_value=0.0,
+            max_value=10.0,
+            value=3.3,
+            step=0.1,
+            help="Lubricating oil pressure - Normal range: 0.003-7.266 bar"
+        )
+        
+        fuel_pressure = st.number_input(
+            "Fuel Pressure (bar)",
+            min_value=0.0,
+            max_value=25.0,
+            value=6.7,
+            step=0.1,
+            help="Fuel delivery pressure - Normal range: 0.003-21.138 bar"
+        )
+
+    with col2:
+        st.subheader("🌡️ Temperature & Coolant Sensors")
+        
+        coolant_pressure = st.number_input(
+            "Coolant Pressure (bar)",
+            min_value=0.0,
+            max_value=10.0,
+            value=2.3,
+            step=0.1,
+            help="Coolant system pressure - Normal range: 0.002-7.479 bar"
+        )
+        
+        lub_oil_temp = st.number_input(
+            "Lubrication Oil Temperature (°C)",
+            min_value=60.0,
+            max_value=100.0,
+            value=77.6,
+            step=0.5,
+            help="Lubricating oil temperature - Normal range: 71.3-89.6 °C"
+        )
+        
+        coolant_temp = st.number_input(
+            "Coolant Temperature (°C)",
+            min_value=50.0,
+            max_value=200.0,
+            value=78.4,
+            step=0.5,
+            help="Engine coolant temperature - Normal range: 61.7-195.5 °C"
+        )
+
+    # Prediction button
+    st.markdown("---")
+    
+    if st.button("🔍 Predict Engine Condition", use_container_width=True, type="primary"):
+        # Prepare input data
+        input_df = 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_temp,
+            "Coolant Temperature": coolant_temp
+        }])
+
+        try:
+            # Make prediction
+            prediction = model.predict(input_df)[0]
+            proba = model.predict_proba(input_df)[0]
+
+            # Display results
+            st.markdown("---")
+            st.header("🎯 Prediction Result")
+
+            if prediction == 0:
+                st.markdown(
+                    '<div class="prediction-box normal">✅ Engine Operating Normally</div>',
+                    unsafe_allow_html=True
+                )
+                st.success("✓ No maintenance required at this time. Engine is functioning within normal parameters.")
+            else:
+                st.markdown(
+                    '<div class="prediction-box maintenance">⚠️ Maintenance Required</div>',
+                    unsafe_allow_html=True
+                )
+                st.warning("⚠ Engine shows signs of potential failure. Schedule maintenance as soon as possible to prevent breakdown.")
+
+            # Confidence scores
+            st.subheader("📊 Prediction Confidence")
+            
+            conf_col1, conf_col2 = st.columns(2)
+            
+            with conf_col1:
+                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                st.metric(
+                    label="Normal Operation Probability",
+                    value=f"{proba[0]:.2%}",
+                    help="Confidence that engine is operating normally"
+                )
+                st.markdown('</div>', unsafe_allow_html=True)
+            
+            with conf_col2:
+                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                st.metric(
+                    label="Maintenance Required Probability",
+                    value=f"{proba[1]:.2%}",
+                    help="Confidence that engine requires maintenance"
+                )
+                st.markdown('</div>', unsafe_allow_html=True)
+
+            # Input summary
+            with st.expander("📋 View Input Summary"):
+                st.dataframe(
+                    input_df.T.rename(columns={0: "Value"}),
+                    use_container_width=True
+                )
+                
+            # Recommendations
+            with st.expander("💡 Recommendations"):
+                if prediction == 0:
+                    st.markdown("""
+                    **Current Status: Healthy**
+                    - Continue regular monitoring
+                    - Maintain current maintenance schedule
+                    - Monitor for any sudden changes in sensor readings
+                    - Schedule next routine inspection as planned
+                    """)
+                else:
+                    st.markdown("""
+                    **Immediate Actions Required:**
+                    - Schedule comprehensive engine inspection
+                    - Check lubrication system
+                    - Inspect cooling system
+                    - Review fuel delivery system
+                    - Monitor engine closely until serviced
+                    - Consider reducing operational load
+                    """)
+        
+        except Exception as e:
+            st.error(f"❌ Prediction error: {e}")
+            st.info("Please verify all sensor values are within valid ranges and try again.")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        "<p style='text-align: center; color: #666; font-size: 14px;'>"
+        "🤖 Built with XGBoost & Streamlit | 🤗 Model hosted on Hugging Face<br>"
+        "Developed as part of ML Deployment & Automation Project"
+        "</p>",
+        unsafe_allow_html=True
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+streamlit==1.31.0
+pandas==2.1.4
+numpy==1.26.3
+scikit-learn==1.4.0
+xgboost==2.0.3
+joblib==1.3.2
+huggingface-hub==0.20.3