Gid

# importing pandas
import numpy as np
import pandas as pd
from pandas.core.internals.blocks import F
pip install --upgrade scikit-learn
import numpy as np
import pandas as pd
from datetime import datetime
from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix
#from sklearn.metrics import plot_confusion_matrix
from sklearn import tree
from sklearn.metrics import classification_report
from sklearn.metrics import accuracy_score
from sklearn import neighbors, datasets
#from sklearn.inspection import DecisionBoundaryDisplay
import sklearn.metrics
from sklearn import metrics
from sklearn.metrics import f1_score
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt
from sklearn import preprocessing

label_encoder = preprocessing.LabelEncoder()
#AttackFree= [0:2369397]
#DoS= [0:656578]
#Fuzzy= )[0:591989]
#Impersonation= [0:995471]
AttackFree=
pd.read_csv('/content/drive/MyDrive/CAN_VehicleAttack_ML/CAN_vehicleAttack_
dataset1/CAN_Attack_dataset1-15F/CAN_Attack_dataset1_15
F/github_folder/extracted feature/CAN_attack_dataset1/Attack_free new.csv')
[0:236939]
DoS=
F/github_folder/extracted feature/CAN_attack_dataset1/DoS_Attack_new.csv')
[0:65657]
Fuzzy=
F/github_folder/extracted
feature/CAN_attack_dataset1/Fuzzy_Attack_New.csv')[0:59198]
Impersonation=
dataset1/CAN_Attack_dataset1-1
#Class1: Attack-Free
AttackFree.iloc[:, 1]= label_encoder.fit_transform(AttackFree.iloc[:, 1])

#AttackFree.iloc[:, 16]= label_encoder.fit_transform(AttackFree.iloc[:,
16])
#Class2: DoS
DoS.iloc[:, 1]= label_encoder.fit_transform(DoS.iloc[:, 1])

#DoS.iloc[:, 16]= label_encoder.fit_transform(DoS.iloc[:, 16])
#Class3: Fuzzy
Fuzzy.iloc[:, 1]= label_encoder.fit_transform(Fuzzy.iloc[:, 1])

#Fuzzy.iloc[:, 16]= label_encoder.fit_transform(Fuzzy.iloc[:, 16])
#Class4:Impersonation
Impersonation.iloc[:, 0]= label_encoder.fit_transform(Impersonation.iloc[:,

0])
1])
2])
3])
4])
5])
6])
7])
8])
9])
Impersonation.iloc[:, 10]=
label_encoder.fit_transform(Impersonation.iloc[:, 10])
#Impersonation.iloc[:, 16]=
label1 = []
for i in range(len(AttackFree)):
label1.append(1)
label2 = []
for i in range(len(DoS)):
label2.append(2)
label3 = []
for i in range(len(Fuzzy)):
label3.append(3)
label4 = []
for i in range(len(Impersonation)):
label4.append(4)
Dataset = np.concatenate((AttackFree, DoS, Fuzzy, Impersonation))

label = np.concatenate((label1, label2, label3, label4))
# Splitting the dataset into the Training set and Test set
X_Train, X_Test, Y_Train, Y_Test = train_test_split(Dataset, label,
test_size = 0.25, random_state = 0)
# Feature Scaling
sc_X = StandardScaler()
X_Train = sc_X.fit_transform(X_Train)
X_Test = sc_X.transform(X_Test)
# do your work here
# SVM Classifier
#Fitting the classifier into the Training set:SVM Training

#kernel = precomputed, rbf,linear,polynomial, poly
classifier_svm = SVC(kernel = 'rbf', gamma='scale',random_state = 0,
max_iter=-1, tol=0.0001,degree=3, verbose=False, class_weight=None,
C=100.0)
start_time_1 = datetime.now()
classifier_svm.fit(X_Train, Y_Train)
end_time_1 = datetime.now()
print('Training Duration: {}'.format(end_time_1 - start_time_1))
# SVM Testing
# Predicting the test set results
Y_Pred_svm = classifier_svm.predict(X_Test)
print('Testing Duration: {}'.format(end_time_2 - start_time_2))
# Making the Confusion Matrix :SVM

cm_svm = confusion_matrix(Y_Test, Y_Pred_svm)
cm_svm
import seaborn as sn
font = {'family' : 'normal',

'size' : 14}
plt.rc('font', **font)
label = ['AttackFree', 'DoS', 'Fuzzy', 'Impersonation']
df_cm_svm = pd.DataFrame(cm_svm, index = [i for i in label],

columns = [i for i in label])
plt.figure(figsize = (7,5))
sn.heatmap(df_cm_svm, annot=True, fmt='.0f', cmap='Blues')
plt.ylabel('True Class')
plt.xlabel('Predicted Class')
plt.show()
#evaluation for SVM
print("Accuracy:",metrics.accuracy_score(Y_Test, Y_Pred_svm))
print("Precision:",metrics.precision_score(Y_Test, Y_Pred_svm,
average='micro'))
print("Recall:",metrics.recall_score(Y_Test, Y_Test, average='micro'))
print("F1_Score:",metrics.f1_score(Y_Test, Y_Test, average='micro'))
print("Cohen_Kappa_Score:",sklearn.metrics.cohen_kappa_score(Y_Test,
Y_Pred_svm, labels=None, weights=None, sample_weight=None))
#print("MSE:",metrics.mean_squared_error(Y_Test,Y_Pred_svm))
# Individual Clasification- SVM
print(classification_report(Y_Test, Y_Pred_svm))
#DT classifier
# Fitting the classifier into the Training set:Decision Tree (DT) Training
classifier_dt = tree.DecisionTreeClassifier(criterion='gini',
splitter='best',random_state=0, max_depth=None)
classifier_dt.fit(X_Train, Y_Train)
#DT Testing
Y_Pred_dt = classifier_dt.predict(X_Test)
Y_Pred_dt
# Making the Confusion Matrix :DT

cm_dt = confusion_matrix(Y_Test, Y_Pred_dt)
cm_dt

'size' : 14}
df_cm_dt = pd.DataFrame(cm_dt, index = [i for i in label],

sn.heatmap(df_cm_dt, annot=True, fmt='.0f', cmap='Blues')
plt.show()
#evaluation for DT
print("Accuracy:",metrics.accuracy_score(Y_Test, Y_Pred_dt))
print("Precision:",metrics.precision_score(Y_Test, Y_Pred_dt,
average='micro'))
Y_Pred_dt, labels=None, weights=None, sample_weight=None))
# Individual Clasification- DT
print(classification_report(Y_Test, Y_Pred_dt))
# KNN classifier
#Fitting the classifier into the Training set:K-nearest Neighbour Training
#(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2,
metric='minkowski', metric_params=None, n_jobs=None)
#metric (Manhattan Distance, minkowski distance, Euclidean Distance, Cosine
Distance, Jaccard Distance, Hamming Distance)
#n_neighbors = 20
classifier_knn = neighbors.KNeighborsClassifier(n_neighbors=5,
weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski',
metric_params=None, n_jobs=None)
classifier_knn.fit(X_Train, Y_Train)
# KNN Testing
Y_Pred_knn = classifier_knn.predict(X_Test)
# Making the Confusion Matrix :knn

cm_knn = confusion_matrix(Y_Test, Y_Pred_knn)
cm_knn

'size' : 14}
df_cm_knn = pd.DataFrame(cm_knn, index = [i for i in label],

sn.heatmap(df_cm_knn, annot=True, fmt='.0f', cmap='Blues')
plt.show()
#evaluation for KNN

print("Accuracy:",metrics.accuracy_score(Y_Test, Y_Pred_knn))
print("Precision:",metrics.precision_score(Y_Test, Y_Pred_knn,
average='micro'))
Y_Pred_knn, labels=None, weights=None, sample_weight=None))
# Individual Clasification- KNN
print(classification_report(Y_Test, Y_Pred_knn))

Gid

Uploaded by

Copyright:

Available Formats

You might also like

Gid

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Gid

Uploaded by

Copyright:

Available Formats

# importing pandas

pip install --upgrade scikit-learn

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt

from sklearn import preprocessing

AttackFree.iloc[:, 1]= label_encoder.fit_transform(AttackFree.iloc[:, 1])

DoS.iloc[:, 1]= label_encoder.fit_transform(DoS.iloc[:, 1])

Fuzzy.iloc[:, 1]= label_encoder.fit_transform(Fuzzy.iloc[:, 1])

Impersonation.iloc[:, 0]= label_encoder.fit_transform(Impersonation.iloc[:,

Dataset = np.concatenate((AttackFree, DoS, Fuzzy, Impersonation))

#Fitting the classifier into the Training set:SVM Training

# Making the Confusion Matrix :SVM

font = {'family' : 'normal',

label = ['AttackFree', 'DoS', 'Fuzzy', 'Impersonation']

df_cm_svm = pd.DataFrame(cm_svm, index = [i for i in label],

#evaluation for SVM

# Individual Clasification- SVM

# Making the Confusion Matrix :DT

font = {'family' : 'normal',

label = ['AttackFree', 'DoS', 'Fuzzy', 'Impersonation']

df_cm_dt = pd.DataFrame(cm_dt, index = [i for i in label],

# Making the Confusion Matrix :knn

font = {'family' : 'normal',

label = ['AttackFree', 'DoS', 'Fuzzy', 'Impersonation']

df_cm_knn = pd.DataFrame(cm_knn, index = [i for i in label],

#evaluation for KNN

# Individual Clasification- KNN

You might also like