132 lines
4.2 KiB
Python
132 lines
4.2 KiB
Python
from flask import Flask, request
|
|
import threading
|
|
import numpy as np
|
|
from sklearn.preprocessing import MinMaxScaler
|
|
import tensorflow as tf
|
|
from time import time_ns
|
|
import pickle
|
|
import pandas as pd
|
|
import requests
|
|
import sys
|
|
|
|
# Part to be hardcoded for now, expected to be "ip:port"
|
|
destination = sys.argv[1]
|
|
|
|
app = Flask(__name__)
|
|
|
|
@app.route('/accept_data', methods=['POST'])
|
|
def accept_data():
|
|
|
|
data = request.data
|
|
data = data.decode("utf-8")
|
|
formatted_lines = []
|
|
for line in data.strip().split("\n"):
|
|
elements = line.split(",")
|
|
formatted_line = f"{elements[0]}, {elements[1]}, {elements[2].split()[0]}"
|
|
formatted_lines.append(formatted_line)
|
|
new_data = "\n".join(formatted_lines)
|
|
new_data = pd.DataFrame(
|
|
[line.split(",") for line in new_data.strip().split("\n")],
|
|
columns=["lat", "long", "rtt"],
|
|
)
|
|
new_data["lat"] = new_data["lat"].astype(float)
|
|
new_data["long"] = new_data["long"].astype(float)
|
|
new_data["rtt"] = new_data["rtt"].astype(int)
|
|
global df_final
|
|
df_final = new_data
|
|
dataset_received.set()
|
|
return "Received new datapoints from the network monitoring tool", 200
|
|
|
|
|
|
|
|
def run_flask():
|
|
if __name__ == '__main__':
|
|
app.run(host='0.0.0.0', port=5000)
|
|
|
|
def scale(data, min_val, max_val):
|
|
# lat_min_val = 0
|
|
# lat_max_val = 50
|
|
|
|
# lon_min_val = 0
|
|
# lon_max_val = 10
|
|
|
|
# rtt_min_val = 0
|
|
# rtt_max_val = 1000
|
|
|
|
range_max = 1
|
|
range_min = -1
|
|
|
|
return ((data - min_val) / (max_val - min_val)) * (range_max - range_min) + range_min
|
|
|
|
def reverse_scale(data, min_val, max_val):
|
|
range_min = -1
|
|
range_max = 1
|
|
return ((data - range_min) / (range_max - range_min)) * (max_val - min_val) + min_val
|
|
|
|
def main():
|
|
flask_thread = threading.Thread(target=run_flask)
|
|
flask_thread.setDaemon(True)
|
|
flask_thread.start()
|
|
pd.set_option('mode.chained_assignment', None)
|
|
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
|
|
best_model = tf.keras.models.load_model("trained_rtt.h5", compile=False)
|
|
|
|
global q_alpha, n_future, n_past, dataset_received
|
|
dataset_received = threading.Event()
|
|
q_alpha = 0.95
|
|
n_features = 3
|
|
n_future= 5
|
|
n_past = 100
|
|
|
|
while True:
|
|
dataset_received.wait()
|
|
uc6_06_start = time_ns()
|
|
|
|
dataset_100 = df_final[0:100]
|
|
# dataset_compare_5 = df_final[100:105, 2]
|
|
scalers={}
|
|
|
|
dataset_100.loc[:,"lat"] = scale(dataset_100["lat"],0,50)
|
|
dataset_100.loc[:,"long"] = scale(dataset_100["long"],0,10)
|
|
dataset_100.loc[:,"rtt"] = scale(dataset_100["rtt"],0,1000)
|
|
|
|
# Scaling train data
|
|
for i in dataset_100.columns:
|
|
scaler = MinMaxScaler(feature_range=(-1,1))
|
|
s_s = scaler.fit_transform(dataset_100[i].values.reshape(-1,1))
|
|
s_s=np.reshape(s_s,len(s_s))
|
|
scalers['scaler_'+ i] = scaler
|
|
dataset_100[i]=s_s.copy()
|
|
|
|
|
|
X_test = np.array(dataset_100)
|
|
X_test = X_test.reshape((1, X_test.shape[0], n_features))
|
|
|
|
pred = best_model.predict(X_test)
|
|
pred = reverse_scale(pred,0,1000)
|
|
pred = np.ceil(pred)
|
|
|
|
dataset_compare_5 = df_final.iloc[100:105, 2]
|
|
# df_final['column'] = df_final['column'].astype(str)
|
|
# print(df_final)
|
|
# dataset_compare_5 = df_final["column"].iloc[100:106].str().split(',')[2].astype(float)
|
|
numpy_actual_values = (np.array(dataset_compare_5)/100000).astype(int)
|
|
# errors = np.sum(pred < numpy_actual_values)
|
|
|
|
uc6_06_end = time_ns()
|
|
kpi_uc6_06 = (uc6_06_end-uc6_06_start)/1000000000 # Time required by the PQoS to provide a response in sec (Target <0.2)
|
|
|
|
|
|
try:
|
|
response = requests.post(f"http://{destination}/upload_predictions", json={f"Predicitons": np.array2string(pred), "Response time": kpi_uc6_06})
|
|
except requests.exceptions.RequestException as e:
|
|
print(f"Error while sending the prediction results: {e}")
|
|
# Time required by the PQoS to provide a response in sec (Target <0.2)
|
|
#print(f"Predictions: \n{pred}")
|
|
#print (f"Time required to process the request: {kpi_uc6_06}s (Target <0.2s)\n\n")
|
|
dataset_received.clear()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|