import argparse

import pandas as pd

import numpy as np

np.random.seed(2500)

import tensorflow as tf

from keras.utils import np_utils

from keras.models import Sequential

from keras.models import load_model

from keras.layers import Input, Dropout, Flatten, Dense

from keras.layers import Conv1D, MaxPooling1D

from keras.callbacks import ModelCheckpoint, TensorBoard

from keras import optimizers

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import LabelEncoder

from sklearn.metrics import confusion_matrix

from sklearn.metrics import classification_report, f1_score

from sklearn.metrics import precision_score, recall_score

import matplotlib

matplotlib.use('Agg')

import matplotlib.pyplot as plt

import seaborn as sn

from laplotter import LossAccPlotter

from data_frequency import DataFrequency

import plotly.plotly as py

import plotly.graph_objs as go

def load_dataset(data_file):

return x,y

def create_train_test(x, y):

return x_train, x_test, y_train, y_test

def transform_data(x_train, x_test, y_train, y_test):

return x_train, x_test, y_train, y_test, class_labels, nb_classes

def build_model(nb_classes, optimizer, show_summary=False):

return model

def run_model(mode, model, optimizer, x_features, y_labels, *class_labels):

print(msg)

def plot_confusion_matrix(y_labels, preds, class_labels, optimizer_name):

return pdf_filename

def plot_class_performance_metric(y_labels, preds, class_labels, optimizer_name):

plt.savefig('metrics/' + optimizer + '-' + 'performance_metric.png', dpi=400),

def plot_label_frequecy(label_frequency_distribution):

label_frequency = sorted(label_frequency_distribution.items())

keys = sorted(label_frequency_distribution.keys())

df_label_freq = pd.DataFrame(label_frequency[7:], index=keys[7:], \

columns=['protocol','frequency'])

df_label_freq.plot.bar(figsize=(20,15), grid=True, fontsize=16, rot=30)

plt.xlabel('Protocol Label', fontsize=20)

plt.ylabel('Frequency (%)', fontsize=20)

plt.yticks(np.arange(0.0, 10.05, 0.5), fontsize=20)

plt.savefig('frequency_data/frequency_plot.png', dpi=600)

def plot_loss_acc_history(fit_history, optimizer_name):

plotter.block()

if __name__ == '__main__':

parser = argparse.ArgumentParser()

parser.add_argument('--run-mode', required=True, type=str, choices=['TRAIN', 'EVAL', 'PRED'],

help='TRAIN : train model, EVAL : evaluate model, PRED : make prediction with model')

parser.add_argument('--data-csv', required=True, type=str, help='Raw data CSV file for input')

parser.add_argument('--optimizer', required=True, type=str, choices=['SGD', 'Adam', 'RMSprop', \

'SGD-Momentum', 'SGD-Nesterov'], help='Name of optimizer to train the deep learning model')

args = parser.parse_args()

# Load data

x, y = load_dataset(args.data_csv)

# Calculate protocol label frequency distribution

data_freq = DataFrequency(y)

label_frequency_distribution = data_freq.calculate_label_distribution()

# Plot bar chart

plot_label_frequecy(label_frequency_distribution)

# Create train and test set

x_train, x_test, y_train, y_test = create_train_test(x, y)

# Transform data

x_train, x_test, y_train, y_test, class_labels, nb_classes = \

transform_data(x_train, x_test, y_train, y_test)

# Get the name of the optimizer

optimizer = args.optimizer

if args.run_mode == 'TRAIN':

# Create model

cnn_model = build_model(nb_classes, optimizer)

# Run model for TRAINING

run_model(args.run_mode, cnn_model, optimizer, x_train, y_train)

else:

try:

# Load mode

cnn_model = load_model('models/trained_model_{}.h5'.format('conv1d-' + optimizer))

except:

raise IOError('Model for the specified optimizer not created yet. Train the model first.')

# Evaluate or make prediction

run_model(args.run_mode, cnn_model, optimizer, x_test, y_test, class_labels)