Update app.py

app.py

@@ -1,104 +1,91 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-import tensorflow as tf
-from sklearn.preprocessing import MinMaxScaler
-import plotly.express as px
-import os
-from groq import Groq
+import matplotlib.pyplot as plt
+from pyod.models.iforest import IForest
+from pyod.models.lof import LOF
 
-# Initialize session state
-if 'model' not in st.session_state:
-    st.session_state.model = None
-if 'threshold' not in st.session_state:
-    st.session_state.threshold = None
+def main():
+    st.title("AI-Based Network Anomaly Detection (Predictive Maintenance)")
+    st.markdown(
+        """
+        This application uses AI to detect unusual behavior in a network before it leads to failure.
+        By leveraging open source models and PyOD, it predicts potential issues, enabling proactive maintenance.
+        """
+    )
 
-# Autoencoder model definition
-def build_autoencoder(input_dim):
-    model = tf.keras.Sequential([
-        tf.keras.layers.Dense(64, activation='relu', input_shape=(input_dim,)),
-        tf.keras.layers.Dense(32, activation='relu'),
-        tf.keras.layers.Dense(64, activation='relu'),
-        tf.keras.layers.Dense(input_dim)
-    ])
-    model.compile(optimizer='adam', loss='mse')
-    return model
+    # Sidebar settings for model and parameters
+    st.sidebar.header("Settings")
+    model_choice = st.sidebar.selectbox("Select Anomaly Detection Model", ("Isolation Forest", "Local Outlier Factor"))
+    contamination = st.sidebar.slider("Contamination (Expected anomaly ratio)", 0.0, 0.5, 0.1)
 
-# Sidebar controls
-st.sidebar.title("Configuration")
-fine_tune = st.sidebar.button("Fine-tune Model")
-groq_api_key = st.sidebar.text_input("Groq API Key (optional)", type="password")
+    uploaded_file = st.file_uploader("Upload CSV file with network data", type=["csv"])
 
-# Main interface
-st.title("🛰️ AI Network Anomaly Detector")
-st.write("Upload your network data (CSV) to detect anomalies")
+    if uploaded_file is not None:
+        data = pd.read_csv(uploaded_file)
+        st.write("### Data Preview")
+        st.dataframe(data.head())
+    else:
+        st.info("No file uploaded. Generating synthetic network data for demonstration.")
+        # Generate synthetic data with features like traffic, latency, and packet_loss
+        np.random.seed(42)
+        n_samples = 300
+        traffic = np.random.normal(100, 10, n_samples)
+        latency = np.random.normal(50, 5, n_samples)
+        packet_loss = np.random.normal(0.5, 0.1, n_samples)
+        # Introduce anomalies by modifying a subset of data points
+        anomaly_indices = np.random.choice(n_samples, size=20, replace=False)
+        traffic[anomaly_indices] *= 1.5
+        latency[anomaly_indices] *= 2
+        packet_loss[anomaly_indices] *= 5
+        
+        data = pd.DataFrame({
+            "traffic": traffic,
+            "latency": latency,
+            "packet_loss": packet_loss
+        })
+        st.write("### Synthetic Data")
+        st.dataframe(data.head())
 
-# File uploader
-uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
+    # Use only numeric features for anomaly detection
+    features = data.select_dtypes(include=[np.number]).columns.tolist()
+    if not features:
+        st.error("No numeric columns found in the data for anomaly detection.")
+        return
 
-# Load or generate sample data
-if uploaded_file is not None:
-    data = pd.read_csv(uploaded_file)
-else:
-    st.info("Using sample data. Upload a file to use your own dataset.")
-    data = pd.read_csv("sample_wifi_data.csv")  # You should provide this sample file
+    X = data[features].values
 
-# Preprocessing
-features = ['device_count', 'connection_attempts', 'packet_loss', 'latency']
-scaler = MinMaxScaler()
-data_scaled = scaler.fit_transform(data[features])
+    # Initialize the selected model from PyOD
+    if model_choice == "Isolation Forest":
+        model = IForest(contamination=contamination)
+    elif model_choice == "Local Outlier Factor":
+        model = LOF(contamination=contamination)
 
-# Model training/fine-tuning
-if fine_tune or st.session_state.model is None:
-    with st.spinner("Training model..."):
-        autoencoder = build_autoencoder(data_scaled.shape[1])
-        autoencoder.fit(data_scaled, data_scaled, 
-                       epochs=100, 
-                       batch_size=32,
-                       verbose=0,
-                       validation_split=0.1)
-        st.session_state.model = autoencoder
-        
-        # Calculate threshold
-        reconstructions = autoencoder.predict(data_scaled)
-        mse = np.mean(np.power(data_scaled - reconstructions, 2), axis=1)
-        st.session_state.threshold = np.percentile(mse, 95)
+    # Fit the model and predict anomalies (0: normal, 1: anomaly)
+    model.fit(X)
+    predictions = model.labels_
+    data["anomaly"] = predictions
 
-# Anomaly detection
-if st.session_state.model and st.button("Detect Anomalies"):
-    reconstructions = st.session_state.model.predict(data_scaled)
-    mse = np.mean(np.power(data_scaled - reconstructions, 2), axis=1)
-    anomalies = mse > st.session_state.threshold
-    
-    # Visualization
-    fig = px.line(data, x=data.index, y='connection_attempts', 
-                 title='Network Traffic with Anomalies')
-    fig.add_scatter(x=data[anomalies].index, y=data[anomalies]['connection_attempts'], 
-                   mode='markers', name='Anomalies')
-    st.plotly_chart(fig)
-    
-    # Generate alert with Groq/Llama3
-    if groq_api_key:
-        try:
-            client = Groq(api_key=groq_api_key)
-            response = client.chat.completions.create(
-                model="llama3-70b-8192",
-                messages=[{
-                    "role": "user",
-                    "content": f"Generate a network security alert for {sum(anomalies)} anomalies detected. Max connection attempts: {data['connection_attempts'].max()}"
-                }]
-            )
-            st.warning(response.choices[0].message.content)
-        except Exception as e:
-            st.error(f"Groq API Error: {str(e)}")
-    else:
-        st.warning(f"Detected {sum(anomalies)} anomalies! Consider adding Groq API key for detailed analysis.")
+    st.subheader("Anomaly Detection Results")
+    st.write(data.head())
+    n_anomalies = np.sum(predictions)
+    st.write(f"Detected **{n_anomalies}** anomalies out of **{len(data)}** data points.")
+
+    # Visualization (if at least 2 numeric features are available)
+    if len(features) >= 2:
+        st.subheader("Visualization")
+        fig, ax = plt.subplots()
+        # Plot using the first two numeric features
+        x_feature = features[0]
+        y_feature = features[1]
+        normal_data = data[data["anomaly"] == 0]
+        anomaly_data = data[data["anomaly"] == 1]
+        ax.scatter(normal_data[x_feature], normal_data[y_feature], label="Normal", color="blue", alpha=0.5)
+        ax.scatter(anomaly_data[x_feature], anomaly_data[y_feature], label="Anomaly", color="red", marker="x")
+        ax.set_xlabel(x_feature)
+        ax.set_ylabel(y_feature)
+        ax.legend()
+        st.pyplot(fig)
 
-# Download button for results
-if st.session_state.threshold:
-    st.download_button(
-        label="Download Anomaly Report",
-        data=data[anomalies].to_csv().encode('utf-8'),
-        file_name='anomalies_report.csv',
-        mime='text/csv'
-    )
+if __name__ == "__main__":
+    main()