1、数据集预处理
1.1 整合数据并剔除脏数据
如上图所示，整个数据集是分开的，想要训练，必须要整合在一起，同时在数据集中存在 Nan 和 Infiniti 脏数据（只有第 15 列和第 16 列存在）需要剔除：
具体代码如下：
import pandas as pd
# 按行合并多个Dataframe数据
def mergeData():
monday = writeData("data\MachineLearningCVE\Monday-WorkingHours.pcap_ISCX.csv")
# 剔除第一行属性特征名称
monday = monday.drop([0])
friday1 = writeData("data\MachineLearningCVE\Friday-WorkingHours-Afternoon-DDos.pcap_ISCX.csv")
friday1 = friday1.drop([0])
friday2 = writeData("data\MachineLearningCVE\Friday-WorkingHours-Afternoon-PortScan.pcap_ISCX.csv")
friday2 = friday2.drop([0])
friday3 = writeData("data\MachineLearningCVE\Friday-WorkingHours-Morning.pcap_ISCX.csv")
friday3 = friday3.drop([0])
thursday1 = writeData("data\MachineLearningCVE\Thursday-WorkingHours-Afternoon-Infilteration.pcap_ISCX.csv")
thursday1 = thursday1.drop([0])
thursday2 = writeData("data\MachineLearningCVE\Thursday-WorkingHours-Morning-WebAttacks.pcap_ISCX.csv")
thursday2 = thursday2.drop([0])
tuesday = writeData("data\MachineLearningCVE\Tuesday-WorkingHours.pcap_ISCX.csv")
tuesday = tuesday.drop([0])
wednesday = writeData("data\MachineLearningCVE\Wednesday-workingHours.pcap_ISCX.csv")
wednesday = wednesday.drop([0])
frame = [monday,friday1,friday2,friday3,thursday1,thursday2,tuesday,wednesday]
# 合并数据
result = pd.concat(frame)
list = clearDirtyData(result)
result = result.drop(list)
return result
# 清除CIC-IDS数据集中的脏数据，第一行特征名称和含有Nan、Infiniti等数据的行数
def clearDirtyData(df):
dropList = df[(df[14]=="Nan")|(df[15]=="Infinity")].index.tolist()
return dropList
raw_data=mergeData()
file = 'data/total.csv'
raw_data.to_csv(file, index=False, header=False)将合并文件保存为 total.csv，省去每次训练都要重复操作的步骤
1.2 分析数据
在 panda 库中，dataframe 类型有一个很好用的函数 value_counts，可以用来统计标签数量，加载 total.csv 得到 raw_data，运行下面代码：
# 得到标签列索引
last_column_index = raw_data.shape[1] - 1
print(raw_data[last_column_index].value_counts())打印结果如下：
由上图可以看到，整个数据集相当不平衡，正常数据非常大，而攻击流量却相当少，可以说整个数据集是相当不平衡的，怎么解决这个问题，下一节来说一说。
1.3 平衡数据集
针对这种情况，一般而言，是要扩充小的攻击数据集，其扩充方法有很多：
从数据源头采集更多数据
复制原有数据并加上随机噪声
重采样
根据当前数据集估计数据分布参数，使用该分布产生更多数据等
上面的方法都不太好整：
数据源头不用想了；
复制数据加上加上随机噪声，需要对于数据本身比较理解，否则容易出现问题；
重采样，因为数据量很少，想要达到平衡必须百倍扩充数据，重采样只适用于扩充量不大的情况（个人见解）
根据分布产生更多数据，因为数据太少了（只有几十个），而且特征太多，估计出来的分布会十分不准确，而由此分布产生的数据则更加不准确了。
由于上述方法不好整，我只好用一个不算方法的方法去做：复制粘贴，将每个数据集扩充到 5000 条以上（其实本质上类似于重采样），具体代码如下：
import pandas as pd
# 根据file读取数据
def writeData(file):
print("Loading raw data...")
raw_data = pd.read_csv(file, header=None,low_memory=False)
return raw_data
# 将大的数据集根据标签特征分为15类，存储到lists集合中
def separateData(raw_data):
# dataframe数据转换为多维数组
lists=raw_data.values.tolist()
temp_lists=[]
# 生成15个空的list集合，用来暂存生成的15种特征集
for i in range(0,15):
temp_lists.append([])
# 得到raw_data的数据标签集合
label_set = lookData(raw_data)
# 将无序的数据标签集合转换为有序的list
label_list = list(label_set)
for i in range(0,len(lists)):
# 得到所属标签的索引号
data_index = label_list.index(lists[i][len(lists[0])-1])
temp_lists[data_index].append(lists[i])
if i%5000==0:
print(i)
saveData(temp_lists,'data/expendData/')
return temp_lists
# 将lists分批保存到file文件路径下
def saveData(lists,file):
label_set = lookData(raw_data)
label_list = list(label_set)
for i in range(0,len(lists)):
save = pd.DataFrame(lists[i])
file1 = file+label_list[i]+'.csv'
save.to_csv(file1,index=False,header=False)
def lookData(raw_data):
# 打印数据集的标签数据数量
last_column_index = raw_data.shape[1] - 1
print(raw_data[last_column_index].value_counts())
# 取出数据集标签部分
labels = raw_data.iloc[:, raw_data.shape[1] - 1:]
# 多维数组转为以为数组
labels = labels.values.ravel()
label_set = set(labels)
return label_set
# lists存储着15类数据集，将数据集数量少的扩充到至少不少于5000条，然后存储起来。
def expendData(lists):
totall_list = []
for i in range(0,len(lists)):
while len(lists[i])<5000:
lists[i].extend(lists[i])
print(i)
totall_list.extend(lists[i])
saveData(lists,'data/expendData/')
save = pd.DataFrame(totall_list)
file = 'data/expendData/totall_extend.csv'
save.to_csv(file, index=False, header=False)
file = 'data/clearData/total.csv'
raw_data = writeData(file)
lists = separateData(raw_data)
expendData(lists)再来看一下数据集的统计情况：
将这个数据集命名为 total_expend.csv，等使用的时候，我们仔细分析一下两个数据集对于模型训练到底有什么区别。
2、使用 sklearn 进行训练和测试
sklearn 分类算法有很多，这里以决策树为例。
2.1 数据处理
直接上代码吧：
import pandas as pd
import numpy as np
from sklearn.metrics import confusion_matrix, zero_one_loss
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn import preprocessing
# 加载数据
raw_data_filename = "data/clearData/total_expend.csv"
print("Loading raw data...")
raw_data = pd.read_csv(raw_data_filename, header=None,low_memory=False)
# 随机抽取比例，当数据集比较大的时候，可以采用这个，可选项
raw_data=raw_data.sample(frac=0.03)
# 查看标签数据情况
last_column_index = raw_data.shape[1] - 1
print("print data labels:")
print(raw_data[last_column_index].value_counts())
# 将非数值型的数据转换为数值型数据
# print("Transforming data...")
raw_data[last_column_index], attacks = pd.factorize(raw_data[last_column_index], sort=True)
# 对原始数据进行切片，分离出特征和标签，第1~78列是特征，第79列是标签
features = raw_data.iloc[:, :raw_data.shape[1] - 1] # pandas中的iloc切片是完全基于位置的索引
labels = raw_data.iloc[:, raw_data.shape[1] - 1:]
# 特征数据标准化，这一步是可选项
features = preprocessing.scale(features)
features = pd.DataFrame(features)
# 将多维的标签转为一维的数组
labels = labels.values.ravel()
# 将数据分为训练集和测试集,并打印维数
df = pd.DataFrame(features)
X_train, X_test, y_train, y_test = train_test_split(df, labels, train_size=0.8, test_size=0.2, stratify=labels)
# print("X_train,y_train:", X_train.shape, y_train.shape)
# print("X_test,y_test:", X_test.shape, y_test.shape)上述大概流程可以分为：
- 加载数据
- 分析数据
- 非数值型数据转换数值数据
- 分离特征和标签
- 数据标准化\归一化\正则化
- 将这个数据集切分为训练集合测试集
2.2 训练和测试
import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, zero_one_loss
# 训练模型
print("Training model...")
clf = DecisionTreeClassifier(criterion='entropy', max_depth=12, min_samples_leaf=1, splitter="best")
trained_model = clf.fit(X_train, y_train)
print("Score:", trained_model.score(X_train, y_train))
# 预测
print("Predicting...")
y_pred = clf.predict(X_test)
print("Computing performance metrics...")
results = confusion_matrix(y_test, y_pred)
error = zero_one_loss(y_test, y_pred)
# 根据混淆矩阵求预测精度
list_diag = np.diag(results)
list_raw_sum = np.sum(results, axis=1)
print("Predict accuracy of the decisionTree: ", np.mean(list_diag) / np.mean(list_raw_sum))在 sklearn 中，训练模型和预测模型几乎是一个模板，想要换算法，只需要将上面的算法行替换即可，也就是：
clf = DecisionTreeClassifier(criterion='entropy', max_depth=12, min_samples_leaf=1, splitter="best")其他都可以不变
来看一下预测结果：
预测准确率为 99.56，算是很高了。
2.3 测试 total.csv 和 total_expend.csv 的区别
上面一节采用的数据集是 total.csv，也就是数据不平衡的数据集，但是从结果来看，其准确率很高，达到了 99.56%，然而，评价一个模型，准确率只是一个指标而已，我们来打印一下其混淆矩阵：
由上图可以看到，存在很多类别被误分的，但是为什么其准确率依然这么高呢？
这是因为数据不平衡，total.csv 数据集中，正常数据（也就是标签为 begin）的数据太多了，占据了几乎 99%的比例，只要它预测正确，那么整个数据集的准确率就会很高，至于其他标签的准确率哪怕再低，也不会有多大影响。
再来看看如果使用 total_expend.csv 数据集，先看准确率：
99.70%的准确率也很高，再看混淆矩阵打印：
可以看到，相比上面的，要好了很多，大部分类别都预测正确了（当然，这个也可能是因为类别标签大都重复造成的。）
绘制混淆矩阵代码：
class PlotConfusionMatrix:
def plot_confusion_matrix(self,labels,cm, title='Confusion Matrix', cmap=plt.cm.binary):
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
xlocations = np.array(range(len(labels)))
plt.xticks(xlocations, labels, rotation=90)
plt.yticks(xlocations, labels)
plt.ylabel('True label')
plt.xlabel('Predicted label')
def prepareWork(self,labels, y_true, y_pred):
tick_marks = np.array(range(len(labels))) + 0.5
cm = confusion_matrix(y_true, y_pred)
np.set_printoptions(precision=2)
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
plt.figure(figsize=(12, 8), dpi=120)
ind_array = np.arange(len(labels))
x, y = np.meshgrid(ind_array, ind_array)
for x_val, y_val in zip(x.flatten(), y.flatten()):
c = cm_normalized[y_val][x_val]
if c > 0.01:
plt.text(x_val, y_val, "%0.2f" % (c,), color='red', fontsize=7, va='center', ha='center')
# offset the tick
plt.gca().set_xticks(tick_marks, minor=True)
plt.gca().set_yticks(tick_marks, minor=True)
plt.gca().xaxis.set_ticks_position('none')
plt.gca().yaxis.set_ticks_position('none')
plt.grid(True, which='minor', linestyle='-')
plt.gcf().subplots_adjust(bottom=0.15)
self.plot_confusion_matrix(labels,cm_normalized, title='Normalized confusion matrix')
# show confusion matrix
# plt.savefig('image/confusion_matrix.png', format='png')
plt.show()
# 绘制混淆矩阵
def plotMatrix(attacks, y_test, y_pred):
# attacks是整个数据集的标签集合，但是切分测试集的时候，某些标签数量很少，可能会被去掉，这里要剔除掉这些标签
y_test_set = set(y_test)
y_test_list = list(y_test_set)
attacks_test = []
for i in range(0, len(y_test_set)):
attacks_test.append(attacks[y_test_list[i]])
p = PlotConfusionMatrix()
p.prepareWork(attacks_test, y_test, y_pred)
# 绘制混淆矩阵图形，attacks是标签列表，y_test是测试结果，y_pred是预测结果
plotMatrix(attacks,y_test,y_pred)
2.4 调参
调参，就我所知有两种，一种是通过绘制学习曲线来调节某个超参数——横坐标为参数，纵坐标为准确度或者其他模型度量；另外一种是通过网格搜索交叉验证来调节多个超参数（本质是组合参数，然后循环验证）
2.4.1 绘制学习曲线调节决策树最优深度
参数那么多，如何确定最优的参数呢？针对一个参数调节的时候，可以画出学习曲线——横坐标为参数，纵坐标为准确度：
import matplotlib.pyplot as plt
test = []
for i in range(10):
clf = tree.DecisionTreeClassifier(max_depth=i+1
,criterion="entropy"
,random_state=30
,splitter="random"
)
clf = clf.fit(Xtrain, Ytrain)
score = clf.score(Xtest, Ytest)
test.append(score)
plt.plot(range(1,11),test,color="red",label="max_depth")
plt.legend()
plt.show()2.4.2 网格搜索寻找最优参数组合
-
#网格搜索：能够帮助我们同时调整多个参数的技术，枚举技术 import numpy as np gini_thresholds = np.linspace(0,0.5,20)#基尼系数的边界 #entropy_thresholds = np.linespace(0, 1, 50) #一串参数和这些参数对应的，我们希望网格搜索来搜索的参数的取值范围 parameters = {'splitter':('best','random') ,'criterion':("gini","entropy") ,"max_depth":[*range(1,10)] ,'min_samples_leaf':[*range(1,50,5)] ,'min_impurity_decrease':[*gini_thresholds]} clf = DecisionTreeClassifier(random_state=25)#实例化决策树 GS = GridSearchCV(clf, parameters, cv=10)#实例化网格搜索，cv指的是交叉验证 GS.fit(Xtrain,Ytrain) print(GS.best_params_)#从我们输入的参数和参数取值的列表中，返回最佳组合 print(GS.best_score_)#网格搜索后的模型的评判标准
文章出处登录后可见！
已经登录？立即刷新
