├── README.md ├── combined_data.csv ├── step1_split_with_type.ipynb ├── step2_calculate_by_split.ipynb ├── step3_visualization_WebDDoS.ipynb ├── step4_concat_500_per_class.ipynb ├── step5_meachineLearning.ipynb ├── step5_meachineLearning_Linear.ipynb ├── step5_meachineLearning_heatmap.ipynb ├── step6_PCA_t-SNE.ipynb ├── step7_mlp.ipynb └── step8_cnn.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # CIC-DDoS2019-Detection 2 | 数据清洗与合并 Data Cleaning and Merging ； 3 | 4 | 机器学习模型 Machine Learning Models； 5 | 6 | 深度学习模型 Deep Learning Models ； 7 | 8 | PCA, t-SNE分析 PCA, t-SNE Analysis； 9 | 10 | 数据，结果可视化 Data and Results Visualization 11 | 12 | 13 | 14 | ## CIC-DDoS2019 15 | 16 | 17 | 18 | 对`CIC-DDoS2019`数据集进行检测,本文提供了如下内容： 19 | 20 | + 数据清洗与合并 21 | + 机器学习模型 22 | + 深度学习模型 23 | + PCA,t-SNE分析 24 | + 数据，结果可视化 25 | 26 | 27 | 28 | ### 1、数据集加载 29 | 30 | 31 | 32 | 选择的数据集是这里的csv文件[CIC-DDoS2019 (kaggle.com)](https://www.kaggle.com/datasets/dhoogla/cicddos2019) 33 | 34 | ![image-20240618203852993](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182038051.png) 35 | 36 | 37 | 38 | ``` 39 | 链接：https://pan.baidu.com/s/1gP86I08ZQhAOgcfCd5OVVw?pwd=2019 40 | 提取码：2019 41 | ``` 42 | 43 | 44 | 45 | ### 2、数据分割 46 | 47 | ```python 48 | import os 49 | import pandas as pd 50 | 51 | # 设置包含CSV文件的目录 52 | directory = 'class_split' # 替换为您的目录路径 53 | 54 | # 列出目录下所有的CSV文件 55 | csv_files = [f for f in os.listdir(directory) if f.endswith('.csv')] 56 | 57 | # 读取每个CSV文件并打印行数 58 | for csv_file in csv_files: 59 | file_path = os.path.join(directory, csv_file) 60 | try: 61 | # 读取CSV文件 62 | data = pd.read_csv(file_path) 63 | # 获取行数 64 | num_rows = len(data) 65 | print(f"{csv_file}: {num_rows} 行") 66 | except Exception as e: 67 | print(f"无法读取 {csv_file}: {e}") 68 | 69 | ``` 70 | 71 | ![image-20240618205624924](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182056981.png) 72 | 73 | ![image-20240618205239085](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182052134.png) 74 | 75 | 76 | 77 | 78 | 79 | ### 3、数据可视化 80 | 81 | ```python 82 | import pandas as pd 83 | import matplotlib.pyplot as plt 84 | import seaborn as sns 85 | # 加载数据 86 | file_path = './class_split/WebDDoS.csv' 87 | data = pd.read_csv(file_path) 88 | 89 | # 设置绘图样式 90 | sns.set(style="whitegrid") 91 | 92 | # 创建一个图形框架 93 | fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(16, 6)) 94 | 95 | # 散点图：流持续时间与前向数据包数量 96 | sns.scatterplot(ax=axes[0], x=data[' Flow Duration'], y=data[' Total Fwd Packets'], color='blue') 97 | axes[0].set_title('Flow Duration vs Total Fwd Packets') 98 | axes[0].set_xlabel('Flow Duration') 99 | axes[0].set_ylabel('Total Fwd Packets') 100 | 101 | # 箱线图：前向和后向数据包的分布 102 | sns.boxplot(data=data[[' Total Fwd Packets', ' Total Backward Packets']], ax=axes[1]) 103 | axes[1].set_title('Distribution of Packet Counts') 104 | axes[1].set_ylabel('Packet Counts') 105 | 106 | plt.tight_layout() 107 | plt.show() 108 | 109 | 110 | ``` 111 | 112 | ![image-20240618205846107](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182058190.png) 113 | 114 | 115 | 116 | 117 | 118 | ```python 119 | import pandas as pd 120 | import matplotlib.pyplot as plt 121 | import seaborn as sns 122 | import numpy as np 123 | 124 | # 加载数据 125 | file_path = './class_split/WebDDoS.csv' 126 | data = pd.read_csv(file_path) 127 | 128 | # 将时间列转换为 datetime 类型 129 | data[' Timestamp'] = pd.to_datetime(data[' Timestamp']) 130 | 131 | # 筛选出数值型数据列 132 | numeric_data = data.select_dtypes(include=[np.number]) 133 | 134 | # 设置绘图样式 135 | sns.set(style="whitegrid") 136 | 137 | # 创建图形框架，一行两列 138 | fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(16, 6)) 139 | 140 | # 时间序列分析：数据包数量随时间的变化 141 | data.sort_values(' Timestamp', inplace=True) 142 | data['Packet Count'] = data[' Total Fwd Packets'] + data[' Total Backward Packets'] 143 | data.plot(x=' Timestamp', y='Packet Count', ax=axes[0], title='Packet Count Over Time') 144 | 145 | # 热图：特征间的相关性 146 | correlation_matrix = numeric_data.corr() 147 | sns.heatmap(correlation_matrix, ax=axes[1]) 148 | axes[1].set_title('Feature Correlation Heatmap') 149 | 150 | plt.tight_layout() 151 | plt.show() 152 | 153 | ``` 154 | 155 | ![image-20240618205929292](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182059383.png) 156 | 157 | ```python 158 | import pandas as pd 159 | import matplotlib.pyplot as plt 160 | import seaborn as sns 161 | 162 | # 加载数据 163 | file_path = './class_split/WebDDoS.csv' 164 | data = pd.read_csv(file_path) 165 | 166 | # 设置绘图样式 167 | sns.set(style="whitegrid") 168 | 169 | # 创建图形框架，一行两列 170 | fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(18, 9)) 171 | 172 | # 小提琴图：前向包大小与反向包大小 173 | sns.violinplot(data=data[[' Total Fwd Packets', ' Total Backward Packets']], ax=axes[0]) 174 | axes[0].set_title('Violin Plot of Packet Sizes') 175 | 176 | # 选择源端口和目的端口的频率最高的前5个端口 177 | top_src_ports = data[' Source Port'].value_counts().nlargest(5) 178 | top_dst_ports = data[' Destination Port'].value_counts().nlargest(5) 179 | 180 | # 圆饼图：显示源端口的计数 181 | axes[1].pie(top_src_ports, labels=top_src_ports.index, autopct='%1.1f%%', startangle=140) 182 | axes[1].set_title('Pie Chart of Top 5 Source Ports') 183 | 184 | plt.tight_layout() 185 | plt.show() 186 | 187 | 188 | ``` 189 | 190 | ![violin_pie](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182102934.png) 191 | 192 | 193 | 194 | 195 | 196 | ```python 197 | import pandas as pd 198 | import seaborn as sns 199 | import matplotlib.pyplot as plt 200 | import numpy as np 201 | 202 | # 加载数据 203 | file_path = './class_split/WebDDoS.csv' 204 | data = pd.read_csv(file_path) 205 | 206 | # 数据清洗，处理可能的无穷大或不合理的值 207 | data['Flow Bytes/s'] = pd.to_numeric(data['Flow Bytes/s'], errors='coerce').replace([np.inf, -np.inf], np.nan).fillna(0) 208 | 209 | # 选择几个数值变量进行分析 210 | selected_columns = [' Flow Duration', ' Total Fwd Packets', ' Total Backward Packets', 'Flow Bytes/s'] 211 | selected_data = data[selected_columns] 212 | 213 | # 设置绘图样式 214 | sns.set(style="whitegrid") 215 | 216 | # 创建对角线分布图 217 | pair_plot = sns.pairplot(selected_data) 218 | pair_plot.fig.suptitle("Pair Plot of Selected Features", y=1.02) # 添加总标题并调整位置 219 | plt.savefig("pair_plot.png") 220 | plt.show() 221 | 222 | ``` 223 | 224 | ![pair_plot](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182102335.png) 225 | 226 | 227 | 228 | 229 | 230 | ### 4、数据合并 231 | 232 | ```python 233 | import pandas as pd 234 | import os 235 | 236 | # 文件目录 237 | directory = './class_split/' 238 | 239 | # 文件列表 240 | files = [ 241 | 'BENIGN.csv', 'DrDoS_DNS.csv', 'DrDoS_LDAP.csv', 'DrDoS_MSSQL.csv', 242 | 'DrDoS_NTP.csv', 'DrDoS_NetBIOS.csv', 'DrDoS_SNMP.csv', 'DrDoS_UDP.csv', 243 | 'LDAP.csv', 'MSSQL.csv', 'NetBIOS.csv', 'Portmap.csv', 244 | 'Syn.csv', 'TFTP.csv', 'UDP.csv', 'UDP-lag.csv' 245 | ] 246 | 247 | # 创建空的DataFrame 248 | combined_data = pd.DataFrame() 249 | 250 | # 对每个文件进行处理 251 | for file in files: 252 | file_path = os.path.join(directory, file) 253 | # 加载数据 254 | data = pd.read_csv(file_path) 255 | # 随机选取500条数据 256 | sample_data = data.sample(n=500, random_state=1) 257 | # 将数据加入到总的DataFrame中 258 | combined_data = pd.concat([combined_data, sample_data], ignore_index=True) 259 | 260 | # 保存到新的CSV文件 261 | combined_data.to_csv('./combined_data.csv', index=False) 262 | 263 | print("数据合并完成，已保存到combined_data.csv") 264 | 265 | ``` 266 | 267 | 对于每一种类型都选择500个样本`combined_data.csv` 268 | 269 | 【注：本文提供的csv可满足简单的训练，如果需要更多的数据，可以下载官方数据】 270 | 271 | ### 5、机器学习 272 | 273 | #### Logistic 274 | 275 | ```python 276 | # 训练逻辑回归模型 277 | logreg.fit(X_train, y_train) 278 | y_pred_logreg = logreg.predict(X_test) 279 | print("Logistic Regression Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_logreg) * 100)) 280 | 281 | ``` 282 | 283 | 284 | 285 | 286 | 287 | #### Random Forest 288 | 289 | ```python 290 | # 训练随机森林模型 291 | rf.fit(X_train, y_train) 292 | y_pred_rf = rf.predict(X_test) 293 | print("Random Forest Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_rf) * 100)) 294 | 295 | ``` 296 | 297 | 298 | 299 | 300 | 301 | #### SVM 302 | 303 | ```python 304 | # 训练支持向量机模型 305 | svm.fit(X_train, y_train) 306 | y_pred_svm = svm.predict(X_test) 307 | print("SVM Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_svm) * 100)) 308 | 309 | ``` 310 | 311 | 312 | 313 | #### XGBoost 314 | 315 | ```python 316 | # 训练XGBoost模型 317 | xgb.fit(X_train, y_train) 318 | y_pred_xgb = xgb.predict(X_test) 319 | print("XGBoost Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_xgb) * 100)) 320 | 321 | # 打印分类报告（以XGBoost为例） 322 | print("\nClassification Report for XGBoost:") 323 | print(classification_report(y_test, y_pred_xgb)) 324 | ``` 325 | 326 | 327 | 328 | 329 | 330 | ```python 331 | from sklearn.linear_model import LogisticRegression 332 | from sklearn.ensemble import RandomForestClassifier 333 | from sklearn.svm import SVC 334 | from xgboost import XGBClassifier 335 | from sklearn.metrics import accuracy_score, classification_report 336 | 337 | # 初始化模型 338 | logreg = LogisticRegression(max_iter=1000) 339 | rf = RandomForestClassifier(n_estimators=100) 340 | svm = SVC() 341 | xgb = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss') 342 | 343 | # 训练逻辑回归模型 344 | logreg.fit(X_train, y_train) 345 | y_pred_logreg = logreg.predict(X_test) 346 | print("Logistic Regression Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_logreg) * 100)) 347 | 348 | # 训练随机森林模型 349 | rf.fit(X_train, y_train) 350 | y_pred_rf = rf.predict(X_test) 351 | print("Random Forest Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_rf) * 100)) 352 | 353 | # 训练支持向量机模型 354 | svm.fit(X_train, y_train) 355 | y_pred_svm = svm.predict(X_test) 356 | print("SVM Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_svm) * 100)) 357 | 358 | # 训练XGBoost模型 359 | xgb.fit(X_train, y_train) 360 | y_pred_xgb = xgb.predict(X_test) 361 | print("XGBoost Accuracy: {:.2f}%".format(accuracy_score(y_test, y_pred_xgb) * 100)) 362 | 363 | # 打印分类报告（以XGBoost为例） 364 | print("\nClassification Report for XGBoost:") 365 | print(classification_report(y_test, y_pred_xgb)) 366 | 367 | ``` 368 | 369 | ``` 370 | Logistic Regression Accuracy: 54.96% 371 | Random Forest Accuracy: 62.04% 372 | SVM Accuracy: 50.17% 373 | XGBoost Accuracy: 62.75% 374 | 375 | Classification Report for XGBoost: 376 | precision recall f1-score support 377 | 378 | 0 0.99 0.99 0.99 170 379 | 1 0.50 0.42 0.45 143 380 | 2 0.31 0.25 0.28 174 381 | 3 0.56 0.52 0.54 159 382 | 4 0.99 0.99 0.99 145 383 | 5 0.45 0.42 0.43 146 384 | 6 0.60 0.65 0.63 148 385 | 7 0.46 0.55 0.50 121 386 | 8 0.36 0.46 0.40 144 387 | 9 0.54 0.56 0.55 156 388 | 10 0.38 0.40 0.39 154 389 | 11 0.40 0.44 0.42 146 390 | 12 0.99 0.98 0.99 150 391 | 13 1.00 0.97 0.99 158 392 | 14 0.51 0.49 0.50 130 393 | 15 0.92 0.90 0.91 156 394 | 395 | accuracy 0.63 2400 396 | macro avg 0.62 0.62 0.62 2400 397 | weighted avg 0.63 0.63 0.63 2400 398 | ``` 399 | 400 | 401 | 402 | ```python 403 | from sklearn.metrics import confusion_matrix 404 | import seaborn as sns 405 | from sklearn.linear_model import LogisticRegression 406 | from sklearn.ensemble import RandomForestClassifier 407 | from sklearn.svm import SVC 408 | from xgboost import XGBClassifier 409 | from sklearn.metrics import accuracy_score, classification_report 410 | import matplotlib.pyplot as plt 411 | 412 | # 初始化模型 413 | logreg = LogisticRegression(max_iter=1000) 414 | rf = RandomForestClassifier(n_estimators=100) 415 | svm = SVC() 416 | 417 | # 训练模型 418 | logreg.fit(X_train, y_train) 419 | rf.fit(X_train, y_train) 420 | svm.fit(X_train, y_train) 421 | 422 | # 预测结果 423 | y_pred_logreg = logreg.predict(X_test) 424 | y_pred_rf = rf.predict(X_test) 425 | y_pred_svm = svm.predict(X_test) 426 | 427 | # 混淆矩阵 428 | cm_logreg = confusion_matrix(y_test, y_pred_logreg) 429 | cm_rf = confusion_matrix(y_test, y_pred_rf) 430 | cm_svm = confusion_matrix(y_test, y_pred_svm) 431 | 432 | # 绘制混淆矩阵的热图 433 | fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(18, 6)) 434 | sns.heatmap(cm_logreg, annot=True, fmt="d", ax=axes[0], cmap='Blues') 435 | axes[0].set_title('Logistic Regression Confusion Matrix') 436 | axes[0].set_xlabel('Predicted labels') 437 | axes[0].set_ylabel('True labels') 438 | 439 | sns.heatmap(cm_rf, annot=True, fmt="d", ax=axes[1], cmap='Blues') 440 | axes[1].set_title('Random Forest Confusion Matrix') 441 | axes[1].set_xlabel('Predicted labels') 442 | axes[1].set_ylabel('True labels') 443 | 444 | sns.heatmap(cm_svm, annot=True, fmt="d", ax=axes[2], cmap='Blues') 445 | axes[2].set_title('SVM Confusion Matrix') 446 | axes[2].set_xlabel('Predicted labels') 447 | axes[2].set_ylabel('True labels') 448 | 449 | plt.tight_layout() 450 | plt.savefig("confusion.png") 451 | plt.show() 452 | 453 | ``` 454 | 455 | ![confusion](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182109743.png) 456 | 457 | 458 | 459 | ### 6、PCA t-SNE 460 | 461 | 462 | 463 | ```python 464 | from sklearn.decomposition import PCA 465 | from sklearn.manifold import TSNE 466 | import matplotlib.pyplot as plt 467 | import pandas as pd 468 | from sklearn.preprocessing import StandardScaler, LabelEncoder 469 | from sklearn.model_selection import train_test_split 470 | import numpy as np 471 | 472 | # 加载数据 473 | data = pd.read_csv('./combined_data.csv') 474 | 475 | # 删除不需要的列，例如时间戳或IP地址（假设你的数据集中有这些列） 476 | data.drop([' Timestamp'], axis=1, inplace=True) 477 | 478 | # 类型转换，将分类标签编码 479 | label_encoder = LabelEncoder() 480 | data[' Label'] = label_encoder.fit_transform(data[' Label']) 481 | 482 | # 检查并处理无穷大和非常大的数值 483 | data.replace([np.inf, -np.inf], np.nan, inplace=True) # 将inf替换为NaN 484 | data.fillna(data.median(), inplace=True) # 使用中位数填充NaN，确保之前中位数计算不包括inf 485 | 486 | # 特征标准化 487 | scaler = StandardScaler() 488 | X = scaler.fit_transform(data.drop(' Label', axis=1)) # 确保标签列不参与标准化 489 | y = data[' Label'] 490 | # PCA 491 | pca = PCA(n_components=2) 492 | X_pca = pca.fit_transform(X) 493 | 494 | # t-SNE 495 | tsne = TSNE(n_components=2, random_state=42) 496 | X_tsne = tsne.fit_transform(X) 497 | 498 | # 可视化 PCA 499 | plt.figure(figsize=(8, 8)) 500 | plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', alpha=0.5) 501 | plt.title('PCA of Dataset') 502 | plt.xlabel('Principal Component 1') 503 | plt.ylabel('Principal Component 2') 504 | plt.colorbar() 505 | plt.show() 506 | 507 | # 可视化 t-SNE 508 | plt.figure(figsize=(8, 8)) 509 | plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='viridis', alpha=0.5) 510 | plt.title('t-SNE of Dataset') 511 | plt.xlabel('t-SNE Feature 1') 512 | plt.ylabel('t-SNE Feature 2') 513 | plt.colorbar() 514 | plt.show() 515 | 516 | ``` 517 | 518 | ![image-20240618211011385](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182110450.png) 519 | 520 | ![image-20240618211021915](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182110981.png) 521 | 522 | ### 7、深度学习 523 | 524 | #### MLP 525 | 526 | ```python 527 | import torch 528 | import torch.nn as nn 529 | import torch.optim as optim 530 | from torch.utils.data import DataLoader, TensorDataset 531 | 532 | # 定义模型 533 | class NeuralNetwork(nn.Module): 534 | def __init__(self, input_size, num_classes): 535 | super(NeuralNetwork, self).__init__() 536 | self.layer1 = nn.Linear(input_size, 64) 537 | self.relu = nn.ReLU() 538 | self.layer2 = nn.Linear(64, 64) 539 | self.output_layer = nn.Linear(64, num_classes) 540 | 541 | def forward(self, x): 542 | x = self.relu(self.layer1(x)) 543 | x = self.relu(self.layer2(x)) 544 | x = self.output_layer(x) 545 | return x 546 | 547 | # 初始化模型 548 | input_size = X_train.shape[1] 549 | num_classes = len(np.unique(y)) 550 | model = NeuralNetwork(input_size, num_classes) 551 | 552 | # 损失函数和优化器 553 | criterion = nn.CrossEntropyLoss() 554 | optimizer = optim.Adam(model.parameters(), lr=0.001) 555 | 556 | ``` 557 | 558 | ![image-20240618211132917](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182111981.png) 559 | 560 | ![image-20240618211140162](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182111228.png) 561 | 562 | #### CNN 563 | 564 | ```python 565 | import torch 566 | import torch.nn as nn 567 | import torch.optim as optim 568 | from torch.utils.data import DataLoader, TensorDataset 569 | 570 | # 定义模型 571 | class CNN(nn.Module): 572 | def __init__(self, input_size, num_classes): 573 | super(CNN, self).__init__() 574 | self.conv1 = nn.Conv1d(1, 16, kernel_size=3, stride=1, padding=1) 575 | self.relu = nn.ReLU() 576 | self.pool = nn.MaxPool1d(kernel_size=2, stride=2) 577 | self.conv2 = nn.Conv1d(16, 32, kernel_size=3, stride=1, padding=1) 578 | # 计算池化后的尺寸 579 | conv1_out_size = (input_size + 2 * 1 - 3) / 1 + 1 # Conv1 580 | pool1_out_size = conv1_out_size / 2 # Pool1 581 | conv2_out_size = (pool1_out_size + 2 * 1 - 3) / 1 + 1 # Conv2 582 | pool2_out_size = conv2_out_size / 2 # Pool2 583 | final_size = int(pool2_out_size) * 32 # conv2 的输出通道数 * 输出长度 584 | self.fc = nn.Linear(final_size, num_classes) 585 | 586 | def forward(self, x): 587 | x = x.unsqueeze(1) # Adding a channel dimension 588 | x = self.relu(self.conv1(x)) 589 | x = self.pool(x) 590 | x = self.relu(self.conv2(x)) 591 | x = self.pool(x) 592 | x = torch.flatten(x, 1) 593 | x = self.fc(x) 594 | return x 595 | 596 | 597 | # 初始化模型 598 | input_size = X_train.shape[1] 599 | num_classes = len(np.unique(y)) 600 | model = CNN(input_size,num_classes) 601 | 602 | # 损失函数和优化器 603 | criterion = nn.CrossEntropyLoss() 604 | optimizer = optim.Adam(model.parameters(), lr=0.001) 605 | 606 | ``` 607 | 608 | ![image-20240618211231779](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182112848.png) 609 | 610 | ![image-20240618211238465](https://daetz-image.oss-cn-hangzhou.aliyuncs.com/img/202406182112545.png) 611 | -------------------------------------------------------------------------------- /step1_split_with_type.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "# !pip install pandas\n", 10 | "# !pip install scikit-learn" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "# Load Data" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "metadata": { 24 | "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", 25 | "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5", 26 | "tags": [] 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "import numpy as np # linear algebra\n", 31 | "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", 32 | "from sklearn.utils import resample\n", 33 | "from sklearn import preprocessing\n", 34 | "\n", 35 | "import os\n", 36 | "dataset_path = []\n", 37 | "\n", 38 | "for dirname, _, filenames in os.walk('./data/'):\n", 39 | " for filename in filenames:\n", 40 | " if filename.endswith('.csv'):\n", 41 | " dfp = os.path.join(dirname, filename)\n", 42 | " dataset_path.append(dfp)\n" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 3, 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "name": "stdout", 52 | "output_type": "stream", 53 | "text": [ 54 | "17\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "print(len(dataset_path))" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 4, 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "# mult = 5\n", 69 | "cols = list(pd.read_csv(dataset_path[1], nrows=1))\n", 70 | "\n", 71 | "def load_file(path):\n", 72 | " # data = pd.read_csv(path, sep=',')\n", 73 | " data = pd.read_csv(path,\n", 74 | " usecols =[i for i in cols if i != \" Source IP\" \n", 75 | " and i != ' Destination IP' and i != 'Flow ID' \n", 76 | " and i != 'SimillarHTTP' and i != 'Unnamed: 0'])\n", 77 | "\n", 78 | " return data" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 5, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "samples = pd.concat([load_file(dfp) for dfp in dataset_path], ignore_index=True)" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 6, 93 | "metadata": {}, 94 | "outputs": [ 95 | { 96 | "data": { 97 | "image/png": "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\n", 98 | "text/plain": [ 99 | "
" 100 | ] 101 | }, 102 | "metadata": { 103 | "needs_background": "light" 104 | }, 105 | "output_type": "display_data" 106 | } 107 | ], 108 | "source": [ 109 | "import pandas as pd\n", 110 | "import matplotlib.pyplot as plt\n", 111 | "\n", 112 | "# Count the occurrences of each label\n", 113 | "label_counts = samples[' Label'].value_counts()\n", 114 | "\n", 115 | "# Create a bar plot to visualize the label counts\n", 116 | "plt.figure(figsize=(10, 6))\n", 117 | "label_counts.plot(kind='bar')\n", 118 | "plt.title('Comparison of Label Column')\n", 119 | "plt.xlabel('Label')\n", 120 | "plt.ylabel('Count')\n", 121 | "plt.show()" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 7, 127 | "metadata": {}, 128 | "outputs": [ 129 | { 130 | "data": { 131 | "text/html": [ 132 | "
\n", 133 | "\n", 146 | "\n", 147 | " \n", 148 | " \n", 149 | " \n", 150 | " \n", 151 | " \n", 152 | " \n", 153 | " \n", 154 | " \n", 155 | " \n", 156 | " \n", 157 | " \n", 158 | " \n", 159 | " \n", 160 | " \n", 161 | " \n", 162 | " \n", 163 | " \n", 164 | " \n", 165 | " \n", 166 | " \n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | " \n", 218 | " \n", 219 | " \n", 220 | " \n", 221 | " \n", 222 | " \n", 223 | " \n", 224 | " \n", 225 | " \n", 226 | " \n", 227 | " \n", 228 | " \n", 229 | " \n", 230 | " \n", 231 | " \n", 232 | " \n", 233 | " \n", 234 | " \n", 235 | " \n", 236 | " \n", 237 | " \n", 238 | " \n", 239 | " \n", 240 | " \n", 241 | " \n", 242 | " \n", 243 | " \n", 244 | " \n", 245 | " \n", 246 | " \n", 247 | " \n", 248 | " \n", 249 | " \n", 250 | " \n", 251 | " \n", 252 | " \n", 253 | " \n", 254 | " \n", 255 | " \n", 256 | " \n", 257 | " \n", 258 | " \n", 259 | " \n", 260 | " \n", 261 | " \n", 262 | " \n", 263 | " \n", 264 | " \n", 265 | " \n", 266 | " \n", 267 | " \n", 268 | " \n", 269 | " \n", 270 | " \n", 271 | " \n", 272 | " \n", 273 | " \n", 274 | " \n", 275 | " \n", 276 | " \n", 277 | " \n", 278 | " \n", 279 | " \n", 280 | " \n", 281 | " \n", 282 | " \n", 283 | " \n", 284 | " \n", 285 | " \n", 286 | " \n", 287 | " \n", 288 | " \n", 289 | " \n", 290 | " \n", 291 | " \n", 292 | " \n", 293 | " \n", 294 | " \n", 295 | " \n", 296 | " \n", 297 | " \n", 298 | " \n", 299 | " \n", 300 | " \n", 301 | " \n", 302 | " \n", 303 | " \n", 304 | " \n", 305 | " \n", 306 | " \n", 307 | " \n", 308 | " \n", 309 | " \n", 310 | " \n", 311 | " \n", 312 | " \n", 313 | " \n", 314 | " \n", 315 | " \n", 316 | " \n", 317 | " \n", 318 | " \n", 319 | " \n", 320 | " \n", 321 | " \n", 322 | " \n", 323 | " \n", 324 | " \n", 325 | " \n", 326 | " \n", 327 | " \n", 328 | " \n", 329 | " \n", 330 | " \n", 331 | " \n", 332 | " \n", 333 | " \n", 334 | " \n", 335 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | " \n", 342 | " \n", 343 | " \n", 344 | " \n", 345 | " \n", 346 | " \n", 347 | " \n", 348 | " \n", 349 | " \n", 350 | " \n", 351 | " \n", 352 | " \n", 353 | " \n", 354 | " \n", 355 | " \n", 356 | " \n", 357 | " \n", 358 | " \n", 359 | " \n", 360 | " \n", 361 | " \n", 362 | " \n", 363 | " \n", 364 | " \n", 365 | " \n", 366 | " \n", 367 | " \n", 368 | " \n", 369 | " \n", 370 | " \n", 371 | " \n", 372 | " \n", 373 | " \n", 374 | " \n", 375 | " \n", 376 | " \n", 377 | " \n", 378 | " \n", 379 | " \n", 380 | " \n", 381 | " \n", 382 | " \n", 383 | " \n", 384 | " \n", 385 | " \n", 386 | " \n", 387 | " \n", 388 | " \n", 389 | " \n", 390 | " \n", 391 | " \n", 392 | " \n", 393 | " \n", 394 | " \n", 395 | " \n", 396 | " \n", 397 | " \n", 398 | " \n", 399 | " \n", 400 | " \n", 401 | " \n", 402 | " \n", 403 | " \n", 404 | " \n", 405 | " \n", 406 | " \n", 407 | " \n", 408 | " \n", 409 | " \n", 410 | " \n", 411 | " \n", 412 | " \n", 413 | " \n", 414 | " \n", 415 | " \n", 416 | " \n", 417 | " \n", 418 | " \n", 419 | " \n", 420 | " \n", 421 | " \n", 422 | " \n", 423 | " \n", 424 | " \n", 425 | " \n", 426 | " \n", 427 | " \n", 428 | " \n", 429 | " \n", 430 | " \n", 431 | " \n", 432 | " \n", 433 | " \n", 434 | " \n", 435 | " \n", 436 | " \n", 437 | " \n", 438 | " \n", 439 | "
Source PortDestination PortProtocolTimestampFlow DurationTotal Fwd PacketsTotal Backward PacketsTotal Length of Fwd PacketsTotal Length of Bwd PacketsFwd Packet Length Max...Active MeanActive StdActive MaxActive MinIdle MeanIdle StdIdle MaxIdle MinInboundLabel
091020073172018-12-01 11:09:58.62254548202944.00.01472.0...0.00.00.00.00.00.00.00.01DrDoS_DNS
158839159172018-12-01 11:10:43.9115812202944.00.01472.0...0.00.00.00.00.00.00.00.01DrDoS_DNS
295322161172018-12-01 11:08:16.5006551202944.00.01472.0...0.00.00.00.00.00.00.00.01DrDoS_DNS
366318811172018-12-01 11:11:00.6834381202944.00.01472.0...0.00.00.00.00.00.00.00.01DrDoS_DNS
45914168172018-12-01 11:11:08.1362061202896.00.01448.0...0.00.00.00.00.00.00.00.01DrDoS_DNS
..................................................................
1130645804628062018-11-03 11:30:16.18603653120.00.00.0...0.00.00.00.00.00.00.00.01BENIGN
1130646804628262018-11-03 11:30:16.18616366120.00.00.0...0.00.00.00.00.00.00.00.01BENIGN
113064751233123172018-11-03 11:30:16.402521262882296.096.048.0...0.00.00.00.00.00.00.00.00BENIGN
1130648529688062018-11-03 11:30:17.14519930679110.00.00.0...0.00.00.00.00.00.00.00.00BENIGN
1130649805296862018-11-03 11:30:17.17587967120.00.00.0...0.00.00.00.00.00.00.00.01BENIGN
\n", 440 | "

1130650 rows × 83 columns

\n", 441 | "
" 442 | ], 443 | "text/plain": [ 444 | " Source Port Destination Port Protocol \\\n", 445 | "0 910 20073 17 \n", 446 | "1 588 39159 17 \n", 447 | "2 953 22161 17 \n", 448 | "3 663 18811 17 \n", 449 | "4 591 4168 17 \n", 450 | "... ... ... ... \n", 451 | "1130645 80 46280 6 \n", 452 | "1130646 80 46282 6 \n", 453 | "1130647 51233 123 17 \n", 454 | "1130648 52968 80 6 \n", 455 | "1130649 80 52968 6 \n", 456 | "\n", 457 | " Timestamp Flow Duration Total Fwd Packets \\\n", 458 | "0 2018-12-01 11:09:58.622545 48 2 \n", 459 | "1 2018-12-01 11:10:43.911581 2 2 \n", 460 | "2 2018-12-01 11:08:16.500655 1 2 \n", 461 | "3 2018-12-01 11:11:00.683438 1 2 \n", 462 | "4 2018-12-01 11:11:08.136206 1 2 \n", 463 | "... ... ... ... \n", 464 | "1130645 2018-11-03 11:30:16.186036 53 1 \n", 465 | "1130646 2018-11-03 11:30:16.186163 66 1 \n", 466 | "1130647 2018-11-03 11:30:16.402521 26288 2 \n", 467 | "1130648 2018-11-03 11:30:17.145199 30679 1 \n", 468 | "1130649 2018-11-03 11:30:17.175879 67 1 \n", 469 | "\n", 470 | " Total Backward Packets Total Length of Fwd Packets \\\n", 471 | "0 0 2944.0 \n", 472 | "1 0 2944.0 \n", 473 | "2 0 2944.0 \n", 474 | "3 0 2944.0 \n", 475 | "4 0 2896.0 \n", 476 | "... ... ... \n", 477 | "1130645 2 0.0 \n", 478 | "1130646 2 0.0 \n", 479 | "1130647 2 96.0 \n", 480 | "1130648 1 0.0 \n", 481 | "1130649 2 0.0 \n", 482 | "\n", 483 | " Total Length of Bwd Packets Fwd Packet Length Max ... \\\n", 484 | "0 0.0 1472.0 ... \n", 485 | "1 0.0 1472.0 ... \n", 486 | "2 0.0 1472.0 ... \n", 487 | "3 0.0 1472.0 ... \n", 488 | "4 0.0 1448.0 ... \n", 489 | "... ... ... ... \n", 490 | "1130645 0.0 0.0 ... \n", 491 | "1130646 0.0 0.0 ... \n", 492 | "1130647 96.0 48.0 ... \n", 493 | "1130648 0.0 0.0 ... \n", 494 | "1130649 0.0 0.0 ... \n", 495 | "\n", 496 | " Active Mean Active Std Active Max Active Min Idle Mean \\\n", 497 | "0 0.0 0.0 0.0 0.0 0.0 \n", 498 | "1 0.0 0.0 0.0 0.0 0.0 \n", 499 | "2 0.0 0.0 0.0 0.0 0.0 \n", 500 | "3 0.0 0.0 0.0 0.0 0.0 \n", 501 | "4 0.0 0.0 0.0 0.0 0.0 \n", 502 | "... ... ... ... ... ... \n", 503 | "1130645 0.0 0.0 0.0 0.0 0.0 \n", 504 | "1130646 0.0 0.0 0.0 0.0 0.0 \n", 505 | "1130647 0.0 0.0 0.0 0.0 0.0 \n", 506 | "1130648 0.0 0.0 0.0 0.0 0.0 \n", 507 | "1130649 0.0 0.0 0.0 0.0 0.0 \n", 508 | "\n", 509 | " Idle Std Idle Max Idle Min Inbound Label \n", 510 | "0 0.0 0.0 0.0 1 DrDoS_DNS \n", 511 | "1 0.0 0.0 0.0 1 DrDoS_DNS \n", 512 | "2 0.0 0.0 0.0 1 DrDoS_DNS \n", 513 | "3 0.0 0.0 0.0 1 DrDoS_DNS \n", 514 | "4 0.0 0.0 0.0 1 DrDoS_DNS \n", 515 | "... ... ... ... ... ... \n", 516 | "1130645 0.0 0.0 0.0 1 BENIGN \n", 517 | "1130646 0.0 0.0 0.0 1 BENIGN \n", 518 | "1130647 0.0 0.0 0.0 0 BENIGN \n", 519 | "1130648 0.0 0.0 0.0 0 BENIGN \n", 520 | "1130649 0.0 0.0 0.0 1 BENIGN \n", 521 | "\n", 522 | "[1130650 rows x 83 columns]" 523 | ] 524 | }, 525 | "execution_count": 7, 526 | "metadata": {}, 527 | "output_type": "execute_result" 528 | } 529 | ], 530 | "source": [ 531 | "samples" 532 | ] 533 | }, 534 | { 535 | "cell_type": "code", 536 | "execution_count": 8, 537 | "metadata": {}, 538 | "outputs": [ 539 | { 540 | "name": "stdout", 541 | "output_type": "stream", 542 | "text": [ 543 | "数据已按类别分割并保存到文件中。\n" 544 | ] 545 | } 546 | ], 547 | "source": [ 548 | "\n", 549 | "# 根据 'Label' 列分组数据\n", 550 | "grouped = samples.groupby(' Label')\n", 551 | "\n", 552 | "# 创建存储分割文件的目录\n", 553 | "output_dir = 'class_split'\n", 554 | "if not os.path.exists(output_dir):\n", 555 | " os.makedirs(output_dir)\n", 556 | "\n", 557 | "# 为每个类别保存一个CSV文件\n", 558 | "for label, group in grouped:\n", 559 | " filename = os.path.join(output_dir, f\"{label}.csv\")\n", 560 | " group.to_csv(filename, index=False)\n", 561 | "\n", 562 | "print(\"数据已按类别分割并保存到文件中。\")" 563 | ] 564 | } 565 | ], 566 | "metadata": { 567 | "kernelspec": { 568 | "display_name": "Python 3 (ipykernel)", 569 | "language": "python", 570 | "name": "python3" 571 | }, 572 | "language_info": { 573 | "codemirror_mode": { 574 | "name": "ipython", 575 | "version": 3 576 | }, 577 | "file_extension": ".py", 578 | "mimetype": "text/x-python", 579 | "name": "python", 580 | "nbconvert_exporter": "python", 581 | "pygments_lexer": "ipython3", 582 | "version": "3.8.10" 583 | } 584 | }, 585 | "nbformat": 4, 586 | "nbformat_minor": 4 587 | } 588 | -------------------------------------------------------------------------------- /step2_calculate_by_split.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "c6dca9d8-aabf-466e-ad35-31fec5211f7d", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "BENIGN.csv: 113065 行\n", 14 | "DrDoS_DNS.csv: 30618 行\n", 15 | "DrDoS_LDAP.csv: 14508 行\n", 16 | "DrDoS_MSSQL.csv: 18054 行\n", 17 | "DrDoS_NTP.csv: 129285 行\n", 18 | "DrDoS_NetBIOS.csv: 15363 行\n", 19 | "DrDoS_SNMP.csv: 13563 行\n", 20 | "DrDoS_UDP.csv: 19413 行\n", 21 | "LDAP.csv: 41801 行\n", 22 | "MSSQL.csv: 25280 行\n", 23 | "NetBIOS.csv: 16252 行\n", 24 | "Portmap.csv: 42606 行\n", 25 | "Syn.csv: 356496 行\n", 26 | "TFTP.csv: 227223 行\n", 27 | "UDP.csv: 33695 行\n", 28 | "UDP-lag.csv: 33294 行\n", 29 | "UDPLag.csv: 83 行\n", 30 | "WebDDoS.csv: 51 行\n" 31 | ] 32 | } 33 | ], 34 | "source": [ 35 | "import os\n", 36 | "import pandas as pd\n", 37 | "\n", 38 | "# 设置包含CSV文件的目录\n", 39 | "directory = 'class_split' # 替换为您的目录路径\n", 40 | "\n", 41 | "# 列出目录下所有的CSV文件\n", 42 | "csv_files = [f for f in os.listdir(directory) if f.endswith('.csv')]\n", 43 | "\n", 44 | "# 读取每个CSV文件并打印行数\n", 45 | "for csv_file in csv_files:\n", 46 | " file_path = os.path.join(directory, csv_file)\n", 47 | " try:\n", 48 | " # 读取CSV文件\n", 49 | " data = pd.read_csv(file_path)\n", 50 | " # 获取行数\n", 51 | " num_rows = len(data)\n", 52 | " print(f\"{csv_file}: {num_rows} 行\")\n", 53 | " except Exception as e:\n", 54 | " print(f\"无法读取 {csv_file}: {e}\")\n" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "id": "1b2fb846-4ca5-4593-a6e1-40bf82817d80", 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [] 64 | } 65 | ], 66 | "metadata": { 67 | "kernelspec": { 68 | "display_name": "Python 3 (ipykernel)", 69 | "language": "python", 70 | "name": "python3" 71 | }, 72 | "language_info": { 73 | "codemirror_mode": { 74 | "name": "ipython", 75 | "version": 3 76 | }, 77 | "file_extension": ".py", 78 | "mimetype": "text/x-python", 79 | "name": "python", 80 | "nbconvert_exporter": "python", 81 | "pygments_lexer": "ipython3", 82 | "version": "3.8.10" 83 | } 84 | }, 85 | "nbformat": 4, 86 | "nbformat_minor": 5 87 | } 88 | -------------------------------------------------------------------------------- /step4_concat_500_per_class.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "9b206acf-66c3-411a-8139-f34a29dcacb9", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "数据合并完成，已保存到combined_data.csv\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "import pandas as pd\n", 19 | "import os\n", 20 | "\n", 21 | "# 文件目录\n", 22 | "directory = './class_split/'\n", 23 | "\n", 24 | "# 文件列表\n", 25 | "files = [\n", 26 | " 'BENIGN.csv', 'DrDoS_DNS.csv', 'DrDoS_LDAP.csv', 'DrDoS_MSSQL.csv',\n", 27 | " 'DrDoS_NTP.csv', 'DrDoS_NetBIOS.csv', 'DrDoS_SNMP.csv', 'DrDoS_UDP.csv',\n", 28 | " 'LDAP.csv', 'MSSQL.csv', 'NetBIOS.csv', 'Portmap.csv',\n", 29 | " 'Syn.csv', 'TFTP.csv', 'UDP.csv', 'UDP-lag.csv'\n", 30 | "]\n", 31 | "\n", 32 | "# 创建空的DataFrame\n", 33 | "combined_data = pd.DataFrame()\n", 34 | "\n", 35 | "# 对每个文件进行处理\n", 36 | "for file in files:\n", 37 | " file_path = os.path.join(directory, file)\n", 38 | " # 加载数据\n", 39 | " data = pd.read_csv(file_path)\n", 40 | " # 随机选取500条数据\n", 41 | " sample_data = data.sample(n=500, random_state=1)\n", 42 | " # 将数据加入到总的DataFrame中\n", 43 | " combined_data = pd.concat([combined_data, sample_data], ignore_index=True)\n", 44 | "\n", 45 | "# 保存到新的CSV文件\n", 46 | "combined_data.to_csv('./combined_data.csv', index=False)\n", 47 | "\n", 48 | "print(\"数据合并完成，已保存到combined_data.csv\")\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "id": "d82fdf83-9cb3-4a8f-a781-ff46c41460d1", 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [] 58 | } 59 | ], 60 | "metadata": { 61 | "kernelspec": { 62 | "display_name": "Python 3 (ipykernel)", 63 | "language": "python", 64 | "name": "python3" 65 | }, 66 | "language_info": { 67 | "codemirror_mode": { 68 | "name": "ipython", 69 | "version": 3 70 | }, 71 | "file_extension": ".py", 72 | "mimetype": "text/x-python", 73 | "name": "python", 74 | "nbconvert_exporter": "python", 75 | "pygments_lexer": "ipython3", 76 | "version": "3.8.10" 77 | } 78 | }, 79 | "nbformat": 4, 80 | "nbformat_minor": 5 81 | } 82 | -------------------------------------------------------------------------------- /step5_meachineLearning.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 9, 6 | "id": "4f2dc226-adbc-411e-99c9-738112cb2d93", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "Looking in indexes: http://mirrors.aliyun.com/pypi/simple\n", 14 | "Collecting xgboost\n", 15 | " Downloading http://mirrors.aliyun.com/pypi/packages/c3/eb/496aa2f5d356af4185f770bc76055307f8d1870e11016b10fd779b21769c/xgboost-2.0.3-py3-none-manylinux2014_x86_64.whl (297.1 MB)\n", 16 | "\u001b[K |████████████████████████████████| 297.1 MB 357 kB/s eta 0:00:01 |███████████████████████████▎ | 253.5 MB 386 kB/s eta 0:01:53 |███████████████████████████▍ | 254.1 MB 290 kB/s eta 0:02:28 |████████████████████████████▉ | 267.7 MB 337 kB/s eta 0:01:28\n", 17 | "\u001b[?25hRequirement already satisfied: numpy in /root/miniconda3/lib/python3.8/site-packages (from xgboost) (1.21.4)\n", 18 | "Requirement already satisfied: scipy in /root/miniconda3/lib/python3.8/site-packages (from xgboost) (1.10.1)\n", 19 | "Installing collected packages: xgboost\n", 20 | "Successfully installed xgboost-2.0.3\n", 21 | "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n" 22 | ] 23 | } 24 | ], 25 | "source": [ 26 | "# !pip install xgboost" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 7, 32 | "id": "83f5001c-4f04-466b-b942-ef2d3800f8b5", 33 | "metadata": {}, 34 | "outputs": [ 35 | { 36 | "name": "stdout", 37 | "output_type": "stream", 38 | "text": [ 39 | "数据预处理完成，准备进行模型训练和测试。\n" 40 | ] 41 | } 42 | ], 43 | "source": [ 44 | "import pandas as pd\n", 45 | "from sklearn.preprocessing import StandardScaler, LabelEncoder\n", 46 | "from sklearn.model_selection import train_test_split\n", 47 | "import numpy as np\n", 48 | "\n", 49 | "# 加载数据\n", 50 | "data = pd.read_csv('./combined_data.csv')\n", 51 | "\n", 52 | "# 删除不需要的列，例如时间戳或IP地址（假设你的数据集中有这些列）\n", 53 | "data.drop([' Timestamp'], axis=1, inplace=True)\n", 54 | "\n", 55 | "# 类型转换，将分类标签编码\n", 56 | "label_encoder = LabelEncoder()\n", 57 | "data[' Label'] = label_encoder.fit_transform(data[' Label'])\n", 58 | "\n", 59 | "# 检查并处理无穷大和非常大的数值\n", 60 | "data.replace([np.inf, -np.inf], np.nan, inplace=True) # 将inf替换为NaN\n", 61 | "data.fillna(data.median(), inplace=True) # 使用中位数填充NaN，确保之前中位数计算不包括inf\n", 62 | "\n", 63 | "# 特征标准化\n", 64 | "scaler = StandardScaler()\n", 65 | "X = scaler.fit_transform(data.drop(' Label', axis=1)) # 确保标签列不参与标准化\n", 66 | "y = data[' Label']\n", 67 | "\n", 68 | "# 划分训练集和测试集\n", 69 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", 70 | "\n", 71 | "print(\"数据预处理完成，准备进行模型训练和测试。\")\n" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 12, 77 | "id": "c3cb72e1-33a8-4fa6-92ad-eed5ab041fe4", 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "name": "stdout", 82 | "output_type": "stream", 83 | "text": [ 84 | "Logistic Regression Accuracy: 54.96%\n", 85 | "Random Forest Accuracy: 62.04%\n", 86 | "SVM Accuracy: 50.17%\n", 87 | "XGBoost Accuracy: 62.75%\n", 88 | "\n", 89 | "Classification Report for XGBoost:\n", 90 | " precision recall f1-score support\n", 91 | "\n", 92 | " 0 0.99 0.99 0.99 170\n", 93 | " 1 0.50 0.42 0.45 143\n", 94 | " 2 0.31 0.25 0.28 174\n", 95 | " 3 0.56 0.52 0.54 159\n", 96 | " 4 0.99 0.99 0.99 145\n", 97 | " 5 0.45 0.42 0.43 146\n", 98 | " 6 0.60 0.65 0.63 148\n", 99 | " 7 0.46 0.55 0.50 121\n", 100 | " 8 0.36 0.46 0.40 144\n", 101 | " 9 0.54 0.56 0.55 156\n", 102 | " 10 0.38 0.40 0.39 154\n", 103 | " 11 0.40 0.44 0.42 146\n", 104 | " 12 0.99 0.98 0.99 150\n", 105 | " 13 1.00 0.97 0.99 158\n", 106 | " 14 0.51 0.49 0.50 130\n", 107 | " 15 0.92 0.90 0.91 156\n", 108 | "\n", 109 | " accuracy 0.63 2400\n", 110 | " macro avg 0.62 0.62 0.62 2400\n", 111 | "weighted avg 0.63 0.63 0.63 2400\n", 112 | "\n" 113 | ] 114 | } 115 | ], 116 | "source": [ 117 | "from sklearn.linear_model import LogisticRegression\n", 118 | "from sklearn.ensemble import RandomForestClassifier\n", 119 | "from sklearn.svm import SVC\n", 120 | "from xgboost import XGBClassifier\n", 121 | "from sklearn.metrics import accuracy_score, classification_report\n", 122 | "\n", 123 | "# 初始化模型\n", 124 | "logreg = LogisticRegression(max_iter=1000)\n", 125 | "rf = RandomForestClassifier(n_estimators=100)\n", 126 | "svm = SVC()\n", 127 | "xgb = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')\n", 128 | "\n", 129 | "# 训练逻辑回归模型\n", 130 | "logreg.fit(X_train, y_train)\n", 131 | "y_pred_logreg = logreg.predict(X_test)\n", 132 | "print(\"Logistic Regression Accuracy: {:.2f}%\".format(accuracy_score(y_test, y_pred_logreg) * 100))\n", 133 | "\n", 134 | "# 训练随机森林模型\n", 135 | "rf.fit(X_train, y_train)\n", 136 | "y_pred_rf = rf.predict(X_test)\n", 137 | "print(\"Random Forest Accuracy: {:.2f}%\".format(accuracy_score(y_test, y_pred_rf) * 100))\n", 138 | "\n", 139 | "# 训练支持向量机模型\n", 140 | "svm.fit(X_train, y_train)\n", 141 | "y_pred_svm = svm.predict(X_test)\n", 142 | "print(\"SVM Accuracy: {:.2f}%\".format(accuracy_score(y_test, y_pred_svm) * 100))\n", 143 | "\n", 144 | "# 训练XGBoost模型\n", 145 | "xgb.fit(X_train, y_train)\n", 146 | "y_pred_xgb = xgb.predict(X_test)\n", 147 | "print(\"XGBoost Accuracy: {:.2f}%\".format(accuracy_score(y_test, y_pred_xgb) * 100))\n", 148 | "\n", 149 | "# 打印分类报告（以XGBoost为例）\n", 150 | "print(\"\\nClassification Report for XGBoost:\")\n", 151 | "print(classification_report(y_test, y_pred_xgb))\n" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "id": "d4978d75-3b7d-49ca-93a1-7c84b1e99bc3", 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [] 161 | } 162 | ], 163 | "metadata": { 164 | "kernelspec": { 165 | "display_name": "Python 3 (ipykernel)", 166 | "language": "python", 167 | "name": "python3" 168 | }, 169 | "language_info": { 170 | "codemirror_mode": { 171 | "name": "ipython", 172 | "version": 3 173 | }, 174 | "file_extension": ".py", 175 | "mimetype": "text/x-python", 176 | "name": "python", 177 | "nbconvert_exporter": "python", 178 | "pygments_lexer": "ipython3", 179 | "version": "3.8.10" 180 | } 181 | }, 182 | "nbformat": 4, 183 | "nbformat_minor": 5 184 | } 185 | -------------------------------------------------------------------------------- /step5_meachineLearning_Linear.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "83f5001c-4f04-466b-b942-ef2d3800f8b5", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "数据预处理完成，准备进行模型训练和测试。\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "import pandas as pd\n", 19 | "from sklearn.preprocessing import StandardScaler, LabelEncoder\n", 20 | "from sklearn.model_selection import train_test_split\n", 21 | "import numpy as np\n", 22 | "\n", 23 | "# 加载数据\n", 24 | "data = pd.read_csv('./combined_data.csv')\n", 25 | "\n", 26 | "# 删除不需要的列，例如时间戳或IP地址（假设你的数据集中有这些列）\n", 27 | "data.drop([' Timestamp'], axis=1, inplace=True)\n", 28 | "\n", 29 | "# 类型转换，将分类标签编码\n", 30 | "label_encoder = LabelEncoder()\n", 31 | "data[' Label'] = label_encoder.fit_transform(data[' Label'])\n", 32 | "\n", 33 | "# 检查并处理无穷大和非常大的数值\n", 34 | "data.replace([np.inf, -np.inf], np.nan, inplace=True) # 将inf替换为NaN\n", 35 | "data.fillna(data.median(), inplace=True) # 使用中位数填充NaN，确保之前中位数计算不包括inf\n", 36 | "\n", 37 | "# 特征标准化\n", 38 | "scaler = StandardScaler()\n", 39 | "X = scaler.fit_transform(data.drop(' Label', axis=1)) # 确保标签列不参与标准化\n", 40 | "y = data[' Label']\n", 41 | "\n", 42 | "# 划分训练集和测试集\n", 43 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", 44 | "\n", 45 | "print(\"数据预处理完成，准备进行模型训练和测试。\")\n" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 4, 51 | "id": "ed08b466-38a2-4286-bac5-a14ba7d02440", 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "image/png": "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\n", 57 | "text/plain": [ 58 | "
" 59 | ] 60 | }, 61 | "metadata": { 62 | "needs_background": "light" 63 | }, 64 | "output_type": "display_data" 65 | } 66 | ], 67 | "source": [ 68 | "from sklearn.metrics import confusion_matrix\n", 69 | "import seaborn as sns\n", 70 | "from sklearn.linear_model import LogisticRegression\n", 71 | "from sklearn.ensemble import RandomForestClassifier\n", 72 | "from sklearn.svm import SVC\n", 73 | "from xgboost import XGBClassifier\n", 74 | "from sklearn.metrics import accuracy_score, classification_report\n", 75 | "import matplotlib.pyplot as plt\n", 76 | "\n", 77 | "# 初始化模型\n", 78 | "logreg = LogisticRegression(max_iter=1000)\n", 79 | "rf = RandomForestClassifier(n_estimators=100)\n", 80 | "svm = SVC()\n", 81 | "\n", 82 | "# 训练模型\n", 83 | "logreg.fit(X_train, y_train)\n", 84 | "rf.fit(X_train, y_train)\n", 85 | "svm.fit(X_train, y_train)\n", 86 | "\n", 87 | "# 预测结果\n", 88 | "y_pred_logreg = logreg.predict(X_test)\n", 89 | "y_pred_rf = rf.predict(X_test)\n", 90 | "y_pred_svm = svm.predict(X_test)\n", 91 | "\n", 92 | "# 混淆矩阵\n", 93 | "cm_logreg = confusion_matrix(y_test, y_pred_logreg)\n", 94 | "cm_rf = confusion_matrix(y_test, y_pred_rf)\n", 95 | "cm_svm = confusion_matrix(y_test, y_pred_svm)\n", 96 | "\n", 97 | "# 绘制混淆矩阵的热图\n", 98 | "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(18, 6))\n", 99 | "sns.heatmap(cm_logreg, annot=True, fmt=\"d\", ax=axes[0], cmap='Blues')\n", 100 | "axes[0].set_title('Logistic Regression Confusion Matrix')\n", 101 | "axes[0].set_xlabel('Predicted labels')\n", 102 | "axes[0].set_ylabel('True labels')\n", 103 | "\n", 104 | "sns.heatmap(cm_rf, annot=True, fmt=\"d\", ax=axes[1], cmap='Blues')\n", 105 | "axes[1].set_title('Random Forest Confusion Matrix')\n", 106 | "axes[1].set_xlabel('Predicted labels')\n", 107 | "axes[1].set_ylabel('True labels')\n", 108 | "\n", 109 | "sns.heatmap(cm_svm, annot=True, fmt=\"d\", ax=axes[2], cmap='Blues')\n", 110 | "axes[2].set_title('SVM Confusion Matrix')\n", 111 | "axes[2].set_xlabel('Predicted labels')\n", 112 | "axes[2].set_ylabel('True labels')\n", 113 | "\n", 114 | "plt.tight_layout()\n", 115 | "plt.savefig(\"confusion.png\")\n", 116 | "plt.show()\n" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "id": "7b50f7c2-f71d-4ae8-a5c7-4be8dc1d2c2e", 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [ 126 | "from sklearn.metrics import confusion_matrix\n", 127 | "import seaborn as sns\n", 128 | "\n", 129 | "# 初始化模型\n", 130 | "logreg = LogisticRegression(max_iter=1000)\n", 131 | "rf = RandomForestClassifier(n_estimators=100)\n", 132 | "svm = SVC()\n", 133 | "\n", 134 | "# 训练模型\n", 135 | "logreg.fit(X_train, y_train)\n", 136 | "rf.fit(X_train, y_train)\n", 137 | "svm.fit(X_train, y_train)\n", 138 | "\n", 139 | "# 预测结果\n", 140 | "y_pred_logreg = logreg.predict(X_test)\n", 141 | "y_pred_rf = rf.predict(X_test)\n", 142 | "y_pred_svm = svm.predict(X_test)\n", 143 | "\n", 144 | "# 混淆矩阵\n", 145 | "cm_logreg = confusion_matrix(y_test, y_pred_logreg)\n", 146 | "cm_rf = confusion_matrix(y_test, y_pred_rf)\n", 147 | "cm_svm = confusion_matrix(y_test, y_pred_svm)\n", 148 | "\n", 149 | "# 绘制混淆矩阵的热图\n", 150 | "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(18, 6))\n", 151 | "sns.heatmap(cm_logreg, annot=True, fmt=\"d\", ax=axes[0], cmap='Blues')\n", 152 | "axes[0].set_title('Logistic Regression Confusion Matrix')\n", 153 | "axes[0].set_xlabel('Predicted labels')\n", 154 | "axes[0].set_ylabel('True labels')\n", 155 | "\n", 156 | "sns.heatmap(cm_rf, annot=True, fmt=\"d\", ax=axes[1], cmap='Blues')\n", 157 | "axes[1].set_title('Random Forest Confusion Matrix')\n", 158 | "axes[1].set_xlabel('Predicted labels')\n", 159 | "axes[1].set_ylabel('True labels')\n", 160 | "\n", 161 | "sns.heatmap(cm_svm, annot=True, fmt=\"d\", ax=axes[2], cmap='Blues')\n", 162 | "axes[2].set_title('SVM Confusion Matrix')\n", 163 | "axes[2].set_xlabel('Predicted labels')\n", 164 | "axes[2].set_ylabel('True labels')\n", 165 | "\n", 166 | "plt.tight_layout()\n", 167 | "plt.show()\n" 168 | ] 169 | } 170 | ], 171 | "metadata": { 172 | "kernelspec": { 173 | "display_name": "Python 3 (ipykernel)", 174 | "language": "python", 175 | "name": "python3" 176 | }, 177 | "language_info": { 178 | "codemirror_mode": { 179 | "name": "ipython", 180 | "version": 3 181 | }, 182 | "file_extension": ".py", 183 | "mimetype": "text/x-python", 184 | "name": "python", 185 | "nbconvert_exporter": "python", 186 | "pygments_lexer": "ipython3", 187 | "version": "3.8.10" 188 | } 189 | }, 190 | "nbformat": 4, 191 | "nbformat_minor": 5 192 | } 193 | --------------------------------------------------------------------------------