Upload 8 files

project/
├── ai4i2020.csv # Dataset file
├── analysis.py # EDA analysis script
├── preprocessing.py # Data preprocessing module
├── model.py # Machine learning model
├── train_model.py # Script to train and save model
├── app.py # Streamlit web application
└── README.md # Project documentation

README.md

@@ -1,19 +1,218 @@
----
-title: Predictive Maintenance System
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Predicts when industrial machinery will need maintenance.
----
+# Predictive Maintenance System - AI4I 2020 Dataset
+
+## Project Overview
+
+This project implements a comprehensive predictive maintenance system using machine learning to predict when industrial machinery needs maintenance. The system analyzes the AI4I 2020 Predictive Maintenance Dataset and provides interactive visualizations and real-time predictions through a Streamlit web application.
+
+## Features
+
+- **Comprehensive EDA**: 15+ different exploratory data analyses
+- **Machine Learning Model**: Random Forest Classifier for failure prediction
+- **Real-time Predictions**: Interactive interface for runtime predictions
+- **Maintenance Scheduling**: Estimates time to failure and maintenance urgency
+- **Interactive Visualizations**: Dynamic charts and graphs using Plotly
+- **Batch Processing**: Upload CSV files for batch predictions
+
+## Dataset
+
+The AI4I 2020 Predictive Maintenance Dataset contains:
+- **10,000 machine records**
+- **14 features** including temperature, rotational speed, torque, and tool wear
+- **Binary target**: Machine failure (0 = no failure, 1 = failure)
+- **5 failure types**: TWF, HDF, PWF, OSF, RNF
+
+## Project Structure
+
+```
+project/
+├── ai4i2020.csv              # Dataset file
+├── analysis.py               # EDA analysis script
+├── preprocessing.py          # Data preprocessing module
+├── model.py                  # Machine learning model
+├── train_model.py           # Script to train and save model
+├── app.py                    # Streamlit web application
+└── README.md                 # Project documentation
+```
+
+## Installation
+
+1. **Clone or download the project**
+2. **Install dependencies** (requirements listed below):
+```bash
+pip install pandas==2.1.4 numpy==1.26.2 matplotlib==3.8.2 seaborn==0.13.0 scikit-learn==1.4.0 streamlit==1.29.0 plotly==5.18.0
+```
+3. **Ensure the dataset file (`ai4i2020.csv`) is in the project directory**
+
+## Usage
+
+### Option 1: Run Streamlit App Directly (Recommended)
+
+The app will train the model automatically on first run:
+
+```bash
+streamlit run app.py
+```
+
+### Option 2: Train Model First, Then Run App
+
+1. **Train the model**:
+```bash
+python train_model.py
+```
+
+2. **Run the Streamlit app**:
+```bash
+streamlit run app.py
+```
+
+### Option 3: Run EDA Analysis Only
+
+```bash
+python analysis.py
+```
+
+## Streamlit Application
+
+The web application includes four main sections:
+
+### 1. Introduction
+- Dataset overview and statistics
+- Project goals and features
+- Dataset preview
+
+### 2. Exploratory Data Analysis
+Interactive visualizations including:
+- Summary statistics
+- Target distribution
+- Feature distributions
+- Correlation analysis
+- Failure analysis by machine type
+- Tool wear analysis
+- Temperature analysis
+- Outlier detection
+- Pairwise relationships
+- Failure type breakdown
 
-# Welcome to Streamlit!
+### 3. Model & Predictions
+- Model performance metrics
+- Feature importance visualization
+- **Runtime prediction**: Enter machine parameters to predict maintenance needs
+- **Batch prediction**: Upload CSV file for multiple predictions
+- Maintenance urgency assessment
+- Time-to-failure estimation
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+### 4. Conclusion
+- Key findings and takeaways
+- Applications and future improvements
+
+## EDA Analyses Performed
+
+1. Summary statistics (mean, median, mode, etc.)
+2. Missing value analysis
+3. Data types and unique value counts
+4. Target variable distribution
+5. Correlation analysis
+6. Outlier detection (IQR method)
+7. Feature distribution analysis
+8. Failure analysis by machine type
+9. Tool wear analysis
+10. Temperature analysis
+11. Power and rotational speed analysis
+12. Pairwise feature relationships
+13. Detailed failure type analysis
+14. Time to failure estimation
+15. Grouped aggregations
+
+## Machine Learning Model
+
+- **Algorithm**: Random Forest Classifier
+- **Features**: 11 engineered features including:
+  - Air temperature, Process temperature
+  - Rotational speed, Torque
+  - Tool wear
+  - Temperature difference
+  - Power
+  - Machine type encoding
+  
+- **Evaluation Metrics**:
+  - Accuracy
+  - Precision
+  - Recall
+  - F1-Score
+  - ROC-AUC
+
+## Predictive Features
+
+The model predicts:
+1. **Machine Failure**: Binary prediction (Yes/No)
+2. **Failure Probability**: Probability score (0-1)
+3. **Time to Failure**: Estimated minutes until maintenance needed
+4. **Maintenance Status**: Current maintenance requirement status
+5. **Maintenance Urgency**: CRITICAL, HIGH, MEDIUM, or LOW
+
+## Runtime Prediction
+
+Users can input machine parameters:
+- Machine Type (L, M, H)
+- Air Temperature (K)
+- Process Temperature (K)
+- Rotational Speed (rpm)
+- Torque (Nm)
+- Tool Wear (minutes)
+
+The system provides:
+- Failure prediction
+- Maintenance urgency level
+- Estimated time to failure
+- Detailed recommendations
+
+## Technical Stack
+
+- **Python 3.8+**
+- **Data Processing**: Pandas, NumPy
+- **Visualization**: Matplotlib, Seaborn, Plotly
+- **Machine Learning**: Scikit-learn
+- **Web Framework**: Streamlit
+
+## Key Insights
+
+1. **Tool wear** is the most critical indicator of machine health
+2. **Temperature difference** between process and air temperature correlates with failures
+3. Machine **type affects failure rates** differently
+4. Early detection can **prevent costly downtime**
+5. Proactive maintenance scheduling can **optimize operations**
+
+## Applications
+
+- Industrial manufacturing
+- Equipment monitoring systems
+- Preventive maintenance scheduling
+- Cost reduction through failure prevention
+- Production optimization
+
+## Future Enhancements
+
+1. Real-time data streaming integration
+2. IoT sensor integration
+3. Advanced ensemble methods
+4. Time-series analysis
+5. Automated alert system
+6. Historical maintenance record integration
+
+## Author
+
+Developed as part of the Introduction to Data Science course project.
+
+## License
+
+This project is for educational purposes.
+
+## Acknowledgments
+
+- AI4I 2020 Predictive Maintenance Dataset
+- Scikit-learn documentation
+- Streamlit documentation
+
+---
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+**Note**: Make sure the `ai4i2020.csv` file is in the same directory as the scripts before running the application.

analysis.py

@@ -0,0 +1,431 @@
+"""
+Comprehensive Exploratory Data Analysis (EDA) for AI4I 2020 Predictive Maintenance Dataset
+This script performs 10-15 different analyses as required for the project.
+"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import warnings
+warnings.filterwarnings('ignore')
+
+# Set style for better visualizations
+sns.set_style("whitegrid")
+plt.rcParams['figure.figsize'] = (12, 6)
+
+class EDAAnalysis:
+    def __init__(self, data_path='ai4i2020.csv'):
+        """Initialize the EDA analysis class"""
+        self.df = pd.read_csv(data_path)
+        self.prepare_data()
+        
+    def prepare_data(self):
+        """Prepare data for analysis"""
+        # Create a copy for analysis
+        self.df_clean = self.df.copy()
+        
+        # Calculate temperature difference (important feature)
+        self.df_clean['Temperature difference [K]'] = (
+            self.df_clean['Process temperature [K]'] - 
+            self.df_clean['Air temperature [K]']
+        )
+        
+        # Calculate power (Rotational speed * Torque)
+        self.df_clean['Power [W]'] = (
+            self.df_clean['Rotational speed [rpm]'] * 
+            self.df_clean['Torque [Nm]'] / 9.5488  # Conversion factor
+        )
+        
+        # Failure type names
+        self.failure_types = {
+            'TWF': 'Tool Wear Failure',
+            'HDF': 'Heat Dissipation Failure',
+            'PWF': 'Power Failure',
+            'OSF': 'Overstrain Failure',
+            'RNF': 'Random Failure'
+        }
+    
+    def analysis_1_summary_statistics(self):
+        """Analysis 1: Summary statistics for numerical features"""
+        print("="*80)
+        print("ANALYSIS 1: SUMMARY STATISTICS")
+        print("="*80)
+        
+        numerical_cols = [
+            'Air temperature [K]', 'Process temperature [K]', 
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]',
+            'Temperature difference [K]', 'Power [W]'
+        ]
+        
+        summary = self.df_clean[numerical_cols].describe()
+        print(summary)
+        print("\n")
+        
+        return summary
+    
+    def analysis_2_missing_values(self):
+        """Analysis 2: Missing value analysis"""
+        print("="*80)
+        print("ANALYSIS 2: MISSING VALUE ANALYSIS")
+        print("="*80)
+        
+        missing = self.df_clean.isnull().sum()
+        missing_pct = (missing / len(self.df_clean)) * 100
+        
+        missing_df = pd.DataFrame({
+            'Missing Count': missing,
+            'Missing Percentage': missing_pct
+        })
+        missing_df = missing_df[missing_df['Missing Count'] > 0]
+        
+        if len(missing_df) == 0:
+            print("✓ No missing values found in the dataset!")
+        else:
+            print(missing_df)
+        print("\n")
+        
+        return missing_df
+    
+    def analysis_3_data_types(self):
+        """Analysis 3: Data types and unique value counts"""
+        print("="*80)
+        print("ANALYSIS 3: DATA TYPES AND UNIQUE VALUES")
+        print("="*80)
+        
+        info_df = pd.DataFrame({
+            'Column': self.df_clean.columns,
+            'Data Type': self.df_clean.dtypes,
+            'Unique Values': [self.df_clean[col].nunique() for col in self.df_clean.columns],
+            'Non-Null Count': self.df_clean.count().values
+        })
+        
+        print(info_df.to_string(index=False))
+        print("\n")
+        
+        # Categorical value counts
+        print("Type Distribution:")
+        print(self.df_clean['Type'].value_counts())
+        print("\n")
+        
+        return info_df
+    
+    def analysis_4_target_distribution(self):
+        """Analysis 4: Target variable (Machine failure) distribution"""
+        print("="*80)
+        print("ANALYSIS 4: TARGET VARIABLE DISTRIBUTION")
+        print("="*80)
+        
+        failure_counts = self.df_clean['Machine failure'].value_counts()
+        failure_pct = self.df_clean['Machine failure'].value_counts(normalize=True) * 100
+        
+        print("Machine Failure Distribution:")
+        print(f"  No Failure (0): {failure_counts[0]} ({failure_pct[0]:.2f}%)")
+        print(f"  Failure (1): {failure_counts[1]} ({failure_pct[1]:.2f}%)")
+        print("\n")
+        
+        # Failure types breakdown
+        print("Failure Types Breakdown:")
+        for ft in ['TWF', 'HDF', 'PWF', 'OSF', 'RNF']:
+            count = self.df_clean[ft].sum()
+            pct = (count / len(self.df_clean)) * 100
+            print(f"  {self.failure_types[ft]}: {count} ({pct:.2f}%)")
+        print("\n")
+        
+        return failure_counts
+    
+    def analysis_5_correlation_analysis(self):
+        """Analysis 5: Correlation analysis"""
+        print("="*80)
+        print("ANALYSIS 5: CORRELATION ANALYSIS")
+        print("="*80)
+        
+        numerical_cols = [
+            'Air temperature [K]', 'Process temperature [K]', 
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]',
+            'Temperature difference [K]', 'Power [W]', 'Machine failure'
+        ]
+        
+        corr_matrix = self.df_clean[numerical_cols].corr()
+        
+        print("Correlation with Machine Failure:")
+        failure_corr = corr_matrix['Machine failure'].sort_values(ascending=False)
+        print(failure_corr)
+        print("\n")
+        
+        return corr_matrix
+    
+    def analysis_6_outlier_detection(self):
+        """Analysis 6: Outlier detection using IQR method"""
+        print("="*80)
+        print("ANALYSIS 6: OUTLIER DETECTION (IQR METHOD)")
+        print("="*80)
+        
+        numerical_cols = [
+            'Air temperature [K]', 'Process temperature [K]', 
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]'
+        ]
+        
+        outlier_summary = {}
+        
+        for col in numerical_cols:
+            Q1 = self.df_clean[col].quantile(0.25)
+            Q3 = self.df_clean[col].quantile(0.75)
+            IQR = Q3 - Q1
+            lower_bound = Q1 - 1.5 * IQR
+            upper_bound = Q3 + 1.5 * IQR
+            
+            outliers = self.df_clean[(self.df_clean[col] < lower_bound) | 
+                                    (self.df_clean[col] > upper_bound)]
+            outlier_count = len(outliers)
+            outlier_pct = (outlier_count / len(self.df_clean)) * 100
+            
+            outlier_summary[col] = {
+                'Lower Bound': lower_bound,
+                'Upper Bound': upper_bound,
+                'Outlier Count': outlier_count,
+                'Outlier Percentage': outlier_pct
+            }
+            
+            print(f"{col}:")
+            print(f"  Bounds: [{lower_bound:.2f}, {upper_bound:.2f}]")
+            print(f"  Outliers: {outlier_count} ({outlier_pct:.2f}%)")
+        
+        print("\n")
+        return outlier_summary
+    
+    def analysis_7_feature_distributions(self):
+        """Analysis 7: Feature distribution analysis"""
+        print("="*80)
+        print("ANALYSIS 7: FEATURE DISTRIBUTION ANALYSIS")
+        print("="*80)
+        
+        numerical_cols = [
+            'Air temperature [K]', 'Process temperature [K]', 
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]'
+        ]
+        
+        dist_stats = {}
+        for col in numerical_cols:
+            dist_stats[col] = {
+                'Mean': self.df_clean[col].mean(),
+                'Median': self.df_clean[col].median(),
+                'Mode': self.df_clean[col].mode()[0] if len(self.df_clean[col].mode()) > 0 else None,
+                'Std': self.df_clean[col].std(),
+                'Skewness': self.df_clean[col].skew(),
+                'Kurtosis': self.df_clean[col].kurtosis()
+            }
+            
+            print(f"{col}:")
+            print(f"  Mean: {dist_stats[col]['Mean']:.2f}")
+            print(f"  Median: {dist_stats[col]['Median']:.2f}")
+            print(f"  Std Dev: {dist_stats[col]['Std']:.2f}")
+            print(f"  Skewness: {dist_stats[col]['Skewness']:.2f}")
+            print(f"  Kurtosis: {dist_stats[col]['Kurtosis']:.2f}")
+            print()
+        
+        print("\n")
+        return dist_stats
+    def analysis_8_failure_by_type(self):
+        """Analysis 8: Failure analysis by machine type"""
+        print("="*80)
+        print("ANALYSIS 8: FAILURE ANALYSIS BY MACHINE TYPE")
+        print("="*80)
+        
+        failure_by_type = self.df_clean.groupby('Type')['Machine failure'].agg([
+            'count', 'sum', 'mean'
+        ]).round(4)
+        failure_by_type.columns = ['Total Machines', 'Failures', 'Failure Rate']
+        failure_by_type['Failure Rate'] = failure_by_type['Failure Rate'] * 100
+        
+        print(failure_by_type)
+        print("\n")
+        
+        return failure_by_type
+    
+    def analysis_9_tool_wear_analysis(self):
+        """Analysis 9: Tool wear analysis and relationship with failures"""
+        print("="*80)
+        print("ANALYSIS 9: TOOL WEAR ANALYSIS")
+        print("="*80)
+        
+        print("Tool Wear Statistics:")
+        print(f"  Mean: {self.df_clean['Tool wear [min]'].mean():.2f} minutes")
+        print(f"  Median: {self.df_clean['Tool wear [min]'].median():.2f} minutes")
+        print(f"  Max: {self.df_clean['Tool wear [min]'].max():.2f} minutes")
+        print(f"  Min: {self.df_clean['Tool wear [min]'].min():.2f} minutes")
+        print()
+        
+        # Tool wear vs failure
+        tool_wear_failure = self.df_clean.groupby('Machine failure')['Tool wear [min]'].agg([
+            'mean', 'median', 'std', 'min', 'max'
+        ])
+        print("Tool Wear by Failure Status:")
+        print(tool_wear_failure)
+        print("\n")
+        
+        return tool_wear_failure
+    
+    def analysis_10_temperature_analysis(self):
+        """Analysis 10: Temperature analysis"""
+        print("="*80)
+        print("ANALYSIS 10: TEMPERATURE ANALYSIS")
+        print("="*80)
+        
+        temp_stats = self.df_clean.groupby('Machine failure')[
+            ['Air temperature [K]', 'Process temperature [K]', 'Temperature difference [K]']
+        ].agg(['mean', 'std'])
+        
+        print("Temperature Statistics by Failure Status:")
+        print(temp_stats)
+        print("\n")
+        
+        return temp_stats
+    
+    def analysis_11_power_analysis(self):
+        """Analysis 11: Power and rotational speed analysis"""
+        print("="*80)
+        print("ANALYSIS 11: POWER AND ROTATIONAL SPEED ANALYSIS")
+        print("="*80)
+        
+        power_stats = self.df_clean.groupby('Machine failure')[
+            ['Rotational speed [rpm]', 'Torque [Nm]', 'Power [W]']
+        ].agg(['mean', 'std', 'min', 'max'])
+        
+        print("Power Statistics by Failure Status:")
+        print(power_stats)
+        print("\n")
+        
+        return power_stats
+    
+    def analysis_12_pairwise_relationships(self):
+        """Analysis 12: Pairwise feature relationships"""
+        print("="*80)
+        print("ANALYSIS 12: PAIRWISE FEATURE RELATIONSHIPS")
+        print("="*80)
+        
+        key_features = [
+            'Tool wear [min]', 'Temperature difference [K]', 
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Machine failure'
+        ]
+        
+        pairwise_corr = self.df_clean[key_features].corr()
+        print("Pairwise Correlations:")
+        print(pairwise_corr)
+        print("\n")
+        
+        return pairwise_corr
+    
+    def analysis_13_failure_type_analysis(self):
+        """Analysis 13: Detailed failure type analysis"""
+        print("="*80)
+        print("ANALYSIS 13: DETAILED FAILURE TYPE ANALYSIS")
+        print("="*80)
+        
+        failure_types = ['TWF', 'HDF', 'PWF', 'OSF', 'RNF']
+        
+        for ft in failure_types:
+            failed_machines = self.df_clean[self.df_clean[ft] == 1]
+            if len(failed_machines) > 0:
+                print(f"\n{self.failure_types[ft]} ({ft}):")
+                print(f"  Count: {len(failed_machines)}")
+                print(f"  Avg Tool Wear: {failed_machines['Tool wear [min]'].mean():.2f} min")
+                print(f"  Avg Temp Diff: {failed_machines['Temperature difference [K]'].mean():.2f} K")
+                print(f"  Avg Rotational Speed: {failed_machines['Rotational speed [rpm]'].mean():.2f} rpm")
+                print(f"  Avg Torque: {failed_machines['Torque [Nm]'].mean():.2f} Nm")
+        
+        print("\n")
+    
+    def analysis_14_time_to_failure_estimation(self):
+        """Analysis 14: Time to failure estimation based on tool wear"""
+        print("="*80)
+        print("ANALYSIS 14: TIME TO FAILURE ESTIMATION")
+        print("="*80)
+        
+        # Analyze tool wear progression for machines that failed
+        failed_machines = self.df_clean[self.df_clean['Machine failure'] == 1]
+        
+        if len(failed_machines) > 0:
+            avg_tool_wear_at_failure = failed_machines['Tool wear [min]'].mean()
+            median_tool_wear_at_failure = failed_machines['Tool wear [min]'].median()
+            
+            print(f"Average Tool Wear at Failure: {avg_tool_wear_at_failure:.2f} minutes")
+            print(f"Median Tool Wear at Failure: {median_tool_wear_at_failure:.2f} minutes")
+            print()
+            
+            # Estimate time remaining for machines not yet failed
+            non_failed = self.df_clean[self.df_clean['Machine failure'] == 0]
+            if len(non_failed) > 0:
+                non_failed['Estimated Time to Failure'] = (
+                    avg_tool_wear_at_failure - non_failed['Tool wear [min]']
+                )
+                non_failed['Estimated Time to Failure'] = non_failed['Estimated Time to Failure'].clip(lower=0)
+                
+                print("Time to Failure Estimates (for non-failed machines):")
+                print(f"  Machines needing immediate maintenance (< 10 min): "
+                      f"{(non_failed['Estimated Time to Failure'] < 10).sum()}")
+                print(f"  Machines needing maintenance soon (10-50 min): "
+                      f"{((non_failed['Estimated Time to Failure'] >= 10) & (non_failed['Estimated Time to Failure'] < 50)).sum()}")
+                print(f"  Machines with time remaining (> 50 min): "
+                      f"{(non_failed['Estimated Time to Failure'] >= 50).sum()}")
+        
+        print("\n")
+    
+    def analysis_15_grouped_aggregations(self):
+        """Analysis 15: Grouped aggregations by type and failure status"""
+        print("="*80)
+        print("ANALYSIS 15: GROUPED AGGREGATIONS")
+        print("="*80)
+        
+        grouped = self.df_clean.groupby(['Type', 'Machine failure']).agg({
+            'Tool wear [min]': ['mean', 'std', 'max'],
+            'Temperature difference [K]': ['mean', 'std'],
+            'Rotational speed [rpm]': ['mean', 'std'],
+            'Torque [Nm]': ['mean', 'std']
+        })
+        
+        print("Grouped Statistics by Type and Failure Status:")
+        print(grouped)
+        print("\n")
+        
+        return grouped
+    
+    def run_all_analyses(self):
+        """Run all EDA analyses"""
+        print("\n" + "="*80)
+        print("COMPREHENSIVE EXPLORATORY DATA ANALYSIS")
+        print("AI4I 2020 Predictive Maintenance Dataset")
+        print("="*80 + "\n")
+        
+        results = {}
+        
+        results['summary_stats'] = self.analysis_1_summary_statistics()
+        results['missing_values'] = self.analysis_2_missing_values()
+        results['data_types'] = self.analysis_3_data_types()
+        results['target_distribution'] = self.analysis_4_target_distribution()
+        results['correlation'] = self.analysis_5_correlation_analysis()
+        results['outliers'] = self.analysis_6_outlier_detection()
+        results['distributions'] = self.analysis_7_feature_distributions()
+        results['failure_by_type'] = self.analysis_8_failure_by_type()
+        results['tool_wear'] = self.analysis_9_tool_wear_analysis()
+        results['temperature'] = self.analysis_10_temperature_analysis()
+        results['power'] = self.analysis_11_power_analysis()
+        results['pairwise'] = self.analysis_12_pairwise_relationships()
+        self.analysis_13_failure_type_analysis()
+        self.analysis_14_time_to_failure_estimation()
+        results['grouped'] = self.analysis_15_grouped_aggregations()
+        
+        print("="*80)
+        print("EDA ANALYSIS COMPLETE!")
+        print("="*80)
+        
+        return results
+
+if __name__ == "__main__":
+    # Run EDA analysis
+    eda = EDAAnalysis('ai4i2020.csv')
+    results = eda.run_all_analyses()
+    
+    # Save processed data for modeling
+    eda.df_clean.to_csv('processed_data.csv', index=False)
+    print("\nProcessed data saved to 'processed_data.csv'")

app.py

@@ -0,0 +1,989 @@
+"""
+Streamlit Application for Predictive Maintenance Project
+Interactive web app for EDA, model visualization, and runtime predictions
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pickle
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import custom modules
+from preprocessing import DataPreprocessor
+from model import PredictiveMaintenanceModel
+
+# Page configuration
+st.set_page_config(
+    page_title="Predictive Maintenance System",
+    page_icon="🔧",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        color: #ff7f0e;
+        margin-top: 2rem;
+        margin-bottom: 1rem;
+    }
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'preprocessor' not in st.session_state:
+    st.session_state.preprocessor = None
+if 'data' not in st.session_state:
+    st.session_state.data = None
+
+@st.cache_data
+def load_data():
+    """Load and cache the dataset"""
+    df = pd.read_csv('ai4i2020.csv')
+    # Create additional features
+    df['Temperature difference [K]'] = (
+        df['Process temperature [K]'] - df['Air temperature [K]']
+    )
+    df['Power [W]'] = (
+        df['Rotational speed [rpm]'] * df['Torque [Nm]'] / 9.5488
+    )
+    return df
+
+def train_model():
+    """Train the model and preprocessor"""
+    with st.spinner("Training model... This may take a moment."):
+        preprocessor = DataPreprocessor('ai4i2020.csv')
+        X_train, X_test, y_train, y_test, feature_columns = preprocessor.prepare_data()
+        
+        model = PredictiveMaintenanceModel()
+        model.train(X_train, y_train)
+        
+        # Evaluate model
+        results = model.evaluate(X_test, y_test)
+        
+        st.session_state.model = model
+        st.session_state.preprocessor = preprocessor
+        st.session_state.feature_columns = feature_columns
+        
+        return results
+
+# Main App
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🔧 Predictive Maintenance System</h1>', unsafe_allow_html=True)
+    st.markdown("---")
+    
+    # Sidebar Navigation
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio(
+        "Select Page",
+        ["Introduction", "Exploratory Data Analysis", "Model & Predictions", "Conclusion"]
+    )
+    
+    # Load data
+    df = load_data()
+    st.session_state.data = df
+    
+    if page == "Introduction":
+        show_introduction(df)
+    elif page == "Exploratory Data Analysis":
+        show_eda(df)
+    elif page == "Model & Predictions":
+        show_model_predictions(df)
+    elif page == "Conclusion":
+        show_conclusion()
+
+def show_introduction(df):
+    """Introduction page"""
+    st.markdown('<h2 class="sub-header">📋 Project Introduction</h2>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.markdown("""
+        ### About the Dataset
+        
+        This project uses the **AI4I 2020 Predictive Maintenance Dataset**, which contains 
+        synthetic data simulating predictive maintenance scenarios for industrial machinery.
+        
+        #### Dataset Overview:
+        - **Total Records**: 10,000 machines
+        - **Features**: 14 attributes including temperature, rotational speed, torque, and tool wear
+        - **Target**: Machine failure prediction (binary classification)
+        - **Failure Types**: Tool Wear Failure (TWF), Heat Dissipation Failure (HDF), 
+          Power Failure (PWF), Overstrain Failure (OSF), and Random Failure (RNF)
+        
+        #### Project Goals:
+        1. **Exploratory Data Analysis**: Understand patterns and relationships in the data
+        2. **Predictive Modeling**: Build a machine learning model to predict machine failures
+        3. **Maintenance Scheduling**: Estimate when maintenance is needed and how urgent it is
+        4. **Interactive Visualization**: Present findings through an interactive web application
+        
+        #### Key Features:
+        - Comprehensive EDA with 15+ different analyses
+        - Random Forest Classifier for failure prediction
+        - Real-time predictions based on user input
+        - Maintenance urgency assessment
+        - Time-to-failure estimation
+        """)
+    
+    with col2:
+        st.markdown("### Dataset Statistics")
+        st.metric("Total Machines", f"{len(df):,}")
+        st.metric("Features", len(df.columns))
+        st.metric("Machine Failures", f"{df['Machine failure'].sum():,}")
+        st.metric("Failure Rate", f"{(df['Machine failure'].mean()*100):.2f}%")
+        
+        st.markdown("### Machine Types")
+        type_counts = df['Type'].value_counts()
+        type_meanings = {'L': 'Low Quality/Load', 'M': 'Medium Quality/Load', 'H': 'High Quality/Load'}
+        for machine_type, count in type_counts.items():
+            meaning = type_meanings.get(machine_type, '')
+            st.metric(f"Type {machine_type} ({meaning})", f"{count:,}")
+    
+    st.markdown("---")
+    st.markdown("### Dataset Preview")
+    preview_mode = st.radio(
+        "Preview mode",
+        options=["First 20 rows", "Show all (10,000 rows)"],
+        index=0,
+        horizontal=True,
+    )
+    if preview_mode == "First 20 rows":
+        st.dataframe(df.head(20), use_container_width=True)
+    else:
+        st.dataframe(df, use_container_width=True)
+    
+    st.markdown("### Dataset Information")
+    with st.expander("View Column Descriptions"):
+        st.markdown("""
+        - **UDI**: Unique identifier for each machine
+        - **Product ID**: Product identifier
+        - **Type**: Machine type (L = Low Quality/Load, M = Medium Quality/Load, H = High Quality/Load)
+        - **Air temperature [K]**: Air temperature in Kelvin
+        - **Process temperature [K]**: Process temperature in Kelvin
+        - **Rotational speed [rpm]**: Rotational speed in revolutions per minute
+        - **Torque [Nm]**: Torque in Newton meters
+        - **Tool wear [min]**: Tool wear in minutes
+        - **Machine failure**: Binary target (0 = no failure, 1 = failure)
+        - **TWF, HDF, PWF, OSF, RNF**: Different failure type indicators
+        """)
+
+def show_eda(df):
+    """EDA page"""
+    st.markdown('<h2 class="sub-header">📊 Exploratory Data Analysis</h2>', unsafe_allow_html=True)
+    
+    # Analysis selection
+    analysis_type = st.selectbox(
+        "Select Analysis Type",
+        [
+            "Summary Statistics",
+            "Data Types & Unique Values",
+            "Target Distribution",
+            "Feature Distributions",
+            "Correlation Analysis",
+            "Failure Analysis by Type",
+            "Tool Wear Analysis",
+            "Temperature Analysis",
+            "Power & Rotational Speed Analysis",
+            "Outlier Detection",
+            "Pairwise Relationships",
+            "Failure Type Breakdown",
+            "Time to Failure Estimation",
+            "Grouped Aggregations"
+        ]
+    )
+    
+    st.markdown("---")
+    
+    if analysis_type == "Summary Statistics":
+        st.subheader("Summary Statistics")
+        st.dataframe(df.describe(), use_container_width=True)
+        
+        # Key metrics
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Mean Air Temp", f"{df['Air temperature [K]'].mean():.2f} K")
+        with col2:
+            st.metric("Mean Process Temp", f"{df['Process temperature [K]'].mean():.2f} K")
+        with col3:
+            st.metric("Mean Rotational Speed", f"{df['Rotational speed [rpm]'].mean():.0f} rpm")
+        with col4:
+            st.metric("Mean Torque", f"{df['Torque [Nm]'].mean():.2f} Nm")
+    
+    elif analysis_type == "Data Types & Unique Values":
+        st.subheader("Data Types and Unique Values")
+        
+        info_df = pd.DataFrame({
+            'Column': df.columns,
+            'Data Type': df.dtypes.astype(str),
+            'Unique Values': [df[col].nunique() for col in df.columns],
+            'Non-Null Count': df.count().values
+        })
+        
+        st.dataframe(info_df, use_container_width=True)
+        
+        st.subheader("Machine Type Distribution")
+        type_counts = df['Type'].value_counts()
+        type_meanings = {'L': 'Low Quality/Load', 'M': 'Medium Quality/Load', 'H': 'High Quality/Load'}
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            fig = px.bar(
+                x=type_counts.index,
+                y=type_counts.values,
+                title="Machine Type Distribution",
+                labels={'x': 'Machine Type', 'y': 'Count'},
+                color=type_counts.index,
+                color_discrete_sequence=['#e74c3c', '#3498db', '#2ecc71']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            for machine_type, count in type_counts.items():
+                meaning = type_meanings.get(machine_type, '')
+                st.metric(f"Type {machine_type} ({meaning})", f"{count:,}")
+    
+    elif analysis_type == "Target Distribution":
+        st.subheader("Machine Failure Distribution")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            failure_counts = df['Machine failure'].value_counts()
+            fig = px.pie(
+                values=failure_counts.values,
+                names=['No Failure', 'Failure'],
+                title="Failure Distribution",
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            st.metric("No Failure", f"{failure_counts[0]:,} ({(failure_counts[0]/len(df)*100):.2f}%)")
+            st.metric("Failure", f"{failure_counts[1]:,} ({(failure_counts[1]/len(df)*100):.2f}%)")
+            
+            # Failure types
+            st.subheader("Failure Types Breakdown")
+            failure_types = {
+                'TWF': 'Tool Wear Failure',
+                'HDF': 'Heat Dissipation Failure',
+                'PWF': 'Power Failure',
+                'OSF': 'Overstrain Failure',
+                'RNF': 'Random Failure'
+            }
+            for ft_code, ft_name in failure_types.items():
+                count = df[ft_code].sum()
+                st.metric(ft_name, f"{count} ({(count/len(df)*100):.2f}%)")
+    
+    elif analysis_type == "Feature Distributions":
+        st.subheader("Feature Distributions")
+        
+        feature = st.selectbox(
+            "Select Feature",
+            ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 
+             'Torque [Nm]', 'Tool wear [min]', 'Temperature difference [K]', 'Power [W]']
+        )
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            fig = px.histogram(
+                df, x=feature, nbins=50,
+                title=f"Distribution of {feature}",
+                color_discrete_sequence=['#3498db']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            fig = px.box(
+                df, y=feature,
+                title=f"Box Plot of {feature}",
+                color_discrete_sequence=['#9b59b6']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Statistics
+        st.subheader("Statistics")
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Mean", f"{df[feature].mean():.2f}")
+        with col2:
+            st.metric("Median", f"{df[feature].median():.2f}")
+        with col3:
+            st.metric("Std Dev", f"{df[feature].std():.2f}")
+        with col4:
+            st.metric("Skewness", f"{df[feature].skew():.2f}")
+    
+    elif analysis_type == "Correlation Analysis":
+        st.subheader("Correlation Analysis")
+        
+        numerical_cols = [
+            'Air temperature [K]', 'Process temperature [K]',
+            'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]',
+            'Temperature difference [K]', 'Power [W]', 'Machine failure'
+        ]
+        
+        corr_matrix = df[numerical_cols].corr()
+        
+        fig = px.imshow(
+            corr_matrix,
+            text_auto=True,
+            aspect="auto",
+            title="Correlation Heatmap",
+            color_continuous_scale="RdBu"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        st.subheader("Correlation with Machine Failure")
+        failure_corr = corr_matrix['Machine failure'].sort_values(ascending=False)
+        fig = px.bar(
+            x=failure_corr.index,
+            y=failure_corr.values,
+            title="Feature Correlation with Machine Failure",
+            labels={'x': 'Feature', 'y': 'Correlation'},
+            color=failure_corr.values,
+            color_continuous_scale="RdYlGn"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Failure Analysis by Type":
+        st.subheader("Failure Analysis by Machine Type")
+        st.info("**Machine Type Meanings**: L = Low Quality/Load, M = Medium Quality/Load, H = High Quality/Load")
+        
+        failure_by_type = df.groupby('Type')['Machine failure'].agg(['count', 'sum', 'mean']).reset_index()
+        failure_by_type.columns = ['Type', 'Total Machines', 'Failures', 'Failure Rate']
+        failure_by_type['Failure Rate'] = failure_by_type['Failure Rate'] * 100
+        failure_by_type['Type_Label'] = failure_by_type['Type'].map({
+            'L': 'L (Low Quality/Load)',
+            'M': 'M (Medium Quality/Load)',
+            'H': 'H (High Quality/Load)'
+        })
+        
+        st.dataframe(failure_by_type[['Type', 'Total Machines', 'Failures', 'Failure Rate']], use_container_width=True)
+        
+        fig = px.bar(
+            failure_by_type,
+            x='Type_Label',
+            y='Failure Rate',
+            title="Failure Rate by Machine Type",
+            color='Type',
+            color_discrete_sequence=['#e74c3c', '#3498db', '#2ecc71'],
+            labels={'Type_Label': 'Machine Type'}
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Tool Wear Analysis":
+        st.subheader("Tool Wear Analysis")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            fig = px.scatter(
+                df,
+                x='Tool wear [min]',
+                y='Machine failure',
+                color='Machine failure',
+                title="Tool Wear vs Machine Failure",
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            tool_wear_by_failure = df.groupby('Machine failure')['Tool wear [min]'].agg(['mean', 'median', 'std'])
+            st.dataframe(tool_wear_by_failure, use_container_width=True)
+        
+        # Tool wear distribution by failure status
+        fig = px.histogram(
+            df,
+            x='Tool wear [min]',
+            color='Machine failure',
+            nbins=50,
+            title="Tool Wear Distribution by Failure Status",
+            barmode='overlay',
+            color_discrete_sequence=['#2ecc71', '#e74c3c']
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Temperature Analysis":
+        st.subheader("Temperature Analysis")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            fig = px.scatter(
+                df,
+                x='Air temperature [K]',
+                y='Process temperature [K]',
+                color='Machine failure',
+                title="Temperature Relationship",
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            temp_by_failure = df.groupby('Machine failure')[
+                ['Air temperature [K]', 'Process temperature [K]', 'Temperature difference [K]']
+            ].mean()
+            st.dataframe(temp_by_failure, use_container_width=True)
+    
+    elif analysis_type == "Power & Rotational Speed Analysis":
+        st.subheader("Power and Rotational Speed Analysis")
+        
+        power_stats = df.groupby('Machine failure')[
+            ['Rotational speed [rpm]', 'Torque [Nm]', 'Power [W]']
+        ].agg(['mean', 'std', 'min', 'max'])
+        
+        st.dataframe(power_stats, use_container_width=True)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            fig = px.box(
+                df,
+                x='Machine failure',
+                y='Rotational speed [rpm]',
+                title="Rotational Speed by Failure Status",
+                color='Machine failure',
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            fig = px.box(
+                df,
+                x='Machine failure',
+                y='Power [W]',
+                title="Power by Failure Status",
+                color='Machine failure',
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Scatter plot: Power vs Rotational Speed
+        fig = px.scatter(
+            df,
+            x='Rotational speed [rpm]',
+            y='Power [W]',
+            color='Machine failure',
+            title="Power vs Rotational Speed",
+            color_discrete_sequence=['#2ecc71', '#e74c3c']
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Outlier Detection":
+        st.subheader("Outlier Detection")
+        
+        feature = st.selectbox(
+            "Select Feature for Outlier Detection",
+            ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 
+             'Torque [Nm]', 'Tool wear [min]']
+        )
+        
+        method = st.radio(
+            "Detection method",
+            options=["IQR (robust, default)", "Z-score"],
+            index=0,
+            horizontal=True,
+            help="IQR is robust to skew; Z-score highlights extreme standardized values."
+        )
+        
+        if method == "IQR (robust, default)":
+            iqr_mult = st.slider("IQR multiplier", 0.5, 3.0, 1.5, 0.1,
+                                 help="Lower the multiplier to surface milder outliers.")
+            Q1 = df[feature].quantile(0.25)
+            Q3 = df[feature].quantile(0.75)
+            IQR = Q3 - Q1
+            lower_bound = Q1 - iqr_mult * IQR
+            upper_bound = Q3 + iqr_mult * IQR
+            
+            outliers = df[(df[feature] < lower_bound) | (df[feature] > upper_bound)]
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Lower Bound", f"{lower_bound:.2f}")
+                st.metric("Upper Bound", f"{upper_bound:.2f}")
+            with col2:
+                st.metric("Outlier Count", len(outliers))
+                st.metric("Outlier Percentage", f"{(len(outliers)/len(df)*100):.2f}%")
+            
+            fig = px.box(df, y=feature, title=f"Box Plot with Outliers - {feature}")
+            st.plotly_chart(fig, use_container_width=True)
+        
+        else:
+            z_thresh = st.slider("Z-score threshold", 2.0, 5.0, 3.0, 0.1,
+                                 help="Lower threshold to surface more anomalies.")
+            mean = df[feature].mean()
+            std = df[feature].std()
+            if std == 0:
+                outliers = df.iloc[0:0]
+                zscores = pd.Series([0]*len(df), index=df.index)
+            else:
+                zscores = (df[feature] - mean) / std
+                outliers = df[zscores.abs() > z_thresh]
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Mean", f"{mean:.2f}")
+                st.metric("Std Dev", f"{std:.2f}")
+            with col2:
+                st.metric("Outlier Count", len(outliers))
+                st.metric("Outlier Percentage", f"{(len(outliers)/len(df)*100):.2f}%")
+            
+            fig = px.histogram(df, x=feature, nbins=60, opacity=0.7,
+                               title=f"{feature} with Z-score Threshold (>|{z_thresh}|)")
+            # Overlay threshold lines
+            fig.add_vline(x=mean + z_thresh*std, line_dash="dash", line_color="red")
+            fig.add_vline(x=mean - z_thresh*std, line_dash="dash", line_color="red")
+            st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Pairwise Relationships":
+        st.subheader("Pairwise Feature Relationships")
+        
+        feature1 = st.selectbox("Select First Feature", 
+                               ['Tool wear [min]', 'Temperature difference [K]', 
+                                'Rotational speed [rpm]', 'Torque [Nm]'])
+        feature2 = st.selectbox("Select Second Feature",
+                               ['Tool wear [min]', 'Temperature difference [K]',
+                                'Rotational speed [rpm]', 'Torque [Nm]'])
+        
+        if feature1 != feature2:
+            fig = px.scatter(
+                df,
+                x=feature1,
+                y=feature2,
+                color='Machine failure',
+                title=f"{feature1} vs {feature2}",
+                color_discrete_sequence=['#2ecc71', '#e74c3c']
+            )
+            st.plotly_chart(fig, use_container_width=True)
+            
+            correlation = df[feature1].corr(df[feature2])
+            st.metric("Correlation", f"{correlation:.4f}")
+    
+    elif analysis_type == "Failure Type Breakdown":
+        st.subheader("Detailed Failure Type Analysis")
+        
+        failure_types = {
+            'TWF': 'Tool Wear Failure',
+            'HDF': 'Heat Dissipation Failure',
+            'PWF': 'Power Failure',
+            'OSF': 'Overstrain Failure',
+            'RNF': 'Random Failure'
+        }
+        
+        for ft_code, ft_name in failure_types.items():
+            with st.expander(f"{ft_name} ({ft_code})"):
+                failed_machines = df[df[ft_code] == 1]
+                if len(failed_machines) > 0:
+                    st.metric("Count", len(failed_machines))
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.metric("Avg Tool Wear", f"{failed_machines['Tool wear [min]'].mean():.2f} min")
+                    with col2:
+                        st.metric("Avg Temp Diff", f"{failed_machines['Temperature difference [K]'].mean():.2f} K")
+                    with col3:
+                        st.metric("Avg Rotational Speed", f"{failed_machines['Rotational speed [rpm]'].mean():.0f} rpm")
+    
+    elif analysis_type == "Time to Failure Estimation":
+        st.subheader("Time to Failure Estimation")
+        
+        # Analyze tool wear progression for machines that failed
+        failed_machines = df[df['Machine failure'] == 1]
+        
+        if len(failed_machines) > 0:
+            avg_tool_wear_at_failure = failed_machines['Tool wear [min]'].mean()
+            median_tool_wear_at_failure = failed_machines['Tool wear [min]'].median()
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Average Tool Wear at Failure", f"{avg_tool_wear_at_failure:.2f} minutes")
+            with col2:
+                st.metric("Median Tool Wear at Failure", f"{median_tool_wear_at_failure:.2f} minutes")
+            
+            # Estimate time remaining for machines not yet failed
+            non_failed = df[df['Machine failure'] == 0].copy()
+            if len(non_failed) > 0:
+                non_failed['Estimated Time to Failure'] = (
+                    avg_tool_wear_at_failure - non_failed['Tool wear [min]']
+                )
+                non_failed['Estimated Time to Failure'] = non_failed['Estimated Time to Failure'].clip(lower=0)
+                
+                st.subheader("Time to Failure Estimates (for non-failed machines)")
+                
+                immediate = (non_failed['Estimated Time to Failure'] < 10).sum()
+                soon = ((non_failed['Estimated Time to Failure'] >= 10) & 
+                       (non_failed['Estimated Time to Failure'] < 50)).sum()
+                remaining = (non_failed['Estimated Time to Failure'] >= 50).sum()
+                
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Immediate Maintenance (< 10 min)", f"{immediate:,}")
+                with col2:
+                    st.metric("Maintenance Soon (10-50 min)", f"{soon:,}")
+                with col3:
+                    st.metric("Time Remaining (> 50 min)", f"{remaining:,}")
+                
+                # Distribution chart
+                fig = px.histogram(
+                    non_failed,
+                    x='Estimated Time to Failure',
+                    nbins=50,
+                    title="Distribution of Estimated Time to Failure",
+                    color_discrete_sequence=['#3498db']
+                )
+                st.plotly_chart(fig, use_container_width=True)
+    
+    elif analysis_type == "Grouped Aggregations":
+        st.subheader("Grouped Aggregations by Type and Failure Status")
+        
+        grouped = df.groupby(['Type', 'Machine failure']).agg({
+            'Tool wear [min]': ['mean', 'std', 'max'],
+            'Temperature difference [K]': ['mean', 'std'],
+            'Rotational speed [rpm]': ['mean', 'std'],
+            'Torque [Nm]': ['mean', 'std']
+        })
+        
+        st.dataframe(grouped, use_container_width=True)
+        
+        # Visualizations
+        st.subheader("Tool Wear by Type and Failure Status")
+        fig = px.box(
+            df,
+            x='Type',
+            y='Tool wear [min]',
+            color='Machine failure',
+            title="Tool Wear Distribution by Type and Failure Status",
+            color_discrete_sequence=['#2ecc71', '#e74c3c']
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        st.subheader("Temperature Difference by Type and Failure Status")
+        fig = px.box(
+            df,
+            x='Type',
+            y='Temperature difference [K]',
+            color='Machine failure',
+            title="Temperature Difference by Type and Failure Status",
+            color_discrete_sequence=['#2ecc71', '#e74c3c']
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+def show_model_predictions(df):
+    """Model and predictions page"""
+    st.markdown('<h2 class="sub-header">🤖 Machine Learning Model & Predictions</h2>', unsafe_allow_html=True)
+    
+    # Train model section
+    if st.session_state.model is None:
+        st.info("⚠️ Model not trained yet. Click the button below to train the model.")
+        if st.button("Train Model", type="primary"):
+            results = train_model()
+            st.success("✅ Model trained successfully!")
+            st.session_state.model_results = results
+    
+    if st.session_state.model is not None:
+        model = st.session_state.model
+        preprocessor = st.session_state.preprocessor
+        
+        # Model performance section
+        st.subheader("Model Performance")
+        
+        if 'model_results' in st.session_state:
+            results = st.session_state.model_results
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Accuracy", f"{results['accuracy']:.4f}")
+            with col2:
+                st.metric("Precision", f"{results['precision']:.4f}")
+            with col3:
+                st.metric("Recall", f"{results['recall']:.4f}")
+            with col4:
+                st.metric("F1-Score", f"{results['f1_score']:.4f}")
+        
+        # Feature importance
+        st.subheader("Feature Importance")
+        feature_importance = model.get_feature_importance()
+        fig = px.bar(
+            feature_importance,
+            x='importance',
+            y='feature',
+            orientation='h',
+            title="Feature Importance",
+            color='importance',
+            color_continuous_scale="Viridis"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        st.markdown("---")
+        
+        # Runtime prediction section
+        st.subheader("🔮 Runtime Prediction - Predict Maintenance Needs")
+        st.markdown("Enter machine parameters below to predict if maintenance is needed:")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            machine_type = st.selectbox(
+                "Machine Type", 
+                ['L', 'M', 'H'],
+                format_func=lambda x: f"{x} ({'Low Quality/Load' if x == 'L' else 'Medium Quality/Load' if x == 'M' else 'High Quality/Load'})"
+            )
+            air_temp = st.slider("Air Temperature (K)", 
+                                min_value=295.0, max_value=305.0, value=298.0, step=0.1)
+            process_temp = st.slider("Process Temperature (K)",
+                                    min_value=305.0, max_value=315.0, value=309.0, step=0.1)
+        
+        with col2:
+            rotational_speed = st.slider("Rotational Speed (rpm)",
+                                        min_value=1000, max_value=3000, value=1500, step=10)
+            torque = st.slider("Torque (Nm)",
+                             min_value=10.0, max_value=80.0, value=40.0, step=0.1)
+            tool_wear = st.slider("Tool Wear (minutes)",
+                                min_value=0, max_value=300, value=50, step=1)
+        
+        if st.button("Predict Maintenance Status", type="primary"):
+            # Create input data
+            input_data = pd.DataFrame({
+                'Type': [machine_type],
+                'Air temperature [K]': [air_temp],
+                'Process temperature [K]': [process_temp],
+                'Rotational speed [rpm]': [rotational_speed],
+                'Torque [Nm]': [torque],
+                'Tool wear [min]': [tool_wear]
+            })
+            
+            # Preprocess
+            X_new = preprocessor.preprocess_new_data(input_data)
+            
+            # Predict
+            maintenance_pred = model.predict_maintenance(X_new, tool_wear_values=[tool_wear])
+            
+            # Display results
+            st.markdown("### Prediction Results")
+            
+            failure_prob = maintenance_pred['Failure_Probability'].iloc[0]
+            time_to_failure = maintenance_pred['Time_to_Failure_Minutes'].iloc[0]
+            status = maintenance_pred['Maintenance_Status'].iloc[0]
+            urgency = maintenance_pred['Maintenance_Urgency'].iloc[0]
+            
+            # Color coding
+            if urgency == "CRITICAL":
+                st.error(f"🚨 **{status}**")
+            elif urgency == "HIGH":
+                st.warning(f"⚠️ **{status}**")
+            elif urgency == "MEDIUM":
+                st.info(f"ℹ️ **{status}**")
+            else:
+                st.success(f"✅ **{status}**")
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Failure Probability", f"{failure_prob:.2%}")
+            with col2:
+                st.metric("Estimated Time to Maintenance", f"{time_to_failure:.1f} minutes")
+                if time_to_failure > 0:
+                    st.caption(f"Based on historical data: avg failure at 120 min tool wear")
+                else:
+                    st.caption("Tool wear exceeded average failure threshold (120 min)")
+            with col3:
+                st.metric("Maintenance Urgency", urgency)
+            
+            # Detailed information
+            with st.expander("View Detailed Information"):
+                st.markdown(f"""
+                **Machine Parameters:**
+                - Type: {machine_type} ({'Low Quality/Load' if machine_type == 'L' else 'Medium Quality/Load' if machine_type == 'M' else 'High Quality/Load'})
+                - Air Temperature: {air_temp} K
+                - Process Temperature: {process_temp} K
+                - Rotational Speed: {rotational_speed} rpm
+                - Torque: {torque} Nm
+                - Tool Wear: {tool_wear} minutes
+                
+                **Prediction Details:**
+                - Failure Predicted: {'Yes' if maintenance_pred['Failure_Predicted'].iloc[0] == 1 else 'No'}
+                - Failure Probability: {failure_prob:.2%}
+                - Estimated Time to Maintenance: {time_to_failure:.1f} minutes
+                  *Based on historical analysis: Machines in this dataset typically require maintenance when tool wear reaches approximately 120 minutes. 
+                  This estimate projects when your machine will reach that threshold based on current tool wear level.*
+                - Maintenance Status: {status}
+                - Urgency Level: {urgency}
+                
+                **Recommendation:**
+                {get_maintenance_recommendation(urgency, time_to_failure, failure_prob)}
+                """)
+        
+        st.markdown("---")
+        
+        # Batch prediction section
+        st.subheader("Batch Prediction")
+        st.markdown("Upload a CSV file with machine data for batch predictions:")
+        
+        uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
+        
+        if uploaded_file is not None:
+            try:
+                batch_data = pd.read_csv(uploaded_file)
+                st.dataframe(batch_data.head(), use_container_width=True)
+                
+                if st.button("Predict for Batch", type="primary"):
+                    # Check required columns
+                    required_cols = ['Type', 'Air temperature [K]', 'Process temperature [K]',
+                                    'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']
+                    
+                    if all(col in batch_data.columns for col in required_cols):
+                        X_batch = preprocessor.preprocess_new_data(batch_data)
+                        tool_wear_batch = batch_data['Tool wear [min]'].values
+                        batch_predictions = model.predict_maintenance(X_batch, tool_wear_batch)
+                        
+                        # Combine with original data
+                        results_df = pd.concat([batch_data, batch_predictions], axis=1)
+                        
+                        st.success("✅ Batch prediction complete!")
+                        st.dataframe(results_df, use_container_width=True)
+                        
+                        # Summary statistics
+                        st.subheader("Batch Prediction Summary")
+                        col1, col2, col3, col4 = st.columns(4)
+                        with col1:
+                            st.metric("Total Machines", len(batch_data))
+                        with col2:
+                            st.metric("Critical Maintenance", 
+                                    (batch_predictions['Maintenance_Urgency'] == 'CRITICAL').sum())
+                        with col3:
+                            st.metric("High Priority", 
+                                    (batch_predictions['Maintenance_Urgency'] == 'HIGH').sum())
+                        with col4:
+                            st.metric("Average Time to Failure", 
+                                    f"{batch_predictions['Time_to_Failure_Minutes'].mean():.1f} min")
+                    else:
+                        st.error(f"CSV must contain these columns: {', '.join(required_cols)}")
+            except Exception as e:
+                st.error(f"Error processing file: {str(e)}")
+
+def get_maintenance_recommendation(urgency, time_to_failure, failure_prob):
+    """Get maintenance recommendation based on prediction"""
+    if urgency == "CRITICAL":
+        return "**IMMEDIATE ACTION REQUIRED**: Stop the machine immediately and perform maintenance. Failure is imminent."
+    elif urgency == "HIGH":
+        if time_to_failure < 60:
+            return f"**URGENT**: Schedule maintenance within {int(time_to_failure/60)} hour(s) or immediately if possible. The machine shows high risk of failure."
+        else:
+            return f"**Schedule maintenance within {int(time_to_failure/60)} hours**. The machine shows high risk of failure."
+    elif urgency == "MEDIUM":
+        if time_to_failure < 20:
+            return f"**Schedule maintenance within the next 20-30 minutes**. Monitor the machine very closely. Estimated time to maintenance: {time_to_failure:.0f} minutes."
+        elif time_to_failure < 60:
+            return f"**Schedule maintenance within the next hour**. Monitor the machine closely. Estimated time to maintenance: {time_to_failure:.0f} minutes."
+        elif time_to_failure < 120:
+            return f"**Plan maintenance within the next 2 hours**. Monitor the machine closely. Estimated time to maintenance: {int(time_to_failure/60)} hours."
+        else:
+            return f"**Plan maintenance within the next few days**. Monitor the machine regularly. Estimated time to maintenance: {int(time_to_failure/60)} hours."
+    else:
+        if time_to_failure < 120:
+            return f"**Monitor regularly**. No immediate action needed, but plan maintenance soon. Estimated time to maintenance: {int(time_to_failure/60)} hours."
+        else:
+            return f"**No immediate action needed**. Continue regular monitoring. Estimated time to maintenance: {int(time_to_failure/60)} hours."
+
+def show_conclusion():
+    """Conclusion page"""
+    st.markdown('<h2 class="sub-header">📝 Conclusion & Key Takeaways</h2>', unsafe_allow_html=True)
+    
+    st.markdown("""
+    ### Project Summary
+    
+    This predictive maintenance project successfully analyzed the AI4I 2020 dataset and built 
+    a machine learning model to predict machine failures and estimate maintenance needs.
+    
+    ### Key Findings
+    
+    1. **Dataset Characteristics**:
+       - The dataset contains 10,000 machine records with 14 features
+       - Machine failure rate is approximately 3.39% (imbalanced dataset)
+       - Five different failure types were identified: TWF, HDF, PWF, OSF, and RNF
+    
+    2. **Important Features**:
+       - Tool wear is a critical indicator of machine health
+       - Temperature difference between process and air temperature correlates with failures
+       - Machine type (L = Low Quality/Load, M = Medium Quality/Load, H = High Quality/Load) affects failure rates differently
+       - Rotational speed and torque relationships are important predictors
+    
+    3. **Model Performance**:
+       - Random Forest Classifier achieved good performance on the imbalanced dataset
+       - The model can effectively predict machine failures
+       - Feature importance analysis revealed tool wear and temperature as key predictors
+    
+    4. **Maintenance Insights**:
+       - Machines with tool wear > 100 minutes are at higher risk
+       - Temperature differences > 10K indicate potential heat dissipation issues
+       - Early detection can prevent costly downtime
+    
+    ### Applications
+    
+    This system can be used in real-world industrial settings to:
+    - **Prevent unexpected failures** by predicting maintenance needs
+    - **Optimize maintenance schedules** based on actual machine conditions
+    - **Reduce downtime** through proactive maintenance
+    - **Save costs** by avoiding catastrophic failures
+    
+    ### Future Improvements
+    
+    1. **Model Enhancement**:
+       - Try ensemble methods (XGBoost, LightGBM)
+       - Implement time-series analysis for sequential data
+       - Add anomaly detection algorithms
+    
+    2. **Feature Engineering**:
+       - Create more domain-specific features
+       - Include historical maintenance records
+       - Add environmental factors
+    
+    3. **System Integration**:
+       - Real-time data streaming
+       - Integration with IoT sensors
+       - Automated alert system
+    
+    ### Technical Stack
+    
+    - **Data Analysis**: Pandas, NumPy
+    - **Visualization**: Matplotlib, Seaborn, Plotly
+    - **Machine Learning**: Scikit-learn (Random Forest)
+    - **Web Application**: Streamlit
+    - **Preprocessing**: StandardScaler, LabelEncoder
+    
+    ### Acknowledgments
+    
+    Dataset: AI4I 2020 Predictive Maintenance Dataset
+    
+    ---
+    
+    **Project completed for Introduction to Data Science Course (IDS F24)**
+    """)
+    
+    st.markdown("---")
+    st.markdown("### Thank you for using the Predictive Maintenance System! 🔧")
+
+if __name__ == "__main__":
+    main()
+

model.py

@@ -0,0 +1,235 @@
+"""
+Machine Learning Model for Predictive Maintenance
+Uses Random Forest Classifier for failure prediction
+"""
+
+import pandas as pd
+import numpy as np
+import pickle
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    confusion_matrix, classification_report, roc_auc_score
+)
+import warnings
+warnings.filterwarnings('ignore')
+
+class PredictiveMaintenanceModel:
+    def __init__(self):
+        """Initialize the model"""
+        self.model = RandomForestClassifier(
+            n_estimators=100,
+            max_depth=10,
+            min_samples_split=5,
+            min_samples_leaf=2,
+            random_state=42,
+            class_weight='balanced'  # Handle class imbalance
+        )
+        self.is_trained = False
+        self.feature_importance_ = None
+        
+    def train(self, X_train, y_train):
+        """Train the model"""
+        print("Training Random Forest Classifier...")
+        self.model.fit(X_train, y_train)
+        self.is_trained = True
+        
+        # Get feature importance
+        self.feature_importance_ = pd.DataFrame({
+            'feature': X_train.columns,
+            'importance': self.model.feature_importances_
+        }).sort_values('importance', ascending=False)
+        
+        print("Model training complete!")
+        return self
+    
+    def predict(self, X):
+        """Make predictions"""
+        if not self.is_trained:
+            raise ValueError("Model must be trained first!")
+        return self.model.predict(X)
+    
+    def predict_proba(self, X):
+        """Get prediction probabilities"""
+        if not self.is_trained:
+            raise ValueError("Model must be trained first!")
+        return self.model.predict_proba(X)
+    
+    def evaluate(self, X_test, y_test):
+        """Evaluate the model"""
+        if not self.is_trained:
+            raise ValueError("Model must be trained first!")
+        
+        # Predictions
+        y_pred = self.predict(X_test)
+        y_pred_proba = self.predict_proba(X_test)[:, 1]
+        
+        # Metrics
+        accuracy = accuracy_score(y_test, y_pred)
+        precision = precision_score(y_test, y_pred, zero_division=0)
+        recall = recall_score(y_test, y_pred, zero_division=0)
+        f1 = f1_score(y_test, y_pred, zero_division=0)
+        roc_auc = roc_auc_score(y_test, y_pred_proba)
+        
+        # Confusion matrix
+        cm = confusion_matrix(y_test, y_pred)
+        
+        # Classification report
+        report = classification_report(y_test, y_pred, zero_division=0)
+        
+        results = {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall,
+            'f1_score': f1,
+            'roc_auc': roc_auc,
+            'confusion_matrix': cm,
+            'classification_report': report,
+            'y_pred': y_pred,
+            'y_pred_proba': y_pred_proba
+        }
+        
+        print("="*60)
+        print("MODEL EVALUATION RESULTS")
+        print("="*60)
+        print(f"Accuracy:  {accuracy:.4f}")
+        print(f"Precision: {precision:.4f}")
+        print(f"Recall:    {recall:.4f}")
+        print(f"F1-Score:  {f1:.4f}")
+        print(f"ROC-AUC:   {roc_auc:.4f}")
+        print("\nConfusion Matrix:")
+        print(cm)
+        print("\nClassification Report:")
+        print(report)
+        
+        return results
+    
+    def predict_maintenance(self, X, tool_wear_values=None):
+        """
+        Predict maintenance needs and time to failure
+        
+        Args:
+            X: Feature matrix
+            tool_wear_values: Array of tool wear values (optional)
+        
+        Returns:
+            DataFrame with predictions and maintenance recommendations
+        """
+        if not self.is_trained:
+            raise ValueError("Model must be trained first!")
+        
+        # Get failure predictions
+        failure_pred = self.predict(X)
+        failure_proba = self.predict_proba(X)[:, 1]
+        
+        # Estimate time to failure based on tool wear
+        # Average tool wear at failure is around 100-150 minutes based on EDA
+        avg_tool_wear_at_failure = 120  # minutes
+        
+        if tool_wear_values is None:
+            # Try to get tool wear from features if available
+            if 'Tool wear [min]' in X.columns:
+                tool_wear_values = X['Tool wear [min]'].values
+            else:
+                tool_wear_values = np.zeros(len(X))
+        else:
+            # Convert to numpy array if it's a list or scalar
+            tool_wear_values = np.array(tool_wear_values)
+            # If it's a scalar, make it an array
+            if tool_wear_values.ndim == 0:
+                tool_wear_values = np.array([tool_wear_values])
+        
+        # Ensure tool_wear_values is 1D array with same length as predictions
+        if len(tool_wear_values) != len(failure_pred):
+            # If single value provided, repeat it for all predictions
+            if len(tool_wear_values) == 1:
+                tool_wear_values = np.repeat(tool_wear_values, len(failure_pred))
+            else:
+                raise ValueError(f"tool_wear_values length ({len(tool_wear_values)}) doesn't match predictions length ({len(failure_pred)})")
+        
+        # Calculate estimated time to failure
+        time_to_failure = np.maximum(0, avg_tool_wear_at_failure - tool_wear_values)
+        
+        # Determine maintenance urgency
+        maintenance_status = []
+        maintenance_urgency = []
+        
+        for i in range(len(failure_pred)):
+            # Check if tool wear has exceeded the average failure threshold
+            tool_wear_exceeded = tool_wear_values[i] >= avg_tool_wear_at_failure
+            tool_wear_severely_exceeded = tool_wear_values[i] >= (avg_tool_wear_at_failure * 1.5)  # 150% of threshold (180 min)
+            
+            # Combined risk assessment: consider both ML prediction AND tool wear
+            if failure_pred[i] == 1:
+                # Model predicts failure - highest priority
+                maintenance_status.append("IMMEDIATE MAINTENANCE REQUIRED")
+                maintenance_urgency.append("CRITICAL")
+            elif tool_wear_severely_exceeded and failure_proba[i] > 0.2:
+                # Severely exceeded tool wear AND significant failure probability
+                maintenance_status.append("IMMEDIATE MAINTENANCE REQUIRED - Tool wear severely exceeded threshold")
+                maintenance_urgency.append("CRITICAL")
+            elif tool_wear_severely_exceeded:
+                # Severely exceeded tool wear but low failure probability - still HIGH priority
+                maintenance_status.append("URGENT MAINTENANCE NEEDED - Tool wear severely exceeded (monitor closely)")
+                maintenance_urgency.append("HIGH")
+            elif tool_wear_exceeded and failure_proba[i] > 0.3:
+                # Tool wear exceeded AND moderate failure probability
+                maintenance_status.append("IMMEDIATE MAINTENANCE REQUIRED - Tool wear exceeded threshold")
+                maintenance_urgency.append("CRITICAL")
+            elif tool_wear_exceeded:
+                # Tool wear exceeded but low failure probability - HIGH priority
+                maintenance_status.append("URGENT MAINTENANCE NEEDED - Tool wear exceeded threshold")
+                maintenance_urgency.append("HIGH")
+            elif failure_proba[i] > 0.7:
+                # High failure probability regardless of tool wear
+                maintenance_status.append("Maintenance needed soon")
+                maintenance_urgency.append("HIGH")
+            elif failure_proba[i] > 0.4:
+                # Moderate failure probability
+                maintenance_status.append("Schedule maintenance")
+                maintenance_urgency.append("MEDIUM")
+            elif time_to_failure[i] < 20:
+                # Less than 20 minutes remaining
+                maintenance_status.append("Monitor closely - Maintenance needed within 20 minutes")
+                maintenance_urgency.append("MEDIUM")
+            elif time_to_failure[i] < 60:
+                # Less than 1 hour remaining
+                maintenance_status.append("Monitor closely - Maintenance needed within 1 hour")
+                maintenance_urgency.append("MEDIUM")
+            else:
+                # Low risk
+                maintenance_status.append("No immediate maintenance needed")
+                maintenance_urgency.append("LOW")
+        
+        results_df = pd.DataFrame({
+            'Failure_Predicted': failure_pred,
+            'Failure_Probability': failure_proba,
+            'Time_to_Failure_Minutes': time_to_failure,
+            'Maintenance_Status': maintenance_status,
+            'Maintenance_Urgency': maintenance_urgency
+        })
+        
+        return results_df
+    
+    
+    def get_feature_importance(self):
+        """Get feature importance"""
+        if self.feature_importance_ is None:
+            raise ValueError("Model must be trained first!")
+        return self.feature_importance_
+    
+    def save_model(self, filepath='predictive_maintenance_model.pkl'):
+        """Save the trained model"""
+        if not self.is_trained:
+            raise ValueError("Model must be trained first!")
+        
+        with open(filepath, 'wb') as f:
+            pickle.dump(self.model, f)
+        print(f"Model saved to {filepath}")
+    
+    def load_model(self, filepath='predictive_maintenance_model.pkl'):
+        """Load a trained model"""
+        with open(filepath, 'rb') as f:
+            self.model = pickle.load(f)
+        self.is_trained = True
+        print(f"Model loaded from {filepath}")

preprocessing.py

@@ -0,0 +1,205 @@
+"""
+Data Preprocessing Module for AI4I 2020 Predictive Maintenance Dataset
+Handles missing values, encoding, scaling, and train-test splitting
+"""
+
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.impute import SimpleImputer
+
+class DataPreprocessor:
+    def __init__(self, data_path='ai4i2020.csv'):
+        """Initialize the preprocessor"""
+        self.df = pd.read_csv(data_path)
+        self.scaler = StandardScaler()
+        self.label_encoder = LabelEncoder()
+        self.feature_columns = None
+        self.is_fitted = False
+        
+    def create_features(self):
+        """Create additional features"""
+        # Temperature difference
+        self.df['Temperature difference [K]'] = (
+            self.df['Process temperature [K]'] - 
+            self.df['Air temperature [K]']
+        )
+        
+        # Power calculation
+        self.df['Power [W]'] = (
+            self.df['Rotational speed [rpm]'] * 
+            self.df['Torque [Nm]'] / 9.5488
+        )
+        
+        # Tool wear rate (if we had time data, but we'll use a proxy)
+        # We can create bins for tool wear
+        self.df['Tool wear category'] = pd.cut(
+            self.df['Tool wear [min]'],
+            bins=[0, 50, 100, 150, 200, 300],
+            labels=['Very Low', 'Low', 'Medium', 'High', 'Very High']
+        )
+        
+    def handle_missing_values(self):
+        """Handle missing values"""
+        # Check for missing values
+        missing = self.df.isnull().sum()
+        
+        if missing.sum() > 0:
+            # For numerical columns, use mean imputation
+            numerical_cols = self.df.select_dtypes(include=[np.number]).columns
+            imputer = SimpleImputer(strategy='mean')
+            self.df[numerical_cols] = imputer.fit_transform(self.df[numerical_cols])
+            
+            # For categorical columns, use mode imputation
+            categorical_cols = self.df.select_dtypes(include=['object']).columns
+            for col in categorical_cols:
+                if self.df[col].isnull().sum() > 0:
+                    mode_value = self.df[col].mode()[0]
+                    self.df[col].fillna(mode_value, inplace=True)
+        else:
+            print("No missing values found in the dataset.")
+    
+    def encode_categorical_variables(self):
+        """Encode categorical variables"""
+        # Encode Type column
+        self.df['Type_encoded'] = self.label_encoder.fit_transform(self.df['Type'])
+        
+        # One-hot encode Type (alternative approach)
+        type_dummies = pd.get_dummies(self.df['Type'], prefix='Type')
+        self.df = pd.concat([self.df, type_dummies], axis=1)
+        
+        # Encode Tool wear category if it exists
+        if 'Tool wear category' in self.df.columns:
+            self.df['Tool_wear_category_encoded'] = LabelEncoder().fit_transform(
+                self.df['Tool wear category'].astype(str)
+            )
+    
+    def select_features(self):
+        """Select features for modeling"""
+        # Drop non-feature columns
+        columns_to_drop = [
+            'UDI', 'Product ID', 'Type', 'Tool wear category'
+        ]
+        
+        # Keep only relevant columns
+        feature_columns = [
+            'Air temperature [K]',
+            'Process temperature [K]',
+            'Rotational speed [rpm]',
+            'Torque [Nm]',
+            'Tool wear [min]',
+            'Temperature difference [K]',
+            'Power [W]',
+            'Type_encoded',
+            'Type_H',
+            'Type_L',
+            'Type_M'
+        ]
+        
+        # Remove columns that don't exist
+        feature_columns = [col for col in feature_columns if col in self.df.columns]
+        
+        self.feature_columns = feature_columns
+        return feature_columns
+    
+    def scale_features(self, X_train, X_test):
+        """Scale numerical features"""
+        # Scale training data
+        X_train_scaled = self.scaler.fit_transform(X_train)
+        X_test_scaled = self.scaler.transform(X_test)
+        
+        # Convert back to DataFrame
+        X_train_scaled = pd.DataFrame(
+            X_train_scaled,
+            columns=X_train.columns,
+            index=X_train.index
+        )
+        X_test_scaled = pd.DataFrame(
+            X_test_scaled,
+            columns=X_test.columns,
+            index=X_test.index
+        )
+        
+        return X_train_scaled, X_test_scaled
+    
+    def prepare_data(self, target='Machine failure', test_size=0.2, random_state=42):
+        """Complete preprocessing pipeline"""
+        print("Starting data preprocessing...")
+        
+        # Step 1: Create features
+        print("1. Creating additional features...")
+        self.create_features()
+        
+        # Step 2: Handle missing values
+        print("2. Handling missing values...")
+        self.handle_missing_values()
+        
+        # Step 3: Encode categorical variables
+        print("3. Encoding categorical variables...")
+        self.encode_categorical_variables()
+        
+        # Step 4: Select features
+        print("4. Selecting features...")
+        feature_columns = self.select_features()
+        
+        # Step 5: Prepare X and y
+        X = self.df[feature_columns]
+        y = self.df[target]
+        
+        # Step 6: Split data
+        print("5. Splitting data into train and test sets...")
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=random_state, stratify=y
+        )
+        
+        # Step 7: Scale features
+        print("6. Scaling features...")
+        X_train_scaled, X_test_scaled = self.scale_features(X_train, X_test)
+        
+        self.is_fitted = True
+        
+        print("Preprocessing complete!")
+        print(f"Training set shape: {X_train_scaled.shape}")
+        print(f"Test set shape: {X_test_scaled.shape}")
+        print(f"Features: {feature_columns}")
+        
+        return X_train_scaled, X_test_scaled, y_train, y_test, feature_columns
+    
+    def preprocess_new_data(self, new_data):
+        """Preprocess new data for prediction (using fitted scaler and encoders)"""
+        if not self.is_fitted:
+            raise ValueError("Preprocessor must be fitted first using prepare_data()")
+        
+        # Create a copy
+        df_new = new_data.copy()
+        
+        # Create features
+        df_new['Temperature difference [K]'] = (
+            df_new['Process temperature [K]'] - 
+            df_new['Air temperature [K]']
+        )
+        df_new['Power [W]'] = (
+            df_new['Rotational speed [rpm]'] * 
+            df_new['Torque [Nm]'] / 9.5488
+        )
+        
+        # Encode Type
+        df_new['Type_encoded'] = self.label_encoder.transform(df_new['Type'])
+        type_dummies = pd.get_dummies(df_new['Type'], prefix='Type')
+        
+        # Ensure all Type columns exist
+        for col in ['Type_H', 'Type_L', 'Type_M']:
+            if col not in type_dummies.columns:
+                type_dummies[col] = 0
+        
+        df_new = pd.concat([df_new, type_dummies[['Type_H', 'Type_L', 'Type_M']]], axis=1)
+        
+        # Select features
+        X_new = df_new[self.feature_columns]
+        
+        # Scale
+        X_new_scaled = self.scaler.transform(X_new)
+        X_new_scaled = pd.DataFrame(X_new_scaled, columns=self.feature_columns)
+        
+        return X_new_scaled

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+pandas==2.1.4
+numpy==1.26.2
+scikit-learn==1.4.0
+streamlit==1.29.0
+plotly==5.18.0

train_model.py

@@ -0,0 +1,52 @@
+"""
+Script to train and save the predictive maintenance model
+Run this script before using the Streamlit app for the first time
+"""
+
+from preprocessing import DataPreprocessor
+from model import PredictiveMaintenanceModel
+import pickle
+
+def main():
+    print("="*60)
+    print("Training Predictive Maintenance Model")
+    print("="*60)
+    
+    # Initialize preprocessor
+    print("\n1. Loading and preprocessing data...")
+    preprocessor = DataPreprocessor('ai4i2020.csv')
+    
+    # Prepare data
+    X_train, X_test, y_train, y_test, feature_columns = preprocessor.prepare_data()
+    
+    # Train model
+    print("\n2. Training model...")
+    model = PredictiveMaintenanceModel()
+    model.train(X_train, y_train)
+    
+    # Evaluate model
+    print("\n3. Evaluating model...")
+    results = model.evaluate(X_test, y_test)
+    
+    # Save model and preprocessor
+    print("\n4. Saving model and preprocessor...")
+    model.save_model('predictive_maintenance_model.pkl')
+    
+    with open('preprocessor.pkl', 'wb') as f:
+        pickle.dump(preprocessor, f)
+    
+    print("\n5. Saving feature columns...")
+    with open('feature_columns.pkl', 'wb') as f:
+        pickle.dump(feature_columns, f)
+    
+    print("\n" + "="*60)
+    print("Model training complete!")
+    print("="*60)
+    print("\nModel files saved:")
+    print("  - predictive_maintenance_model.pkl")
+    print("  - preprocessor.pkl")
+    print("  - feature_columns.pkl")
+    print("\nYou can now run the Streamlit app: streamlit run app.py")
+
+if __name__ == "__main__":
+    main()