Update app.py

app.py

@@ -2,56 +2,75 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import plotly.express as px
+from datetime import datetime, timedelta
 from prophet import Prophet
+import networkx as nx
 
-# Simulated school network traffic data
-st.title("📡 Smart Network Resource Allocation")
-
-# Load or generate synthetic data
-@st.cache_data
-def load_data():
-    schools = [f"School_{i}" for i in range(1, 6)]
-    time_range = pd.date_range(start="2024-02-01", periods=24, freq="H")
+# Generate synthetic data
+def generate_data():
+    schools = [f"School_{i}" for i in range(1, 11)]
+    time_range = [datetime.now() - timedelta(hours=i) for i in range(24)]
+    
     data = []
-
     for school in schools:
         for time in time_range:
-            bandwidth_usage = np.random.randint(1, 100)  # Random usage in Mbps
+            bandwidth_usage = np.random.randint(1, 100)  # Random bandwidth usage in Mbps
             data.append([school, time, bandwidth_usage])
-
+    
     df = pd.DataFrame(data, columns=["School", "Timestamp", "Bandwidth_Usage"])
+    df.to_csv("network_data.csv", index=False)
     return df
 
-df = load_data()
+# Load or generate data
+df = generate_data()
+
+def train_prophet(df):
+    df["Timestamp"] = pd.to_datetime(df["Timestamp"])
+    df_prophet = df.groupby("Timestamp").mean().reset_index()
+    df_prophet.columns = ["ds", "y"]
+    
+    model = Prophet()
+    model.fit(df_prophet)
+    
+    future = model.make_future_dataframe(periods=5, freq="H")  # Predict next 5 hours
+    forecast = model.predict(future)
+    
+    return forecast
 
-# Display data
-st.subheader("📊 Network Traffic Data")
-st.write(df.tail())
+def allocate_bandwidth(demand_predictions, total_bandwidth=500):
+    total_demand = sum(demand_predictions.values())
+    allocation = {school: (demand / total_demand) * total_bandwidth for school, demand in demand_predictions.items()}
+    return allocation
 
-# Prophet Model for Bandwidth Prediction
-st.subheader("📈 Bandwidth Usage Forecasting")
-df_prophet = df.groupby("Timestamp").mean().reset_index()
-df_prophet.columns = ["ds", "y"]
+def sdn_load_balancer(network_graph, demand_predictions):
+    # Simulating a simple SDN-based routing decision
+    shortest_paths = {}
+    for school in demand_predictions.keys():
+        shortest_paths[school] = nx.shortest_path(network_graph, source='Central_Node', target=school)
+    return shortest_paths
 
-model = Prophet()
-model.fit(df_prophet)
-future = model.make_future_dataframe(periods=5, freq="H")
-forecast = model.predict(future)
+# Create a simple network topology
+graph = nx.Graph()
 
-fig = px.line(forecast, x="ds", y="yhat", title="Predicted Bandwidth Demand")
-st.plotly_chart(fig)
+graph.add_edges_from([
+    ('Central_Node', 'School_1'), ('Central_Node', 'School_2'),
+    ('Central_Node', 'School_3'), ('Central_Node', 'School_4'),
+    ('Central_Node', 'School_5')
+])
 
-# Dynamic Bandwidth Allocation
-st.subheader("⚖️ Smart Bandwidth Allocation")
+# Train model and make predictions
+forecast = train_prophet(df)
+demand_predictions = {f"School_{i}": np.random.randint(20, 100) for i in range(1, 6)}
+bandwidth_allocation = allocate_bandwidth(demand_predictions)
+network_routes = sdn_load_balancer(graph, demand_predictions)
 
-def allocate_bandwidth(predictions, total_bandwidth=500):
-    total_demand = sum(predictions.values())
-    allocation = {school: (predictions[school] / total_demand) * total_bandwidth for school in predictions}
-    return allocation
+# Streamlit UI
+st.title("Smart Network Resource Allocation with SDN Load Balancing")
+fig = px.line(df, x="Timestamp", y="Bandwidth_Usage", color="School", title="Bandwidth Usage Over Time")
+st.plotly_chart(fig)
 
-# Simulated allocation
-predictions = {f"School_{i}": np.random.randint(30, 100) for i in range(1, 6)}
-allocations = allocate_bandwidth(predictions)
+st.write("Predicted Bandwidth Allocations:")
+st.json(bandwidth_allocation)
 
-st.write("📌 **Predicted Bandwidth Allocation (Mbps):**")
-st.json(allocations)
+st.write("SDN-based Load Balancing Routes:")
+st.json(network_routes)