Update app.py

app.py

@@ -5,11 +5,16 @@ import plotly.express as px
 from datetime import datetime, timedelta
 from prophet import Prophet
 import networkx as nx
+from ryu.base import app_manager
+from ryu.controller import ofp_event
+from ryu.controller.handler import MAIN_DISPATCHER, set_ev_cls
+from ryu.ofproto import ofproto_v1_3
+from ryu.lib.packet import packet, ethernet
 
 # 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)]
+    schools = [f"School_{i}" for i in range(1, 11)]  # 10 Schools
+    time_range = [datetime.now() - timedelta(hours=i) for i in range(24)]  # Past 24 hours
     
     data = []
     for school in schools:
@@ -24,14 +29,19 @@ def generate_data():
 # Load or generate data
 df = generate_data()
 
+def detect_anomalies(df):
+    df['Z_Score'] = (df['Bandwidth_Usage'] - df['Bandwidth_Usage'].mean()) / df['Bandwidth_Usage'].std()
+    anomalies = df[df['Z_Score'].abs() > 2]  # Mark as anomaly if Z-score > 2
+    return anomalies
+
 def train_prophet(df):
-    df["Timestamp"] = pd.to_datetime(df["Timestamp"])
+    df["Timestamp"] = pd.to_datetime(df["Timestamp"])  # Convert to datetime format
     df_numeric = df[["Timestamp", "Bandwidth_Usage"]]  # Select only numeric columns
-    df_prophet = df_numeric.groupby("Timestamp").mean().reset_index()
-    df_prophet.columns = ["ds", "y"]
+    df_prophet = df_numeric.groupby("Timestamp").mean().reset_index()  # Average bandwidth per timestamp
+    df_prophet.columns = ["ds", "y"]  # Prophet model requires columns: ds (date) and y (value)
     
     model = Prophet()
-    model.fit(df_prophet)
+    model.fit(df_prophet)  # Train Prophet on past data
     
     future = model.make_future_dataframe(periods=5, freq="H")  # Predict next 5 hours
     forecast = model.predict(future)
@@ -39,17 +49,46 @@ def train_prophet(df):
     return forecast
 
 def allocate_bandwidth(demand_predictions, total_bandwidth=500):
-    total_demand = sum(demand_predictions.values())
+    total_demand = sum(demand_predictions.values())  # Calculate total demand
     allocation = {school: (demand / total_demand) * total_bandwidth for school, demand in demand_predictions.items()}
     return allocation
 
 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
 
+# SDN Controller Class
+class SimpleSwitch13(app_manager.RyuApp):
+    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
+
+    def __init__(self, *args, **kwargs):
+        super(SimpleSwitch13, self).__init__(*args, **kwargs)
+        self.mac_to_port = {}
+
+    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
+    def packet_in_handler(self, ev):
+        msg = ev.msg
+        datapath = msg.datapath
+        ofproto = datapath.ofproto
+        parser = datapath.ofproto_parser
+        in_port = msg.match['in_port']
+
+        pkt = packet.Packet(msg.data)
+        eth = pkt.get_protocol(ethernet.ethernet)
+        dst = eth.dst
+        src = eth.src
+
+        if dst in self.mac_to_port:
+            out_port = self.mac_to_port[dst]
+        else:
+            out_port = ofproto.OFPP_FLOOD
+
+        actions = [parser.OFPActionOutput(out_port)]
+        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions, data=msg.data)
+        datapath.send_msg(out)
+
 # Create a simple network topology
 graph = nx.Graph()
 
@@ -61,17 +100,24 @@ graph.add_edges_from([
 
 # 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)
+demand_predictions = {f"School_{i}": np.random.randint(20, 100) for i in range(1, 6)}  # Random demand per school
+bandwidth_allocation = allocate_bandwidth(demand_predictions)  # Allocate bandwidth
+network_routes = sdn_load_balancer(graph, demand_predictions)  # Compute SDN-based routes
+anomalies = detect_anomalies(df)  # Detect anomalies
 
 # 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)
 
 st.write("Predicted Bandwidth Allocations:")
-st.json(bandwidth_allocation)
+for school, bandwidth in bandwidth_allocation.items():
+    st.write(f"{school}: {bandwidth:.2f} Mbps")
 
 st.write("SDN-based Load Balancing Routes:")
-st.json(network_routes)
+for school, path in network_routes.items():
+    st.write(f"{school}: {' -> '.join(path)}")
+
+st.write("Detected Anomalies:")
+st.dataframe(anomalies)