Spaces:

iStillWaters
/

Engine-Reliability-Dashboard-v2

Sleeping

App Files Files Community

iStillWaters commited on Feb 9

Commit

527087e

verified ·

1 Parent(s): e199b60

Update app.py

Browse files

Files changed (1) hide show

app.py +669 -518

app.py CHANGED Viewed

@@ -3,10 +3,9 @@ import pandas as pd
 import joblib
 import os
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 from huggingface_hub import hf_hub_download
 from datetime import datetime
-import json
 # --- CONFIGURATION ---
 HF_USERNAME = os.getenv("HF_USERNAME", "iStillWaters")
@@ -16,21 +15,18 @@ MODEL_REPO_ID = f"{HF_USERNAME}/{MODEL_REPO_NAME}"
 MODEL_FILENAME = "best_engine_model.pkl"
 SCALER_FILENAME = "scaler.joblib"
-# Sensor thresholds for warnings
-SENSOR_THRESHOLDS = {
-    'rpm_warning': 2000,
-    'rpm_critical': 2300,
-    'coolant_temp_warning': 100,
-    'coolant_temp_critical': 120,
-    'oil_pressure_low': 2.0,
-    'oil_pressure_critical': 1.5,
-    'fuel_pressure_low': 5.0,
-}
-# --- LOAD ARTIFACTS ---
 @st.cache_resource
 def load_artifacts():
-    """Load model and scaler from HuggingFace Hub with error handling"""
     try:
         model_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=MODEL_FILENAME)
         scaler_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=SCALER_FILENAME)
@@ -40,84 +36,437 @@ def load_artifacts():
     except Exception as e:
         return None, None, str(e)
-# --- SESSION STATE INITIALIZATION ---
-def init_session_state():
-    """Initialize session state variables"""
-    if 'history' not in st.session_state:
-        st.session_state.history = []
-    if 'alert_threshold' not in st.session_state:
-        st.session_state.alert_threshold = 0.7
-    if 'dark_mode' not in st.session_state:
-        st.session_state.dark_mode = True
-    if 'show_recommendations' not in st.session_state:
-        st.session_state.show_recommendations = True
 # --- HELPER FUNCTIONS ---
-def create_gauge(value, title, min_val, max_val, thresholds=None, color="blue"):
-    """Create an enhanced gauge chart with color-coded zones"""
-    if thresholds is None:
-        # Default thresholds: green (0-60%), yellow (60-80%), red (80-100%)
-        thresholds = [min_val, min_val + (max_val-min_val)*0.6,
-                     min_val + (max_val-min_val)*0.8, max_val]
     fig = go.Figure(go.Indicator(
-        mode = "gauge+number+delta",
         value = value,
-        title = {'text': title, 'font': {'size': 18}},
-        delta = {'reference': (max_val + min_val) / 2, 'relative': False},
-        domain = {'x': [0, 1], 'y': [0, 1]},
         gauge = {
-            'axis': {'range': [min_val, max_val]},
-            'bar': {'color': color},
-            'bgcolor': "white",
             'borderwidth': 2,
-            'bordercolor': "gray",
             'steps': [
-                {'range': [thresholds[0], thresholds[1]], 'color': "#90EE90"},
-                {'range': [thresholds[1], thresholds[2]], 'color': "#FFD700"},
-                {'range': [thresholds[2], thresholds[3]], 'color': "#FFB6C1"}
             ],
-            'threshold': {
-                'line': {'color': "red", 'width': 4},
-                'thickness': 0.75,
-                'value': thresholds[2]
-            }
         }
     ))
-    fig.update_layout(height=250, margin=dict(l=20, r=20, t=50, b=20))
     return fig
-def validate_inputs(rpm, fuel_p, lub_oil_p, coolant_temp, coolant_p, lub_oil_t):
-    """Validate sensor readings and return warnings"""
-    warnings = []
-    critical = []
-    # RPM checks
-    if rpm > SENSOR_THRESHOLDS['rpm_critical']:
-        critical.append("🔴 CRITICAL: RPM exceeding safe limits!")
-    elif rpm > SENSOR_THRESHOLDS['rpm_warning']:
-        warnings.append("⚠️ RPM approaching redline")
-    # Coolant temperature checks
-    if coolant_temp > SENSOR_THRESHOLDS['coolant_temp_critical']:
-        critical.append("🔴 CRITICAL: Engine overheating!")
-    elif coolant_temp > SENSOR_THRESHOLDS['coolant_temp_warning']:
-        warnings.append("⚠️ Coolant temperature elevated")
-    # Oil pressure checks
-    if lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_critical']:
-        critical.append("🔴 CRITICAL: Oil pressure dangerously low!")
-    elif lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_low']:
-        warnings.append("⚠️ Oil pressure below normal")
-    # Fuel pressure checks
-    if fuel_p < SENSOR_THRESHOLDS['fuel_pressure_low']:
-        warnings.append("⚠️ Fuel pressure low")
-    return warnings, critical
-def prepare_input_data(rpm, lub_oil_p, fuel_p, coolant_p, lub_oil_t, coolant_temp):
-    """Prepare input data for model prediction"""
     return pd.DataFrame({
         'Engine rpm': [rpm],
         'Lub oil pressure': [lub_oil_p],
@@ -128,7 +477,7 @@ def prepare_input_data(rpm, lub_oil_p, fuel_p, coolant_p, lub_oil_t, coolant_tem
     })
 def run_prediction(model, scaler, input_df):
-    """Run model prediction with error handling"""
     try:
         scaled = scaler.transform(input_df)
         pred = model.predict(scaled)[0]
@@ -137,474 +486,276 @@ def run_prediction(model, scaler, input_df):
     except Exception as e:
         return None, None, str(e)
-def get_status_info(prob):
-    """Get status badge and color based on probability"""
-    if prob > 0.75:
-        return "🔴 CRITICAL", "#ff4b4b", "CRITICAL FAILURE RISK"
-    elif prob > 0.5:
-        return "🟡 WARNING", "#ffa500", "ELEVATED FAILURE RISK"
-    elif prob > 0.25:
-        return "🟠 CAUTION", "#ff8c00", "MODERATE RISK"
-    else:
-        return "🟢 HEALTHY", "#00cc00", "SYSTEMS NOMINAL"
-def get_recommendations(input_df, prob, warnings, critical):
-    """Generate actionable recommendations based on sensor readings and prediction"""
     recommendations = []
-    # Critical alerts first
-    if critical:
-        recommendations.extend(critical)
-        recommendations.append("🚨 IMMEDIATE ACTION REQUIRED - SHUT DOWN ENGINE")
-    # Sensor-specific recommendations
     rpm = input_df['Engine rpm'].values[0]
     coolant_temp = input_df['Coolant temp'].values[0]
     lub_oil_p = input_df['Lub oil pressure'].values[0]
     fuel_p = input_df['Fuel pressure'].values[0]
-    if coolant_temp > SENSOR_THRESHOLDS['coolant_temp_warning']:
-        recommendations.append("🔧 Check coolant level and radiator for blockages")
-        recommendations.append("🔧 Inspect water pump operation")
-    if lub_oil_p < SENSOR_THRESHOLDS['oil_pressure_low']:
-        recommendations.append("🔧 Check engine oil level immediately")
-        recommendations.append("🔧 Inspect oil pump and filter for blockages")
-    if fuel_p < SENSOR_THRESHOLDS['fuel_pressure_low']:
-        recommendations.append("🔧 Check fuel filter for clogs")
-        recommendations.append("🔧 Inspect fuel pump performance")
-    if rpm > SENSOR_THRESHOLDS['rpm_warning'] and prob > 0.5:
-        recommendations.append("🔧 Reduce engine load immediately")
-        recommendations.append("🔧 Schedule comprehensive engine inspection")
-    # Model-based recommendations
-    if prob > 0.7:
-        recommendations.append("📅 Schedule immediate maintenance inspection")
-        recommendations.append("📊 Consider engine diagnostics scan")
-    elif prob > 0.4:
-        recommendations.append("📅 Schedule preventive maintenance within 48 hours")
-    if not recommendations and not warnings:
-        recommendations.append("✅ All systems operating within normal parameters")
-        recommendations.append("📅 Continue regular maintenance schedule")
     return recommendations
-def calculate_feature_importance(input_df):
-    """Calculate normalized feature importance scores"""
-    rpm_score = input_df['Engine rpm'].values[0] / 2500
-    coolant_score = input_df['Coolant temp'].values[0] / 200
-    oil_score = max(0, 1 - (input_df['Lub oil pressure'].values[0] / 10))
-    fuel_score = input_df['Fuel pressure'].values[0] / 25
-    return {
-        'Engine RPM': rpm_score,
-        'Coolant Temperature': coolant_score,
-        'Oil Pressure (Risk)': oil_score,
-        'Fuel Pressure': fuel_score
-    }
-def create_history_chart():
-    """Create historical trend chart"""
-    if len(st.session_state.history) < 2:
-        return None
-    hist_df = pd.DataFrame(st.session_state.history)
-    fig = make_subplots(
-        rows=2, cols=1,
-        subplot_titles=('Failure Probability Over Time', 'Engine RPM Over Time'),
-        vertical_spacing=0.15
-    )
-    # Probability trend
-    fig.add_trace(
-        go.Scatter(
-            x=hist_df['timestamp'],
-            y=hist_df['probability']*100,
-            mode='lines+markers',
-            name='Failure Risk (%)',
-            line=dict(color='red', width=2),
-            marker=dict(size=8)
-        ),
-        row=1, col=1
-    )
-    # Add threshold line
-    fig.add_hline(
-        y=st.session_state.alert_threshold*100,
-        line_dash="dash",
-        line_color="orange",
-        annotation_text="Alert Threshold",
-        row=1, col=1
-    )
-    # RPM trend
-    fig.add_trace(
-        go.Scatter(
-            x=hist_df['timestamp'],
-            y=hist_df['rpm'],
-            mode='lines+markers',
-            name='RPM',
-            line=dict(color='cyan', width=2),
-            marker=dict(size=8)
-        ),
-        row=2, col=1
-    )
-    fig.update_xaxes(title_text="Time", row=2, col=1)
-    fig.update_yaxes(title_text="Probability (%)", row=1, col=1)
-    fig.update_yaxes(title_text="RPM", row=2, col=1)
-    fig.update_layout(height=500, showlegend=True)
-    return fig
-def export_report(input_df, prob, pred, warnings, critical, recommendations):
-    """Generate downloadable report"""
-    report = {
-        'Timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
-        'Status': 'FAILURE RISK' if pred == 1 else 'OPERATIONAL',
-        'Failure Probability': f"{prob*100:.2f}%",
-        'Engine RPM': input_df['Engine rpm'].values[0],
-        'Fuel Pressure (Bar)': input_df['Fuel pressure'].values[0],
-        'Oil Pressure': input_df['Lub oil pressure'].values[0],
-        'Oil Temperature': input_df['lub oil temp'].values[0],
-        'Coolant Pressure': input_df['Coolant pressure'].values[0],
-        'Coolant Temperature': input_df['Coolant temp'].values[0],
-        'Warnings': '; '.join(warnings) if warnings else 'None',
-        'Critical Alerts': '; '.join(critical) if critical else 'None',
-        'Recommendations': '; '.join(recommendations[:3]) if recommendations else 'None'
-    }
-    return pd.DataFrame([report])
-# --- MAIN APP ---
 def main():
-    # Page config
-    st.set_page_config(
-        layout="wide",
-        page_title="Engine Health Monitor",
-        page_icon="🏎️",
-        initial_sidebar_state="expanded"
-    )
-    # Initialize session state
-    init_session_state()
-    # Load model
     model, scaler, error = load_artifacts()
-    # Check if model loaded successfully
-    if model is None or scaler is None:
-        st.error(f"⚠️ Failed to load model: {error}")
-        st.info("Please check your HuggingFace configuration and ensure the model repository is accessible.")
         st.stop()
-    # --- SIDEBAR ---
-    with st.sidebar:
-        st.image("https://img.icons8.com/color/96/000000/engine.png", width=80)
-        st.title("⚙️ Settings")
-        # Model info
-        st.subheader("Model Information")
-        st.info(f"**Repository:** {MODEL_REPO_ID}")
-        st.info(f"**Model File:** {MODEL_FILENAME}")
-        # Settings
-        st.subheader("Configuration")
-        st.session_state.alert_threshold = st.slider(
-            "Alert Threshold",
-            0.0, 1.0,
-            st.session_state.alert_threshold,
-            help="Probability threshold for failure alerts"
-        )
-        st.session_state.show_recommendations = st.checkbox(
-            "Show Recommendations",
-            st.session_state.show_recommendations
-        )
-        auto_refresh = st.checkbox("🔄 Auto-refresh (10s)", value=False)
-        # History management
-        st.subheader("History")
-        if st.session_state.history:
-            st.metric("Total Analyses", len(st.session_state.history))
-            if st.button("Clear History"):
-                st.session_state.history = []
-                st.rerun()
         else:
-            st.info("No analysis history yet")
-        # Info
-        st.divider()
-        st.caption("🏎️ Digital Twin Engine Monitor v2.0")
-        st.caption("Powered by Streamlit & ML")
-    # --- CUSTOM CSS ---
-    st.markdown("""
-        <style>
-        .main {background-color: #0e1117;}
-        h1 {text-align: center; color: white;}
-        .diag-header {
-            text-align: center;
-            font-weight: bold;
-            margin-bottom: 20px;
-        }
-        div.stButton > button {
-            font-size: 20px !important;
-            font-weight: bold !important;
-            padding: 10px 20px !important;
-            width: 100%;
-            background-color: #ff4b4b;
-            color: white;
-            border-radius: 10px;
-            margin: 0 auto;
-            display: block;
-        }
-        .metric-card {
-            background-color: #1e1e1e;
-            padding: 15px;
-            border-radius: 10px;
-            border-left: 4px solid #ff4b4b;
-        }
-        .status-badge {
-            padding: 10px 20px;
-            border-radius: 20px;
-            font-weight: bold;
-            text-align: center;
-            font-size: 24px;
-        }
-        </style>
-        """, unsafe_allow_html=True)
-    # --- HEADER ---
-    st.title("🏎️ Digital Twin: Engine Health Monitor")
-    st.markdown("### Real-time Predictive Maintenance System")
-    # --- DASHBOARD INPUTS ---
-    col_left, col_center, col_right = st.columns([1.2, 2, 1.2])
-    with col_left:
-        st.subheader("⛽ Fuel & Air Systems")
-        rpm = st.slider("Engine RPM", 0, 2500, 750, step=50)
-        fuel_p = st.slider("Fuel Pressure (Bar)", 0.0, 25.0, 6.2, step=0.1)
-        st.plotly_chart(
-            create_gauge(rpm, "RPM", 0, 2500, color="cyan"),
-            use_container_width=True
-        )
-    with col_right:
-        st.subheader("🛢️ Cooling & Lubrication")
-        lub_oil_p = st.slider("Oil Pressure (Bar)", 0.0, 10.0, 3.16, step=0.1)
-        coolant_temp = st.slider("Coolant Temp (°C)", 0.0, 200.0, 80.0, step=1.0)
-        st.plotly_chart(
-            create_gauge(coolant_temp, "Coolant Temp (°C)", 0, 200, color="orange"),
-            use_container_width=True
-        )
-    # Additional sensors
-    with st.expander("🔧 Advanced Sensor Configuration"):
-        col_ex1, col_ex2 = st.columns(2)
-        with col_ex1:
-            coolant_p = st.number_input(
-                "Coolant Pressure (Bar)",
-                0.0, 10.0, 2.16, step=0.1,
-                help="Cooling system pressure"
-            )
-        with col_ex2:
-            lub_oil_t = st.number_input(
-                "Oil Temperature (°C)",
-                0.0, 150.0, 80.0, step=1.0,
-                help="Lubrication oil temperature"
-            )
-    # --- PREDICTION CENTER ---
-    with col_center:
-        st.markdown("<h2 class='diag-header'>🩺 Real-Time Diagnostics</h2>", unsafe_allow_html=True)
-        # Validation warnings (before prediction)
-        warnings, critical = validate_inputs(rpm, fuel_p, lub_oil_p, coolant_temp, coolant_p, lub_oil_t)
-        if critical:
-            for alert in critical:
-                st.error(alert)
-        if warnings:
-            with st.expander("⚠️ Sensor Warnings", expanded=True):
-                for warning in warnings:
-                    st.warning(warning)
-        # Analysis button - centered
-        st.markdown("<div style='margin-top: 20px; margin-bottom: 20px;'></div>", unsafe_allow_html=True)
-        col_btn_left, col_btn_center, col_btn_right = st.columns([1, 2, 1])
-        with col_btn_center:
-            analyze_clicked = st.button("🔍 Analyze Engine Status")
-        if analyze_clicked:
-            # Prepare input
-            input_df = prepare_input_data(rpm, lub_oil_p, fuel_p, coolant_p, lub_oil_t, coolant_temp)
-            # Run prediction
-            pred, prob, pred_error = run_prediction(model, scaler, input_df)
-            if pred_error:
-                st.error(f"Prediction error: {pred_error}")
-            else:
-                # Store in history
-                st.session_state.history.append({
-                    'timestamp': datetime.now(),
-                    'rpm': rpm,
-                    'probability': prob,
-                    'status': 'FAIL' if pred == 1 else 'OK',
-                    'coolant_temp': coolant_temp,
-                    'oil_pressure': lub_oil_p
-                })
-                # Get status
-                status_badge, status_color, status_text = get_status_info(prob)
-                # Create probability gauge
-                gauge_color = "red" if prob > 0.5 else "green"
-                fig_prob = go.Figure(go.Indicator(
-                    mode = "gauge+number",
-                    value = prob * 100,
-                    title = {'text': "Failure Probability (%)", 'font': {'size': 20}},
-                    number = {'suffix': "%", 'font': {'size': 40}},
-                    gauge = {
-                        'axis': {'range': [0, 100]},
-                        'bar': {'color': gauge_color},
-                        'steps': [
-                            {'range': [0, 25], 'color': "#90EE90"},
-                            {'range': [25, 50], 'color': "#FFD700"},
-                            {'range': [50, 75], 'color': "#FFA500"},
-                            {'range': [75, 100], 'color': "#FF6B6B"}
-                        ],
-                        'threshold': {
-                            'line': {'color': "red", 'width': 4},
-                            'thickness': 0.75,
-                            'value': st.session_state.alert_threshold * 100
-                        }
-                    }
-                ))
-                fig_prob.update_layout(height=300, margin=dict(l=20, r=20, t=50, b=20))
-                # Display results
-                st.markdown(
-                    f"<div class='status-badge' style='background-color: {status_color}20; "
-                    f"color: {status_color}; border: 2px solid {status_color};'>"
-                    f"{status_badge}</div>",
-                    unsafe_allow_html=True
-                )
-                st.markdown("<br>", unsafe_allow_html=True)
-                # Side-by-side layout
-                res_col1, res_col2 = st.columns([1, 1], gap="medium")
-                # Image based on status
-                if pred == 1 or prob > st.session_state.alert_threshold:
-                    img_url = "https://freesvg.org/img/check-engine.png"
-                else:
-                    img_url = "https://img.freepik.com/premium-vector/check-engine-light-icon-vector-illustration_529846-559.jpg"
-                with res_col1:
-                    st.markdown(
-                        f'<div style="display: flex; justify-content: center; align-items: center; height: 300px;">'
-                        f'<img src="{img_url}" style="max-height: 250px; max-width: 100%; border-radius: 10px;">'
-                        f'</div>',
-                        unsafe_allow_html=True
-                    )
-                with res_col2:
-                    st.plotly_chart(fig_prob, use_container_width=True)
-                # Feature importance
-                if prob > 0.3:
-                    st.markdown("---")
-                    st.subheader("⚡ Key Risk Factors")
-                    feature_scores = calculate_feature_importance(input_df)
-                    sorted_factors = sorted(feature_scores.items(), key=lambda x: x[1], reverse=True)
-                    cols = st.columns(4)
-                    for idx, (factor, severity) in enumerate(sorted_factors):
-                        with cols[idx]:
-                            st.metric(
-                                factor,
-                                f"{severity*100:.1f}%",
-                                delta=None,
-                                help=f"Normalized risk score for {factor}"
-                            )
-                # Recommendations
-                if st.session_state.show_recommendations:
-                    st.markdown("---")
-                    recommendations = get_recommendations(input_df, prob, warnings, critical)
-                    if recommendations:
-                        st.subheader("🛠️ Recommended Actions")
-                        for i, rec in enumerate(recommendations, 1):
-                            st.write(f"{i}. {rec}")
-                # Export report
-                st.markdown("---")
-                report_df = export_report(input_df, prob, pred, warnings, critical, recommendations)
-                csv = report_df.to_csv(index=False)
-                col_export1, col_export2 = st.columns(2)
-                with col_export1:
-                    st.download_button(
-                        "📥 Download Report (CSV)",
-                        csv,
-                        f"engine_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-                        "text/csv",
-                        use_container_width=True
-                    )
-                with col_export2:
-                    json_report = report_df.to_json(orient='records', indent=2)
-                    st.download_button(
-                        "📥 Download Report (JSON)",
-                        json_report,
-                        f"engine_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-                        "application/json",
-                        use_container_width=True
-                    )
-        else:
-            st.info("👆 Adjust the sensor sliders above and click **Analyze Engine Status** to run diagnostics")
-    # --- HISTORICAL TRENDS ---
-    if st.session_state.history:
-        st.markdown("---")
-        st.subheader("📊 Historical Analysis")
-        trend_chart = create_history_chart()
-        if trend_chart:
-            st.plotly_chart(trend_chart, use_container_width=True)
-            # Summary statistics
-            hist_df = pd.DataFrame(st.session_state.history)
-            col_stat1, col_stat2, col_stat3, col_stat4 = st.columns(4)
-            with col_stat1:
-                st.metric("Average Risk", f"{hist_df['probability'].mean()*100:.1f}%")
-            with col_stat2:
-                st.metric("Max Risk", f"{hist_df['probability'].max()*100:.1f}%")
-            with col_stat3:
-                failures = (hist_df['status'] == 'FAIL').sum()
-                st.metric("Failure Alerts", failures)
-            with col_stat4:
-                st.metric("Total Analyses", len(hist_df))
-    # Auto-refresh logic
-    if auto_refresh:
-        import time
-        time.sleep(10)
-        st.rerun()
 if __name__ == "__main__":
     main()

 import joblib
 import os
 import plotly.graph_objects as go
 from huggingface_hub import hf_hub_download
 from datetime import datetime
+import base64
 # --- CONFIGURATION ---
 HF_USERNAME = os.getenv("HF_USERNAME", "iStillWaters")
 MODEL_FILENAME = "best_engine_model.pkl"
 SCALER_FILENAME = "scaler.joblib"
+# --- PAGE CONFIGURATION ---
+st.set_page_config(
+    page_title="Engine Predictive Maintenance",
+    page_icon="🔧",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+# --- LOAD MODEL ---
 @st.cache_resource
 def load_artifacts():
+    """Load ML model and scaler"""
     try:
         model_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=MODEL_FILENAME)
         scaler_path = hf_hub_download(repo_id=MODEL_REPO_ID, filename=SCALER_FILENAME)
     except Exception as e:
         return None, None, str(e)
+# --- SESSION STATE ---
+if 'predictions' not in st.session_state:
+    st.session_state.predictions = []
+if 'current_status' not in st.session_state:
+    st.session_state.current_status = 'unknown'
+# --- CUSTOM CSS ---
+def load_css():
+    st.markdown("""
+    <style>
+    @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&family=Rajdhani:wght@300;400;600;700&display=swap');
+    /* Global Styles */
+    .stApp {
+        background: linear-gradient(135deg, #0a0e27 0%, #1a1f3a 50%, #0a0e27 100%);
+        color: #e0e6ed;
+    }
+    .main {
+        background: transparent;
+    }
+    /* Hide Streamlit Elements */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    /* Title Section */
+    .main-title {
+        font-family: 'Orbitron', sans-serif;
+        font-size: 3.5rem;
+        font-weight: 900;
+        text-align: center;
+        background: linear-gradient(135deg, #00d4ff 0%, #0090ff 50%, #0051ff 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        margin-bottom: 0.5rem;
+        text-transform: uppercase;
+        letter-spacing: 3px;
+        text-shadow: 0 0 30px rgba(0, 212, 255, 0.3);
+    }
+    .subtitle {
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.2rem;
+        text-align: center;
+        color: #8b95a5;
+        margin-bottom: 3rem;
+        letter-spacing: 2px;
+    }
+    /* Dashboard Container */
+    .dashboard-container {
+        position: relative;
+        width: 100%;
+        max-width: 1400px;
+        margin: 0 auto;
+        padding: 2rem;
+    }
+    /* Central Engine Icon Container */
+    .engine-container {
+        position: relative;
+        width: 320px;
+        height: 320px;
+        margin: 4rem auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+    /* Rotating Glow Ring */
+    .glow-ring {
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        border-radius: 50%;
+        border: 3px solid transparent;
+        background: linear-gradient(45deg, transparent 30%, var(--ring-color, #00d4ff) 50%, transparent 70%);
+        animation: rotate 4s linear infinite;
+        opacity: 0.6;
+    }
+    @keyframes rotate {
+        from { transform: rotate(0deg); }
+        to { transform: rotate(360deg); }
+    }
+    /* Engine Circle Background */
+    .engine-circle {
+        position: absolute;
+        width: 280px;
+        height: 280px;
+        border-radius: 50%;
+        background: radial-gradient(circle at 30% 30%,
+            rgba(26, 31, 58, 0.9) 0%,
+            rgba(10, 14, 39, 0.95) 100%);
+        border: 4px solid var(--border-color, #1a4d7a);
+        box-shadow:
+            0 0 40px var(--glow-color, rgba(0, 212, 255, 0.4)),
+            inset 0 0 30px rgba(0, 0, 0, 0.5);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.5s ease;
+    }
+    /* Engine Icon */
+    .engine-icon {
+        font-size: 8rem;
+        filter: drop-shadow(0 0 20px var(--glow-color, rgba(0, 212, 255, 0.6)));
+        transition: all 0.5s ease;
+    }
+    /* Status Colors */
+    .status-healthy {
+        --border-color: #00ff88;
+        --glow-color: rgba(0, 255, 136, 0.5);
+        --ring-color: #00ff88;
+    }
+    .status-warning {
+        --border-color: #ffaa00;
+        --glow-color: rgba(255, 170, 0, 0.5);
+        --ring-color: #ffaa00;
+    }
+    .status-critical {
+        --border-color: #ff3366;
+        --glow-color: rgba(255, 51, 102, 0.5);
+        --ring-color: #ff3366;
+    }
+    .status-unknown {
+        --border-color: #4a5568;
+        --glow-color: rgba(74, 85, 104, 0.3);
+        --ring-color: #4a5568;
+    }
+    /* Probability Display */
+    .probability-display {
+        position: absolute;
+        bottom: -60px;
+        left: 50%;
+        transform: translateX(-50%);
+        font-family: 'Orbitron', sans-serif;
+        font-size: 1.8rem;
+        font-weight: 700;
+        color: var(--border-color, #00d4ff);
+        text-shadow: 0 0 10px var(--glow-color, rgba(0, 212, 255, 0.5));
+        white-space: nowrap;
+    }
+    /* Parameter Cards Grid */
+    .params-grid {
+        display: grid;
+        grid-template-columns: repeat(3, 1fr);
+        gap: 2rem;
+        margin-top: 4rem;
+        max-width: 1200px;
+        margin-left: auto;
+        margin-right: auto;
+    }
+    /* Individual Parameter Card */
+    .param-card {
+        background: linear-gradient(135deg,
+            rgba(26, 31, 58, 0.6) 0%,
+            rgba(10, 14, 39, 0.8) 100%);
+        border: 2px solid rgba(0, 212, 255, 0.2);
+        border-radius: 16px;
+        padding: 1.5rem;
+        backdrop-filter: blur(10px);
+        transition: all 0.3s ease;
+        position: relative;
+        overflow: hidden;
+    }
+    .param-card::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 3px;
+        background: linear-gradient(90deg,
+            transparent 0%,
+            var(--accent-color, #00d4ff) 50%,
+            transparent 100%);
+        opacity: 0;
+        transition: opacity 0.3s ease;
+    }
+    .param-card:hover {
+        border-color: var(--accent-color, #00d4ff);
+        box-shadow: 0 8px 30px rgba(0, 212, 255, 0.15);
+        transform: translateY(-4px);
+    }
+    .param-card:hover::before {
+        opacity: 1;
+    }
+    /* Parameter Icon */
+    .param-icon {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+        display: inline-block;
+    }
+    /* Parameter Label */
+    .param-label {
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.1rem;
+        font-weight: 600;
+        color: #8b95a5;
+        margin-bottom: 0.5rem;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+    /* Parameter Value */
+    .param-value {
+        font-family: 'Orbitron', sans-serif;
+        font-size: 2rem;
+        font-weight: 700;
+        color: var(--accent-color, #00d4ff);
+        margin-bottom: 1rem;
+    }
+    /* Color Accents for Different Parameters */
+    .param-rpm { --accent-color: #00d4ff; }
+    .param-fuel { --accent-color: #ff6b35; }
+    .param-oil-pressure { --accent-color: #ffaa00; }
+    .param-coolant-temp { --accent-color: #ff3366; }
+    .param-coolant-pressure { --accent-color: #00ff88; }
+    .param-oil-temp { --accent-color: #a855f7; }
+    /* Analyze Button */
+    .analyze-button {
+        display: block;
+        margin: 3rem auto;
+        padding: 1.2rem 4rem;
+        font-family: 'Orbitron', sans-serif;
+        font-size: 1.3rem;
+        font-weight: 700;
+        color: #ffffff;
+        background: linear-gradient(135deg, #0090ff 0%, #0051ff 100%);
+        border: 2px solid #00d4ff;
+        border-radius: 50px;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        text-transform: uppercase;
+        letter-spacing: 2px;
+        box-shadow: 0 0 30px rgba(0, 144, 255, 0.3);
+    }
+    .analyze-button:hover {
+        background: linear-gradient(135deg, #00d4ff 0%, #0090ff 100%);
+        box-shadow: 0 0 50px rgba(0, 212, 255, 0.5);
+        transform: translateY(-2px);
+    }
+    /* Status Badge */
+    .status-badge {
+        display: inline-block;
+        padding: 0.8rem 2rem;
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.3rem;
+        font-weight: 700;
+        border-radius: 30px;
+        text-transform: uppercase;
+        letter-spacing: 2px;
+        margin-top: 1rem;
+    }
+    .badge-healthy {
+        background: rgba(0, 255, 136, 0.2);
+        color: #00ff88;
+        border: 2px solid #00ff88;
+        box-shadow: 0 0 20px rgba(0, 255, 136, 0.3);
+    }
+    .badge-warning {
+        background: rgba(255, 170, 0, 0.2);
+        color: #ffaa00;
+        border: 2px solid #ffaa00;
+        box-shadow: 0 0 20px rgba(255, 170, 0, 0.3);
+    }
+    .badge-critical {
+        background: rgba(255, 51, 102, 0.2);
+        color: #ff3366;
+        border: 2px solid #ff3366;
+        box-shadow: 0 0 20px rgba(255, 51, 102, 0.3);
+    }
+    /* Info Panel */
+    .info-panel {
+        background: linear-gradient(135deg,
+            rgba(26, 31, 58, 0.4) 0%,
+            rgba(10, 14, 39, 0.6) 100%);
+        border-left: 4px solid #00d4ff;
+        border-radius: 8px;
+        padding: 1.5rem;
+        margin: 2rem 0;
+        backdrop-filter: blur(10px);
+    }
+    .info-title {
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.3rem;
+        font-weight: 700;
+        color: #00d4ff;
+        margin-bottom: 1rem;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+    .info-content {
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.1rem;
+        color: #b8c5d6;
+        line-height: 1.6;
+    }
+    /* Recommendations List */
+    .recommendation-item {
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 1.1rem;
+        color: #e0e6ed;
+        padding: 0.8rem 1.2rem;
+        margin: 0.5rem 0;
+        background: rgba(0, 212, 255, 0.05);
+        border-left: 3px solid #00d4ff;
+        border-radius: 4px;
+        transition: all 0.2s ease;
+    }
+    .recommendation-item:hover {
+        background: rgba(0, 212, 255, 0.1);
+        transform: translateX(4px);
+    }
+    /* History Section */
+    .history-card {
+        background: linear-gradient(135deg,
+            rgba(26, 31, 58, 0.5) 0%,
+            rgba(10, 14, 39, 0.7) 100%);
+        border: 2px solid rgba(0, 212, 255, 0.2);
+        border-radius: 12px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+    }
+    /* Slider Customization */
+    .stSlider > div > div > div {
+        background: linear-gradient(90deg, #0051ff 0%, #00d4ff 100%);
+    }
+    /* Pulse Animation for Critical State */
+    @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.6; }
+    }
+    .pulse-critical {
+        animation: pulse 1.5s ease-in-out infinite;
+    }
+    /* Footer */
+    .dashboard-footer {
+        text-align: center;
+        margin-top: 4rem;
+        padding: 2rem;
+        font-family: 'Rajdhani', sans-serif;
+        font-size: 0.9rem;
+        color: #6b7280;
+        border-top: 1px solid rgba(107, 114, 128, 0.2);
+    }
+    </style>
+    """, unsafe_allow_html=True)
 # --- HELPER FUNCTIONS ---
+def get_engine_status(probability):
+    """Determine engine status based on failure probability"""
+    if probability < 0.25:
+        return 'healthy', '🟢', '#00ff88', 'OPTIMAL'
+    elif probability < 0.50:
+        return 'warning', '🟡', '#ffaa00', 'CAUTION'
+    elif probability < 0.75:
+        return 'warning', '🟠', '#ff9500', 'WARNING'
+    else:
+        return 'critical', '🔴', '#ff3366', 'CRITICAL'
+def create_circular_gauge(value, max_value, title, color, unit=""):
+    """Create a minimal circular gauge"""
+    percentage = (value / max_value) * 100
     fig = go.Figure(go.Indicator(
+        mode = "gauge+number",
         value = value,
+        number = {'suffix': f" {unit}", 'font': {'size': 24, 'color': color}},
+        title = {'text': title, 'font': {'size': 14, 'color': '#8b95a5'}},
         gauge = {
+            'axis': {'range': [0, max_value], 'tickwidth': 1, 'tickcolor': color},
+            'bar': {'color': color, 'thickness': 0.7},
+            'bgcolor': "rgba(26, 31, 58, 0.3)",
             'borderwidth': 2,
+            'bordercolor': "rgba(255, 255, 255, 0.1)",
             'steps': [
+                {'range': [0, max_value * 0.6], 'color': 'rgba(0, 255, 136, 0.1)'},
+                {'range': [max_value * 0.6, max_value * 0.8], 'color': 'rgba(255, 170, 0, 0.1)'},
+                {'range': [max_value * 0.8, max_value], 'color': 'rgba(255, 51, 102, 0.1)'}
             ],
         }
     ))
+    fig.update_layout(
+        height=200,
+        margin=dict(l=10, r=10, t=40, b=10),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        font={'family': 'Rajdhani', 'color': '#e0e6ed'}
+    )
     return fig
+def prepare_input_data(rpm, fuel_p, lub_oil_p, coolant_p, lub_oil_t, coolant_temp):
+    """Prepare input data for model"""
     return pd.DataFrame({
         'Engine rpm': [rpm],
         'Lub oil pressure': [lub_oil_p],
     })
 def run_prediction(model, scaler, input_df):
+    """Execute model prediction"""
     try:
         scaled = scaler.transform(input_df)
         pred = model.predict(scaled)[0]
     except Exception as e:
         return None, None, str(e)
+def get_recommendations(input_df, prob):
+    """Generate maintenance recommendations"""
     recommendations = []
     rpm = input_df['Engine rpm'].values[0]
     coolant_temp = input_df['Coolant temp'].values[0]
     lub_oil_p = input_df['Lub oil pressure'].values[0]
     fuel_p = input_df['Fuel pressure'].values[0]
+    if prob > 0.75:
+        recommendations.append("⚠️ IMMEDIATE SHUTDOWN RECOMMENDED - Critical failure risk detected")
+        recommendations.append("📞 Contact maintenance team immediately")
+    if coolant_temp > 100:
+        recommendations.append("🌡️ Coolant temperature elevated - Check radiator and cooling system")
+    if lub_oil_p < 2.0:
+        recommendations.append("🛢️ Low oil pressure detected - Inspect oil pump and filter")
+    if fuel_p < 5.0:
+        recommendations.append("⛽ Fuel pressure below optimal - Check fuel pump and lines")
+    if rpm > 2000:
+        recommendations.append("⚙️ High RPM detected - Reduce engine load")
+    if prob > 0.5:
+        recommendations.append("📅 Schedule comprehensive engine inspection within 24 hours")
+    elif prob > 0.25:
+        recommendations.append("📋 Monitor engine parameters and schedule preventive maintenance")
+    else:
+        recommendations.append("✅ Engine operating within normal parameters")
     return recommendations
+# --- MAIN APPLICATION ---
 def main():
+    # Load CSS
+    load_css()
+    # Load Model
     model, scaler, error = load_artifacts()
+    if model is None:
+        st.error(f"⚠️ Model Loading Error: {error}")
         st.stop()
+    # Header
+    st.markdown('<h1 class="main-title">⚙️ Engine Health Monitor</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="subtitle">AI-Powered Predictive Maintenance System</p>', unsafe_allow_html=True)
+    # Main Dashboard Container
+    st.markdown('<div class="dashboard-container">', unsafe_allow_html=True)
+    # Parameter Input Section
+    st.markdown("### 📊 Engine Parameters")
+    # Create 2 rows of 3 parameters each
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.markdown('<div class="param-card param-rpm">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">⚡</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Engine RPM</div>', unsafe_allow_html=True)
+        rpm = st.slider("", 0, 2500, 750, 50, label_visibility="collapsed", key="rpm")
+        st.markdown(f'<div class="param-value">{rpm}</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(rpm, 2500, "RPM", "#00d4ff"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    with col2:
+        st.markdown('<div class="param-card param-fuel">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">⛽</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Fuel Pressure</div>', unsafe_allow_html=True)
+        fuel_p = st.slider("", 0.0, 25.0, 6.2, 0.1, label_visibility="collapsed", key="fuel")
+        st.markdown(f'<div class="param-value">{fuel_p:.1f} Bar</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(fuel_p, 25, "Fuel", "#ff6b35", "Bar"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    with col3:
+        st.markdown('<div class="param-card param-oil-pressure">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">🛢️</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Oil Pressure</div>', unsafe_allow_html=True)
+        lub_oil_p = st.slider("", 0.0, 10.0, 3.16, 0.1, label_visibility="collapsed", key="oil_p")
+        st.markdown(f'<div class="param-value">{lub_oil_p:.2f} Bar</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(lub_oil_p, 10, "Oil", "#ffaa00", "Bar"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    # Second row
+    col4, col5, col6 = st.columns(3)
+    with col4:
+        st.markdown('<div class="param-card param-coolant-temp">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">🌡️</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Coolant Temp</div>', unsafe_allow_html=True)
+        coolant_temp = st.slider("", 0.0, 200.0, 80.0, 1.0, label_visibility="collapsed", key="coolant_temp")
+        st.markdown(f'<div class="param-value">{coolant_temp:.1f} °C</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(coolant_temp, 200, "Temp", "#ff3366", "°C"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    with col5:
+        st.markdown('<div class="param-card param-coolant-pressure">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">💧</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Coolant Pressure</div>', unsafe_allow_html=True)
+        coolant_p = st.slider("", 0.0, 10.0, 2.16, 0.1, label_visibility="collapsed", key="coolant_p")
+        st.markdown(f'<div class="param-value">{coolant_p:.2f} Bar</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(coolant_p, 10, "Coolant P", "#00ff88", "Bar"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    with col6:
+        st.markdown('<div class="param-card param-oil-temp">', unsafe_allow_html=True)
+        st.markdown('<div class="param-icon">🔥</div>', unsafe_allow_html=True)
+        st.markdown('<div class="param-label">Oil Temperature</div>', unsafe_allow_html=True)
+        lub_oil_t = st.slider("", 0.0, 150.0, 80.0, 1.0, label_visibility="collapsed", key="oil_temp")
+        st.markdown(f'<div class="param-value">{lub_oil_t:.1f} °C</div>', unsafe_allow_html=True)
+        st.plotly_chart(create_circular_gauge(lub_oil_t, 150, "Oil Temp", "#a855f7", "°C"), use_container_width=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+    # Central Engine Status Display
+    st.markdown("---")
+    # Analyze Button
+    col_center = st.columns([1, 2, 1])
+    with col_center[1]:
+        analyze = st.button("🔍 ANALYZE ENGINE STATUS", key="analyze", use_container_width=True)
+    # Prediction Results
+    if analyze:
+        input_df = prepare_input_data(rpm, fuel_p, lub_oil_p, coolant_p, lub_oil_t, coolant_temp)
+        pred, prob, error = run_prediction(model, scaler, input_df)
+        if error:
+            st.error(f"Prediction Error: {error}")
         else:
+            # Store prediction
+            st.session_state.predictions.append({
+                'timestamp': datetime.now(),
+                'probability': prob,
+                'prediction': pred,
+                'rpm': rpm,
+                'coolant_temp': coolant_temp
+            })
+            status, emoji, color, status_text = get_engine_status(prob)
+            st.session_state.current_status = status
+            # Display Central Engine Status
+            st.markdown("### 🔧 Engine Status")
+            # Create centered layout for engine icon
+            col_left, col_center, col_right = st.columns([1, 1, 1])
+            with col_center:
+                # Engine status display
+                pulse_class = "pulse-critical" if status == 'critical' else ""
+                st.markdown(f"""
+                <div class="engine-container">
+                    <div class="glow-ring"></div>
+                    <div class="engine-circle status-{status} {pulse_class}">
+                        <div class="engine-icon">{emoji}</div>
+                    </div>
+                    <div class="probability-display">
+                        {prob*100:.1f}% Failure Risk
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+                # Status badge
+                st.markdown(f"""
+                <div style="text-align: center;">
+                    <span class="status-badge badge-{status}">{status_text}</span>
+                </div>
+                """, unsafe_allow_html=True)
+            # Recommendations
+            st.markdown("---")
+            st.markdown("### 📋 Recommendations")
+            recommendations = get_recommendations(input_df, prob)
+            for rec in recommendations:
+                st.markdown(f'<div class="recommendation-item">{rec}</div>', unsafe_allow_html=True)
+            # Detailed Analysis
+            st.markdown("---")
+            st.markdown("### 📊 Detailed Analysis")
+            col_detail1, col_detail2 = st.columns(2)
+            with col_detail1:
+                st.markdown(f"""
+                <div class="info-panel">
+                    <div class="info-title">Prediction Details</div>
+                    <div class="info-content">
+                        <strong>Failure Probability:</strong> {prob*100:.2f}%<br>
+                        <strong>Classification:</strong> {'FAILURE RISK' if pred == 1 else 'OPERATIONAL'}<br>
+                        <strong>Status Level:</strong> {status_text}<br>
+                        <strong>Timestamp:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+            with col_detail2:
+                st.markdown(f"""
+                <div class="info-panel">
+                    <div class="info-title">Critical Parameters</div>
+                    <div class="info-content">
+                        <strong>Engine RPM:</strong> {rpm} {'⚠️' if rpm > 2000 else '✓'}<br>
+                        <strong>Coolant Temp:</strong> {coolant_temp:.1f}°C {'⚠️' if coolant_temp > 100 else '✓'}<br>
+                        <strong>Oil Pressure:</strong> {lub_oil_p:.2f} Bar {'⚠️' if lub_oil_p < 2.0 else '✓'}<br>
+                        <strong>Fuel Pressure:</strong> {fuel_p:.1f} Bar {'⚠️' if fuel_p < 5.0 else '✓'}
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+    else:
+        # Default display before analysis
+        st.markdown("### 🔧 Engine Status")
+        col_left, col_center, col_right = st.columns([1, 1, 1])
+        with col_center:
+            st.markdown(f"""
+            <div class="engine-container">
+                <div class="glow-ring"></div>
+                <div class="engine-circle status-unknown">
+                    <div class="engine-icon">⚙️</div>
+                </div>
+                <div class="probability-display">
+                    Awaiting Analysis
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+            st.markdown(f"""
+            <div style="text-align: center; margin-top: 2rem;">
+                <p style="font-family: 'Rajdhani', sans-serif; color: #8b95a5; font-size: 1.1rem;">
+                    Configure engine parameters above and click "ANALYZE ENGINE STATUS"
+                </p>
+            </div>
+            """, unsafe_allow_html=True)
+    # Analysis History
+    if st.session_state.predictions:
+        st.markdown("---")
+        st.markdown("### 📈 Analysis History")
+        history_df = pd.DataFrame(st.session_state.predictions)
+        # Display last 5 predictions
+        st.markdown(f"**Total Analyses:** {len(history_df)} | **Showing last 5**")
+        for idx, row in history_df.tail(5).iterrows():
+            status, emoji, color, status_text = get_engine_status(row['probability'])
+            st.markdown(f"""
+            <div class="history-card">
+                <strong>{emoji} {row['timestamp'].strftime('%H:%M:%S')}</strong> -
+                Failure Risk: <span style="color: {color};">{row['probability']*100:.1f}%</span> -
+                Status: {status_text}
+            </div>
+            """, unsafe_allow_html=True)
+    # Footer
+    st.markdown("""
+    <div class="dashboard-footer">
+        <p><strong>Engine Predictive Maintenance System</strong></p>
+        <p>Powered by Machine Learning | Real-time Monitoring & Analysis</p>
+        <p style="margin-top: 1rem; font-size: 0.8rem;">Capstone Project - 2024</p>
+    </div>
+    """, unsafe_allow_html=True)
 if __name__ == "__main__":
     main()