Update app.py

app.py

@@ -1,9 +1,9 @@
-import os
-import tempfile
 import pandas as pd
-import pickle
+import numpy as np
+import joblib
 import gradio as gr
-from datetime import datetime
+import os
+import tempfile
 
 # Set a custom directory for Gradio's temporary files
 os.environ["GRADIO_TEMP"] = tempfile.mkdtemp()
@@ -17,159 +17,134 @@ device_models = {
     "Fridge": "fridge_model.pkl"
 }
 
-# Define the device-specific features
+# Define required numeric features for each device
 device_features = {
-    "Fridge": ["date_numeric", "time_numeric", "fridge_temperature", "label"],
     "Garage Door": ["date_numeric", "time_numeric", "door_state", "sphone_signal", "label"],
     "GPS Tracker": ["date_numeric", "time_numeric", "latitude", "longitude", "label"],
-    "Thermostat": ["date_numeric", "time_numeric", "current_temp", "thermostat_status", "label"],
-    "Weather": ["date_numeric", "time_numeric", "temperature", "pressure", "humidity", "label"]
+    "Weather": ["date_numeric", "time_numeric", "temperature", "humidity", "label"],
+    "Thermostat": ["date_numeric", "time_numeric", "temp_set", "temp_actual", "label"],
+    "Fridge": ["date_numeric", "time_numeric", "temp_inside", "door_open", "label"]
 }
 
-# Define class labels for attack types
+# Class labels for attack types (assuming same for all devices; adjust if needed)
 class_labels = {
     0: "Normal",
     1: "Backdoor",
     2: "DDoS",
     3: "Injection",
-    4: "Password",
+    4: "Password Attack",
     5: "Ransomware",
     6: "Scanning",
-    7: "XSS"
+    7: "XSS",
 }
 
-def convert_datetime_features(df):
-    """Convert date and time to numeric features with flexible format handling."""
+def convert_datetime_features(log_data):
+    """Convert date and time into numeric values."""
     try:
-        # Copy dataframe to avoid modifying original
-        df = df.copy()
-        
-        # Try multiple date formats
-        date_formats = ['%d-%b-%y', '%d-%m-%y', '%Y-%m-%d']
-        df['date_numeric'] = pd.Series(index=df.index, dtype='float64')
-        
-        for fmt in date_formats:
-            try:
-                # Attempt to parse dates with the current format
-                valid_dates = pd.to_datetime(df['date'], format=fmt, errors='coerce')
-                if valid_dates.notna().any():
-                    df['date_numeric'] = valid_dates.astype('int64') // 10**9
-                    break
-            except Exception:
-                continue
-        
-        # Check for unparsed dates
-        if df['date_numeric'].isna().any():
-            invalid_rows = df[df['date_numeric'].isna()]['date'].to_list()
-            raise ValueError(f"Invalid date formats in rows: {invalid_rows[:5]}")
-
-        # Convert time to seconds since midnight
-        df['time'] = pd.to_datetime(df['time'], format='%H:%M:%S', errors='coerce')
-        if df['time'].isna().any():
-            invalid_times = df[df['time'].isna()]['time'].to_list()
-            raise ValueError(f"Invalid time formats in rows: {invalid_times[:5]}")
-        df['time_numeric'] = df['time'].dt.hour * 3600 + df['time'].dt.minute * 60 + df['time'].dt.second
-
-        return df
+        log_data['date'] = pd.to_datetime(log_data['date'], format='%d-%m-%y', errors='coerce')
+        log_data['date_numeric'] = log_data['date'].astype(np.int64) // 10**9  
+
+        time_parsed = pd.to_datetime(log_data['time'], format='%H:%M:%S', errors='coerce')
+        log_data['time_numeric'] = (time_parsed.dt.hour * 3600) + (time_parsed.dt.minute * 60) + time_parsed.dt.second
+    except Exception as e:
+        return f"Error processing date/time: {str(e)}", None
     
+    return None, log_data
+
+def detect_intrusion(device, file):
+    """Process log file and predict attack type based on selected device."""
+    # Load the selected device's model
+    try:
+        model = joblib.load(device_models[device])
     except Exception as e:
-        raise ValueError(f"Error converting date/time: {str(e)}")
+        return f"Error loading model for {device}: {str(e)}", None, None
 
-def detect_intrusion(file, device_type="Fridge"):
+    # Read the uploaded file
     try:
-        # Read the input CSV file
-        if isinstance(file, str):
-            log_data = pd.read_csv(file)
-        else:
-            log_data = pd.read_csv(file.name)
-
-        # Validate device type
-        if device_type not in device_features:
-            error_df = pd.DataFrame({"Error": [f"Unsupported device type: {device_type}"]})
-            return error_df, None
-
-        # Convert date and time to numeric features
-        log_data = convert_datetime_features(log_data)
-
-        # Preprocess features based on device type
-        if device_type == "Fridge":
-            log_data['fridge_temperature'] = pd.to_numeric(log_data['fridge_temperature'], errors='coerce')
-        elif device_type == "Garage Door":
-            log_data['door_state'] = log_data['door_state'].map({'closed': 0, 'open': 1})
-            log_data['sphone_signal'] = log_data['sphone_signal'].astype(int)
-        elif device_type == "GPS Tracker":
+        log_data = pd.read_csv(file.name)
+    except Exception as e:
+        return f"Error reading file: {str(e)}", None, None
+
+    # Convert date and time features
+    error, log_data = convert_datetime_features(log_data)
+    if error:
+        return error, None, None
+
+    # Get the required features for the selected device
+    required_features = device_features[device]
+    missing_features = [feature for feature in required_features if feature not in log_data.columns]
+    if missing_features:
+        return f"Missing features for {device}: {', '.join(missing_features)}", None, None
+
+    # Preprocess device-specific features
+    try:
+        if device == "Garage Door":
+            log_data['door_state'] = log_data['door_state'].astype(str).str.strip().replace({'closed': 0, 'open': 1})
+            log_data['sphone_signal'] = pd.to_numeric(log_data['sphone_signal'], errors='coerce')
+        elif device == "GPS Tracker":
             log_data['latitude'] = pd.to_numeric(log_data['latitude'], errors='coerce')
             log_data['longitude'] = pd.to_numeric(log_data['longitude'], errors='coerce')
-        elif device_type == "Thermostat":
-            log_data['current_temp'] = pd.to_numeric(log_data['current_temp'], errors='coerce')
-            log_data['thermostat_status'] = log_data['thermostat_status'].astype(int)
-        elif device_type == "Weather":
-            for col in ['temperature', 'pressure', 'humidity']:
-                log_data[col] = pd.to_numeric(log_data[col], errors='coerce')
-
-        # Select relevant features
-        required_features = device_features[device_type]
-        missing_features = [f for f in required_features if f not in log_data.columns]
-        if missing_features:
-            error_df = pd.DataFrame({"Error": [f"Missing features for {device_type}: {', '.join(missing_features)}"]})
-            return error_df, None
-
-        # Load the pre-trained model
-        try:
-            with open(device_models[device_type], "rb") as f:
-                model = pickle.load(f)
-        except FileNotFoundError:
-            error_df = pd.DataFrame({"Error": [f"Model file for {device_type} not found: {device_models[device_type]}"]})
-            return error_df, None
-        except KeyError:
-            error_df = pd.DataFrame({"Error": [f"No model defined for device type: {device_type}"]})
-            return error_df, None
-
-        # Prepare features for prediction (exclude label if present)
-        features = [f for f in required_features if f != "label"]
-        X = log_data[features]
-
-        # Make predictions
-        predictions = model.predict(X)
-
-        # Map predictions to class labels
-        log_data['Prediction'] = [class_labels.get(pred, "Unknown") for pred in predictions]
-
-        # Format date for output
-        log_data['date'] = log_data['date'].dt.strftime('%Y-%m-%d')
-
-        # Select output columns
-        output_data = log_data[['date', 'time', 'Prediction']]
-
-        # Save results to CSV
-        output_file = f"intrusion_results_{device_type.lower().replace(' ', '_')}.csv"
-        output_data.to_csv(output_file, index=False)
-
-        return output_data, output_file
-
+        elif device == "Weather":
+            log_data['temperature'] = pd.to_numeric(log_data['temperature'], errors='coerce')
+            log_data['humidity'] = pd.to_numeric(log_data['humidity'], errors='coerce')
+        elif device == "Thermostat":
+            log_data['temp_set'] = pd.to_numeric(log_data['temp_set'], errors='coerce')
+            log_data['temp_actual'] = pd.to_numeric(log_data['temp_actual'], errors='coerce')
+        elif device == "Fridge":
+            log_data['temp_inside'] = pd.to_numeric(log_data['temp_inside'], errors='coerce')
+            log_data['door_open'] = log_data['door_open'].astype(str).str.strip().replace({'closed': 0, 'open': 1})
+
+        # Prepare feature values for prediction
+        feature_values = log_data[required_features].astype(float).values
+        predictions = model.predict(feature_values)
     except Exception as e:
-        error_df = pd.DataFrame({"Error": [f"Error processing file: {str(e)}"]})
-        return error_df, None
+        return f"Error during prediction for {device}: {str(e)}", None, None
 
-# Create Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# IoT Intrusion Detection System")
-    gr.Markdown("Upload a CSV file and select the device type to detect intrusions.")
+    # Map predictions to attack types
+    log_data['Prediction'] = [class_labels.get(pred, 'Unknown Attack') for pred in predictions]
 
-    with gr.Row():
-        file_input = gr.File(label="Upload CSV File")
-        device_type = gr.Dropdown(choices=list(device_features.keys()), label="Device Type", value="Fridge")
-    
-    submit_button = gr.Button("Detect Intrusions")
-    
-    output_table = gr.Dataframe(label="Detection Results")
-    output_file = gr.File(label="Download Results CSV")
+    # Format date for output
+    log_data['date'] = log_data['date'].dt.strftime('%Y-%m-%d')
+
+    # Select final output columns
+    output_df = log_data[['date', 'time', 'Prediction']]
+
+    # Save the output to a CSV file for download
+    output_file = f"intrusion_results_{device.lower().replace(' ', '_')}.csv"
+    output_df.to_csv(output_file, index=False)
 
-    submit_button.click(
-        fn=detect_intrusion,
-        inputs=[file_input, device_type],
-        outputs=[output_table, output_file]
+    return None, output_df, output_file
+
+# Create Gradio interface
+def gradio_interface(device, file):
+    error, df, output_file = detect_intrusion(device, file)
+    if error:
+        return error, None, None
+    return df, df, output_file
+
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Dropdown(choices=list(device_models.keys()), label="Select IoT Device", value="Garage Door"),
+        gr.File(label="Upload Log File (CSV format)")
+    ],
+    outputs=[
+        gr.Textbox(label="Status/Error Message", visible=False),
+        gr.Dataframe(label="Intrusion Detection Results"),
+        gr.File(label="Download Predictions CSV")
+    ],
+    title="IoT Intrusion Detection System",
+    description=(
+        """
+        Select an IoT device and upload a CSV log file with the appropriate features for that device.
+        Example features per device:
+        - Garage Door: date,time,door_state,sphone_signal,label (e.g., 26-04-19,13:59:20,1,-85,normal)
+        - GPS Tracker: date,time,latitude,longitude,label
+        - Weather: date,time,temperature,humidity,label
+        - Thermostat: date,time,temp_set,temp_actual,label
+        - Fridge: date,time,temp_inside,door_open,label
+        """
     )
+)
 
-# Launch the interface
-demo.launch()
+iface.launch()