Update app.py

app.py

@@ -1,184 +1,423 @@
 """
-DIAGNOSTIC VERSION - Streamlit App for Debugging
-This version has extensive logging to find the exact failure point
+Streamlit Application for Engine Predictive Maintenance
+Production Version
 """
 
 import streamlit as st
-import sys
+import pandas as pd
 import os
+import sys
 
-print("=" * 80, file=sys.stderr)
-print("DIAGNOSTIC APP STARTING", file=sys.stderr)
-print("=" * 80, file=sys.stderr)
+# Print to console (will show in HF Space logs)
+print("=" * 70, file=sys.stderr)
+print("APP STARTING - INITIALIZATION", file=sys.stderr)
+print("=" * 70, file=sys.stderr)
 
-# Test 1: Page Config
-try:
-    print("\n[TEST 1] Setting page config...", file=sys.stderr)
-    st.set_page_config(
-        page_title="Engine Predictive Maintenance - DIAGNOSTIC",
-        page_icon="🔧",
-        layout="wide"
-    )
-    print("✓ Page config successful", file=sys.stderr)
-except Exception as e:
-    print(f"✗ Page config failed: {e}", file=sys.stderr)
-    import traceback
-    print(traceback.format_exc(), file=sys.stderr)
+# Page Configuration MUST be first
+st.set_page_config(
+    page_title="Engine Predictive Maintenance",
+    page_icon="🔧",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-# Test 2: Imports
-print("\n[TEST 2] Testing imports...", file=sys.stderr)
+# Import after page config
 try:
-    print("  Importing pandas...", file=sys.stderr)
-    import pandas as pd
-    print("  ✓ pandas imported", file=sys.stderr)
-    
-    print("  Importing huggingface_hub...", file=sys.stderr)
+    print("Importing huggingface_hub...", file=sys.stderr)
     from huggingface_hub import hf_hub_download, login
-    print("  ✓ huggingface_hub imported", file=sys.stderr)
-    
-    print("  Importing joblib...", file=sys.stderr)
+    print("Importing joblib...", file=sys.stderr)
     import joblib
-    print("  ✓ joblib imported", file=sys.stderr)
-    
     print("✓ All imports successful", file=sys.stderr)
 except Exception as e:
-    print(f"✗ Import failed: {e}", file=sys.stderr)
-    import traceback
-    print(traceback.format_exc(), file=sys.stderr)
-    st.error(f"Import error: {e}")
+    print(f"✗ Import error: {e}", file=sys.stderr)
+    st.error(f"Import failed: {e}")
     st.stop()
 
-# Test 3: Environment Variables
-print("\n[TEST 3] Checking environment variables...", file=sys.stderr)
-hf_token = os.environ.get("HF_TOKEN")
-print(f"  HF_TOKEN exists: {hf_token is not None}", file=sys.stderr)
-if hf_token:
-    print(f"  HF_TOKEN length: {len(hf_token)}", file=sys.stderr)
-    print(f"  HF_TOKEN starts with: {hf_token[:7]}...", file=sys.stderr)
-else:
-    print("  ⚠ WARNING: HF_TOKEN not found!", file=sys.stderr)
-
-# Test 4: Hugging Face Authentication
-print("\n[TEST 4] Testing Hugging Face authentication...", file=sys.stderr)
-if hf_token:
-    try:
-        print("  Attempting login...", file=sys.stderr)
-        login(token=hf_token)
-        print("  ✓ Login successful", file=sys.stderr)
-    except Exception as e:
-        print(f"  ✗ Login failed: {e}", file=sys.stderr)
-        import traceback
-        print(traceback.format_exc(), file=sys.stderr)
-else:
-    print("  ⚠ Skipping login (no token)", file=sys.stderr)
+# CRITICAL: Feature columns must EXACTLY match model training
+FEATURE_COLUMNS = [
+    "Engine rpm",
+    "Lub oil pressure",
+    "Fuel pressure",
+    "Coolant pressure",
+    "lub oil temp",
+    "Coolant temp"
+]
 
-# Test 5: Model Download
-print("\n[TEST 5] Testing model download...", file=sys.stderr)
-model = None
-model_error = None
+# 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)
 
-try:
-    print("  Repository: Quantum9999/xgb-predictive-maintenance", file=sys.stderr)
-    print("  Filename: xgb_tuned_model.joblib", file=sys.stderr)
-    print("  Cache dir: /tmp/hf_cache", file=sys.stderr)
-    print("  Starting download...", file=sys.stderr)
+
+@st.cache_resource
+def load_model():
+    """Load model from Hugging Face with detailed logging and retries"""
     
-    model_path = hf_hub_download(
-        repo_id="Quantum9999/xgb-predictive-maintenance",
-        filename="xgb_tuned_model.joblib",
-        token=hf_token,
-        cache_dir="/tmp/hf_cache"
-    )
+    print("\n" + "=" * 70, file=sys.stderr)
+    print("LOADING MODEL FROM HUGGING FACE", file=sys.stderr)
+    print("=" * 70, file=sys.stderr)
     
-    print(f"  ✓ Download successful!", file=sys.stderr)
-    print(f"  Model path: {model_path}", file=sys.stderr)
+    max_retries = 3
+    retry_count = 0
     
-    # Test 6: Model Loading
-    print("\n[TEST 6] Testing model loading...", file=sys.stderr)
-    print("  Loading model into memory...", file=sys.stderr)
-    model = joblib.load(model_path)
-    print("  ✓ Model loaded successfully!", file=sys.stderr)
+    while retry_count < max_retries:
+        try:
+            # Get HF_TOKEN and clean it
+            hf_token = os.environ.get("HF_TOKEN")
+            if hf_token:
+                hf_token = hf_token.strip()  # Remove any newlines or whitespace
+            
+            print(f"HF_TOKEN found: {hf_token is not None}", file=sys.stderr)
+            
+            if hf_token:
+                print("Authenticating with Hugging Face...", file=sys.stderr)
+                login(token=hf_token)
+                print("✓ Authentication successful", file=sys.stderr)
+            else:
+                print("⚠ No HF_TOKEN - attempting public access", file=sys.stderr)
+            
+            # Download model
+            print("\nDownloading model...", file=sys.stderr)
+            print("  Repo: Quantum9999/xgb-predictive-maintenance", file=sys.stderr)
+            print("  File: xgb_tuned_model.joblib", file=sys.stderr)
+            
+            model_path = hf_hub_download(
+                repo_id="Quantum9999/xgb-predictive-maintenance",
+                filename="xgb_tuned_model.joblib",
+                token=hf_token,
+                cache_dir="/tmp/hf_cache"
+            )
+            print(f"✓ Model downloaded: {model_path}", file=sys.stderr)
+            
+            # Load model
+            print("Loading model into memory...", file=sys.stderr)
+            model = joblib.load(model_path)
+            print("✓ Model loaded successfully", file=sys.stderr)
+            
+            # Verify model features
+            if hasattr(model, 'feature_names_in_'):
+                print(f"Model expects features: {model.feature_names_in_}", file=sys.stderr)
+            
+            print("=" * 70 + "\n", file=sys.stderr)
+            
+            return model, None
+            
+        except Exception as e:
+            retry_count += 1
+            error_msg = f"Model loading attempt {retry_count}/{max_retries} failed: {str(e)}"
+            print(f"✗ {error_msg}", file=sys.stderr)
+            
+            if retry_count < max_retries:
+                import time
+                wait_time = 2 * retry_count
+                print(f"Retrying in {wait_time} seconds...", file=sys.stderr)
+                time.sleep(wait_time)
+            else:
+                import traceback
+                print(f"Final traceback:\n{traceback.format_exc()}", file=sys.stderr)
+                print("=" * 70 + "\n", file=sys.stderr)
+                return None, error_msg
+
+
+def main():
+    """Main application"""
     
-    # Test 7: Model Properties
-    print("\n[TEST 7] Checking model properties...", file=sys.stderr)
-    print(f"  Model type: {type(model)}", file=sys.stderr)
-    if hasattr(model, 'feature_names_in_'):
-        print(f"  Expected features: {model.feature_names_in_}", file=sys.stderr)
-    if hasattr(model, 'n_features_in_'):
-        print(f"  Number of features: {model.n_features_in_}", file=sys.stderr)
+    print("Starting main application...", file=sys.stderr)
     
-except Exception as e:
-    model_error = str(e)
-    print(f"  ✗ Model loading failed: {e}", file=sys.stderr)
-    import traceback
-    print(traceback.format_exc(), file=sys.stderr)
+    # 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 with progress indicator
+    with st.spinner("Loading AI model... This may take a moment."):
+        model, error = load_model()
+    
+    if model is None:
+        st.error(f"❌ Failed to load prediction model")
+        st.code(error)
+        
+        with st.expander("🔍 Troubleshooting"):
+            st.write("**Possible Issues:**")
+            st.write("1. HF_TOKEN not set in Space secrets")
+            st.write("2. Model repository is private")
+            st.write("3. Model filename is incorrect")
+            st.write("4. Network connectivity issue")
+            
+            st.write("\n**Current Configuration:**")
+            st.write(f"- HF_TOKEN set: {os.environ.get('HF_TOKEN') is not None}")
+            st.write("- Expected repo: Quantum9999/xgb-predictive-maintenance")
+            st.write("- Expected file: xgb_tuned_model.joblib")
+        
+        st.stop()
+    
+    st.success("✓ Model loaded successfully!")
+
+    # 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
+        """)
+        
+        st.header("🎯 How to Use")
+        st.markdown("""
+        1. Enter current sensor readings
+        2. Click 'Predict Engine Condition'
+        3. Review prediction and confidence
+        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
+        """)
 
-print("\n" + "=" * 80, file=sys.stderr)
-print("DIAGNOSTIC TESTS COMPLETED", file=sys.stderr)
-print("=" * 80 + "\n", file=sys.stderr)
+    # Main content
+    st.header("📝 Enter Engine Sensor Readings")
+    st.markdown("---")
 
-# Display results to user
-st.title("🔍 Diagnostic Mode")
-st.write("This is a diagnostic version to identify the issue.")
+    # Input columns
+    col1, col2 = st.columns(2)
 
-st.header("Test Results:")
+    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"
+        )
 
-st.subheader("1. Environment Variables")
-if hf_token:
-    st.success(f"✓ HF_TOKEN found (length: {len(hf_token)})")
-else:
-    st.error("✗ HF_TOKEN not found in environment")
+    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"
+        )
 
-st.subheader("2. Model Loading")
-if model is not None:
-    st.success("✓ Model loaded successfully!")
-    st.write(f"Model type: {type(model)}")
+    # Prediction button
+    st.markdown("---")
     
-    if hasattr(model, 'feature_names_in_'):
-        st.write("Expected features:")
-        st.code(str(model.feature_names_in_))
-    
-    # Try a test prediction
-    st.subheader("3. Test Prediction")
-    try:
-        import pandas as pd
-        test_input = pd.DataFrame([{
-            "Engine rpm": 791.0,
-            "Lub oil pressure": 3.3,
-            "Fuel pressure": 6.7,
-            "Coolant pressure": 2.3,
-            "lub oil temp": 77.6,
-            "Coolant temp": 78.4
+    if st.button("🔍 Predict Engine Condition", use_container_width=True, type="primary"):
+        # Create input DataFrame with exact column names
+        input_df = 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:
+            print(f"Making prediction with input: {input_df.to_dict()}", file=sys.stderr)
+            
+            # Make prediction
+            prediction = model.predict(input_df)[0]
+            proba = model.predict_proba(input_df)[0]
+            
+            print(f"Prediction: {prediction}, Probabilities: {proba}", file=sys.stderr)
+
+            # 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
+                    """)
         
-        prediction = model.predict(test_input)[0]
-        proba = model.predict_proba(test_input)[0]
-        
-        st.success("✓ Test prediction successful!")
-        st.write(f"Prediction: {prediction}")
-        st.write(f"Probabilities: {proba}")
-        
+        except Exception as e:
+            error_msg = f"Prediction error: {e}"
+            print(f"✗ {error_msg}", file=sys.stderr)
+            import traceback
+            print(f"Traceback:\n{traceback.format_exc()}", file=sys.stderr)
+            
+            st.error(f"❌ {error_msg}")
+            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__":
+    print("Entering main()...", file=sys.stderr)
+    try:
+        main()
+        print("✓ Main completed successfully", file=sys.stderr)
     except Exception as e:
-        st.error(f"✗ Test prediction failed: {e}")
-        st.code(str(e))
-        
-else:
-    st.error("✗ Model loading failed!")
-    if model_error:
-        st.code(model_error)
-    st.warning("Check Container logs for detailed traceback")
-
-st.divider()
-st.info("📝 Check the 'Container' logs tab for detailed diagnostic information")
-
-st.header("Next Steps:")
-if model is not None:
-    st.success("✅ Everything works! The issue might be with the healthcheck timing.")
-    st.write("Recommendation: Just wait longer for the Space to become healthy, or increase healthcheck start-period to 90s")
-else:
-    st.error("There's a real issue with model loading.")
-    st.write("Common causes:")
-    st.write("1. HF_TOKEN is wrong or expired")
-    st.write("2. Model file doesn't exist in the repository")
-    st.write("3. Network/connectivity issue")
-    st.write("4. File permissions issue")
+        print(f"✗ FATAL ERROR: {e}", file=sys.stderr)
+        import traceback
+        print(f"Traceback:\n{traceback.format_exc()}", file=sys.stderr)
+        st.error(f"Application error: {e}")