import numpy as np

import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
data = pd.read_csv('dataset_enrgy.csv',nrows=500,engine='python')
data.head()
data.shape
data.columns
data.info()
non_num_cols = [col for col in data.columns if data[col].dtype == 'O']
non_num_data = data[non_num_cols]
non_num_data
[(col, non_num_data[col].nunique()) for col in non_num_cols]
def summarize_cat(col_name):
sorted_values = sorted(non_num_data[col_name].value_counts().iteritems(), key =
lambda x:x[1], reverse=True)
remaining_per = 100
for (value, count) in sorted_values:
per = count / len(non_num_data) * 100
if per >= 1:
print(f'{value} : {per:.2f}%')
else :
print(f'Others : {remaining_per:.2f}%')
break
remaining_per = remaining_per - per
for col in non_num_cols:
print(f"Summary of {col} column : ")
summarize_cat(col)
print('\n')
num_cols = list(set(data.columns) - set(non_num_cols))
num_cols
data[num_cols].describe()
[col for col in num_cols if data[col].isnull().any()]
cols_for_hist = [col for col in num_cols if data[col].nunique() <= 50]
cols_for_hist, len(cols_for_hist)
corr = data[num_cols].corr()
ipdata = data.copy()
print("No. of unique values in Timestamp column :",ipdata['Timestamp'].nunique())
print("No. of unique values in FlowID column :",ipdata['Flow.ID'].nunique())
ipdata.drop(['Timestamp', 'Flow.ID'], axis = 1, inplace = True)
single_unique_cols = [col for col in ipdata.columns if ipdata[col].nunique() == 1]
single_unique_colcorrs
ipdata.drop(single_unique_cols, axis = 1, inplace = True)
ip_add_cols = ['Source.IP', 'Source.Port', 'Destination.IP', 'Destination.Port']
ipdata[ip_add_cols]
ipdata.drop(ip_add_cols, axis = 1, inplace = True)
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder().fit(ipdata['ProtocolName'])
ipdata['ProtocolName'] = encoder.fit_transform(ipdata['ProtocolName'])
ipdata['ProtocolName']
ipdata.head(10)
ipdata.shape
data.dropna(inplace = True)
data.drop(columns =["Label"], inplace = True)
df2 = data
df2.drop(columns =["Source.IP", "Source.Port", "Destination.IP",
"Destination.Port"], inplace = True) #better way is to replace it with country
using some lib like geo2ip but I am lazy
import pandas as pd
import numpy as np
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
from sklearn.preprocessing import LabelEncoder
lb_make = LabelEncoder()
df2["labels"] = lb_make.fit_transform(df2["ProtocolName"])
df2[["ProtocolName", "labels"]].head(11)
from sklearn.model_selection import train_test_split

y = df2.iloc[:,-1]
from lib.utils import *
X,y=scaler_transform(df2)
ac=[]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4,

import random
from sklearn.linear_model import Ridge
model = Ridge(alpha=1.0)

def objective_function(x):
return x**2
class Atomic:
def __init__(self):
self.position = random.uniform(-5, 5)
self.velocity = random.uniform(-1, 1)
self.best_position = self.position
self.best_score = float('inf')
def calculate_pdr(self,pred, original,sample_weight):
if original == 0:
return 0.0
else:
return pred / original
def calculate_throughput(self,data_size_bits, time_seconds,s):
return data_size_bits / time_seconds
def transmission_delay(self,best_fit,s):
for data_chunk in best_fit:
thread = threading.Thread(target=send_data, args=(data_chunk,))
thread.start()
threads.append(thread)
return thread
def calculate_network_lifespan(self,initial_lifespan, yearly_degradation_rate,
obsolescence_time,s):
remaining_lifespan = initial_lifespan
for year in range(1, initial_lifespan + 1):
remaining_lifespan -= 1
remaining_lifespan -= yearly_degradation_rate * initial_lifespan / 100
if year >= obsolescence_time:
remaining_lifespan = 0
break
return max(0, remaining_lifespan)
def atomic_optimization(self,num_particles, num_iterations):
particles = [Atomic() for _ in range(num_particles)]
global_best_position = None
 global_best_score = float('inf')
for _ in range(num_iterations):
for particle in particles:
score = objective_function(particle.position)
if score < particle.best_score:
particle.best_score = score
particle.best_position = particle.position
if score < global_best_score:
global_best_score = score
global_best_position = particle.position
inertia_weight = 0.5
cognitive_weight = 0.5
social_weight = 0.5
particle.velocity = (inertia_weight * particle.velocity +
cognitive_weight * random.random() *
(particle.best_position - particle.position) +
social_weight * random.random() *
(global_best_position - particle.position))
particle.position += particle.velocity
return global_best_position, global_best_score
def train(self,X_train,y_train,X_test):
model.fit(X_train,y_train)
y_pred=model.predict(X_test)
return y_pred
num_particles = 30
num_iterations = 100
p=Atomic()
best_position, best_score =p.atomic_optimization(num_particles, num_iterations)
y_pred=p.train(X_train,y_train,X_test)
print("Best Position:", best_position)
print("Best Score:", best_score)
ac.append(accuracy_score(y_pred,y_train,sample_weight=0.2)*100)
import random
import math
def objective_function(x):
return x**2
def calculate_throughput(data_size_bits, time_seconds,s):
return data_size_bits / time_seconds
def HRBO(num_particles, num_iterations, search_space_lower_bound,
search_space_upper_bound):
particles = [random.uniform(search_space_lower_bound, search_space_upper_bound)
for _ in range(num_particles)] # Initialize particles
for _ in range(num_iterations):
fitness_values = [objective_function(particle) for particle in particles]
best_particle_index = fitness_values.index(min(fitness_values))
best_particle = particles[best_particle_index]
best_fitness = fitness_values[best_particle_index]
for i in range(num_particles):
if i != best_particle_index:
distance = abs(particles[i] - best_particle)
gravitational_force = G * ((fitness_values[i] *
fitness_values[best_particle_index]) / (distance + epsilon))
random_force = random.uniform(0, 1) * (particles[i] -
best_particle)
particles[i] -= gravitational_force * random_force
return best_particle, best_fitness
def calculate_pdr(pred, original,sample_weight):
if original == 0:
return 0.0
 else:
return pred / original
def transmission_delay(best_fit,s):
for data_chunk in best_fit:
thread = threading.Thread(target=send_data, args=(data_chunk,))
thread.start()
threads.append(thread)
return threads
def calculate_network_lifespan(initial_lifespan, yearly_degradation_rate,
obsolescence_time,s):
remaining_lifespan = initial_lifespan
for year in range(1, initial_lifespan + 1):
remaining_lifespan -= 1
remaining_lifespan -= yearly_degradation_rate * initial_lifespan / 100
if year >= obsolescence_time:
remaining_lifespan = 0
break
return max(0, remaining_lifespan)
def train(X_train,y_train,X_test):
model.fit(X_train,y_train)
y_pred=model.predict(X_test)
return y_pred
G = 6.67430e-11
epsilon = 1e-20
num_particles = 30
num_iterations = 100
search_space_lower_bound = -10
search_space_upper_bound = 10
best_solution, best_fitness = HRBO(num_particles, num_iterations,
search_space_lower_bound, search_space_upper_bound)
y_pred=train(X_train,y_train,X_test)
print("Best Fitness:", best_fitness)
ac.append(accuracy_score(y_pred,y_train)*100)
class Bee:
def objective_function(x):
return x**2
def calculate_throughput(self,data_size_bits, time_seconds,s):
return data_size_bits / time_seconds
def calculate_pdr(pred, original,sample_weight):
if original == 0: return 0.0
else:
return pred / original
def transmission_delay(self,best_fit,s):
for data_chunk in best_fit:
thread = threading.Thread(target=send_data, args=(data_chunk,))
thread.start()
threads.append(thread)
return threads
def calculate_network_lifespan(self,initial_lifespan, yearly_degradation_rate,
obsolescence_time,s):
remaining_lifespan = initial_lifespan
for year in range(1, initial_lifespan + 1):
remaining_lifespan -= 1
remaining_lifespan -= yearly_degradation_rate * initial_lifespan / 100
if year >= obsolescence_time:
remaining_lifespan = 0
break
return max(0, remaining_lifespan)
import matplotlib.pyplot as plt
from lib.utils import *
c=Atomic()
b=Bee()
x = [1, 2, 3, 4, 5,6,7,8,9,10]
y = c.calculate_pdr(y_test,y_pred)
y1= calculate_pdr(y_test,y_pred)
y2=b.calculate_pdr(y_test,y_pred)
plt.plot(x, y, label='LSTM', marker='o')
plt.plot(x, y1, label='CNN', marker='o')
plt.plot(x, y2, label='RNN', marker='o')
plt.xlabel('Time Intervals')
plt.ylabel('Ratio')
plt.title('Packet Delivery')
plt.legend()
plt.grid(True)
plt.show()
import matplotlib.pyplot as plt
from lib.utils import *
c=Atomic()
b=Bee()
x = [1, 2, 3, 4, 5,6,7,8,9,10]
y = c.calculate_throughput(y, 30)
y1= calculate_throughput(y, 30)
y2= b.calculate_throughput(y, 30)
plt.plot(x, y, label='LSTM', marker='o')
plt.plot(x, y1, label='CNN', marker='o')
plt.plot(x, y2, label='RNN', marker='o')
plt.xlabel('Time Intervals')
plt.ylabel('Throughput')
plt.title('Improved Throughput')
plt.legend()
plt.grid(True)
plt.show()
import matplotlib.pyplot as plt
from lib.utils import *
c=Atomic()
b=Bee()
x = [1, 2, 3, 4, 5,6,7,8,9,10]
y = c.transmission_delay(y_test,y_pred)
y1= transmission_delay(y_test,y_pred)
y2=b.transmission_delay(y_test,y_pred)
plt.plot(x, y, label='LSTM', marker='o')
plt.plot(x, y1, label='CNN', marker='o')
plt.plot(x, y2, label='RNN', marker='o')
plt.xlabel('Time Intervals')
plt.ylabel('Transmission Delay')
plt.title('Transmission Delay')
plt.legend()
plt.grid(True)
plt.show()
import matplotlib.pyplot as plt
from lib.utils import *
c=Atomic()
b=Bee()
x = [1, 2, 3, 4, 5,6,7,8,9,10]
y = c.calculate_network_lifespan(y_test,y_pred,5)
y1= calculate_network_lifespan(y_test,y_pred,5)
y2=b.calculate_network_lifespan(y_test,y_pred,5)
plt.plot(x, y, label='LSTM', marker='o')
plt.plot(x, y1, label='CNN', marker='o')
plt.plot(x, y2, label='RNN', marker='o')
plt.xlabel('Time Intervals')
plt.ylabel('Network Lifespan')
plt.title('Liffespan')
plt.legend()
plt.grid(True)
plt.show()