基于神经网络的攻击检测

神经网络算法概述

神经网络算法（Neural Network Algorithm）是一类模拟生物神经系统（尤其是大脑）信息处理方式的机器学习方法。它通过大量互联的"人工神经元"组成网络结构，在输入数据和最终输出之间建立非线性映射关系，从而能够自动学习、识别和预测复杂模式和规律。

一、基本概念

人工神经元（Neuron）：最小的计算单元。它接收多个输入信号，并根据各输入信号乘以相应"权重"（weight）后求和，再通过一个"激活函数"（activation function）输出结果。如图¹：

层（Layer）：由多个人工神经元组成。一般分为

• 输入层（Input Layer）：接收外部输入数据；
• 隐藏层（Hidden Layer）：进行特征提取与转换，可以有一个或多个；
• 输出层（Output Layer）：生成最终预测或分类结果。

二、网络结构

前馈神经网络(Feedforward Neural Network)是一种信息在网络中单向流动的神经网络模型，从输入层开始，经一个或多个隐藏层，最后到输出层，没有环路或循环。结构示例如下：

三、工作原理：前向传播与反向传播

1. 前向传播（Forward Propagation）

• 将输入数据逐层传递，计算每个神经元的加权和并通过激活函数，直到输出层生成预测值。

2. 损失计算（Loss Computation）

• 通过损失函数（如均方误差、交叉熵等）计算预测值与真实标签之间的差距。

3. 反向传播（Backpropagation）

• 利用梯度下降等优化算法，根据损失对各层权重进行微调，使网络输出逐渐逼近真实标签。

4. 迭代训练（Epochs）

• 重复以上过程多次，通过大规模数据训练，逐步收敛到较优的参数配置。

四、激活函数

在神经网络中，激活函数用于对每一层的线性输出进行非线性变换，使模型能够学习更复杂的函数表示。

下面是常见的几种激活函数。

1. Sigmoid 函数

公式：
$$\sigma (x)=\frac{1}{1+e^{-x}}$$
特性：

• 输出范围：$(0,1)$

• 光滑的“S”型曲线

• 常用于二分类的输出层

优点：

• 可解释为概率

缺点：

• 容易饱和：当 $x$ 太大或太小时，梯度几乎为 0，导致梯度消失。
• 输出非以 0 为中心

2. Tanh（双曲正切）：

公式：
$$\tanh (x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$$
特性：

• 输出范围：$(-1,1)$
• 也是“S”型曲线，但以 0 为中心

优点：

• 输出对称，更利于收敛

缺点：

• 仍然存在饱和区（梯度消失）

3. ReLU（Rectified Linear Unit,线性整流单元）：

公式：
$$\text{ReLU}(x)=\max (0,x)$$
特性：

• 输出范围：$[0,+\infty )$
• 在 $x>0$ 区域具有常数梯度

优点：

• 计算简单、收敛快
• 减少梯度消失问题

缺点：

• 死亡ReLU问题：如果神经元一直落在 $x<0$，它的梯度就永远为 0，不再更新

五、典型网络架构

• 多层感知机（MLP）：最基础的全连接前馈网络，用于一般分类与回归。
• 卷积神经网络（CNN）：擅长图像与空间数据处理，如图像分类、目标检测。
• 循环神经网络（RNN）及其变种（LSTM、GRU）：处理序列数据，如语音识别、自然语言处理。
• 生成对抗网络（GAN）：由生成器和判别器组成，用于图像生成、风格迁移等。
• 变分自编码器（VAE）：一种生成模型，用于数据压缩和生成。

六、应用场景

• 计算机视觉：图像分类、目标检测、图像分割。
• 自然语言处理：机器翻译、文本分类、问答系统。
• 语音识别与合成：语音转文字、语音合成。
• 推荐系统：用户行为建模与个性化推荐。
• 金融风控：欺诈检测、风险预测。

七、优缺点

优点

• 强大的非线性建模能力，能自动提取特征；
• 在大数据和高性能硬件支撑下，表现出色。

缺点

• 模型复杂、可解释性差；
• 需要大量标注数据和计算资源；
• 容易过拟合，需要正则化和大量调参。

示例1：hello world神经网络

代码参考²，以下实验使用的python的版本均为3.9.21。

# 导入所需的模块
from sklearn.neural_network import MLPClassifier

# 设置训练样本以及对应的标注
X_train = [[0., 0.], [1., 1.]]
y_train = [0, 1]

# 实例化多层神经网络模型
# 隐藏层有两层，分别包含 5 个和 2 个神经元
clf = MLPClassifier(
    solver='lbfgs',           # 使用 L-BFGS 优化算法
    alpha=1e-5,               # 正则化参数
    hidden_layer_sizes=(5, 2),  # 隐藏层结构
    random_state=1            # 固定随机种子以保证结果可复现
)

# 训练模型
clf.fit(X_train, y_train)

# 测试数据
X_test = [[2., 2.], [-1., -2.]]

# 预测结果
predictions = clf.predict(X_test)

# 输出预测结果
print("Predictions:", predictions)

输出结果如下：

示例2：使用神经网络算法识别验证码

import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.neural_network import MLPClassifier

mnist = fetch_openml('mnist_784', version=1)
# 重新调整数据，使用传统的训练/测试分割
X, y = mnist.data / 255., mnist.target  # 归一化处理
X_train, X_test = X[:60000], X[60000:] # 前60000个标签作为训练集，后10000个标签作为测试集
y_train, y_test = y[:60000], y[60000:]

mlp = MLPClassifier(
    hidden_layer_sizes=(50,),  # 隐藏层的神经元数量，这里设置为一层50个神经元
    max_iter=10,              # 最大迭代次数，即训练轮数，设置为10次
    alpha=1e-4,               # L2正则化参数，用于防止过拟合，值越小正则化越弱
    solver='sgd',             # 优化器类型，使用随机梯度下降（Stochastic Gradient Descent）
    verbose=10,              # 训练过程的详细程度，每10次迭代打印一次进度
    tol=1e-4,                # 收敛阈值，当损失函数变化小于这个值时认为收敛
    random_state=1,          # 随机种子，确保每次运行结果一致
    learning_rate_init=.1    # 初始学习率，控制权重更新的步长
)

mlp.fit(X_train, y_train)
print("Training set score: %f" % mlp.score(X_train, y_train))
print("Test set score: %f" % mlp.score(X_test, y_test))

fig, axes = plt.subplots(5, 10)
# 使用全局最小/最大来确保所有的权重都显示在相同的刻度上
vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()
for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):
    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin,
               vmax=.5 * vmax)
    ax.set_xticks(())
    ax.set_yticks(())

plt.show()

运行结果如下：

收敛警告：随机优化器在最大迭代次数（10次）内未收敛。

优化：

增大迭代次数为200，当迭代次数到55时训练数据集的准确率已经到1了。测试数据集的也高达0.973100。

可视化神经网络的权重矩阵。

1. 子图数量：
   • 5行10列共50个子图
   • 每个子图对应一个隐藏层神经元的权重向量
2. 每个子图的内容：
   • 每个28x28的矩阵显示一个隐藏层神经元与所有输入像素的连接权重
   • 灰度颜色表示权重的大小：
     • 较亮的颜色表示较大的正权重
     • 较暗的颜色表示较小的负权重
     • 中间灰色表示接近零的权重
3. 权重分布的含义：
   • 每个子图显示了神经网络学习到的特征检测器
   • 例如，某些子图可能突出显示边缘、角落或其他特定模式
   • 这些特征检测器是神经网络自动学习的，用于识别图像中的重要特征
     

示例3：使用神经网络算法检测Java溢出攻击

使用到ADFA-LD数据集，ADFA-LD数据集是澳大利亚国防学院对外发布的一套主机级入侵 检测系统的数据集合,被广泛应用于入侵检测类产品的测试。

原始代码

使用到的函数。

# -*- coding:utf-8 -*-

# 导入必要的库
import re
import matplotlib.pyplot as plt
import os
from sklearn.feature_extraction.text import CountVectorizer  # 用于文本特征提取
from sklearn import model_selection  # 用于交叉验证
import os

import numpy as np
from sklearn.neural_network import MLPClassifier  # 神经网络分类器


def load_one_flle(filename):
    """
    读取单个文件的内容
    Args:
        filename: 文件路径
    Returns:
        返回文件的第一行内容（去除换行符）
    """
    x=[]
    with open(filename) as f:
        line=f.readline()
        line=line.strip('\n')
    return line

def load_adfa_training_files(rootdir):
    """
    加载ADFA-LD数据集中的正常训练数据
    Args:
        rootdir: 训练数据根目录
    Returns:
        x: 特征数据列表
        y: 标签列表（正常数据标记为0）
    """
    x=[]
    y=[]
    list = os.listdir(rootdir)
    for i in range(0, len(list)):
        path = os.path.join(rootdir, list[i])
        if os.path.isfile(path):
            x.append(load_one_flle(path))
            print("Load file(%s)" % path)
            y.append(0)  # 正常数据标记为0
    return x,y

def dirlist(path, allfile):
    """
    递归获取目录下所有文件
    Args:
        path: 目录路径
        allfile: 存储所有文件路径的列表
    Returns:
        包含所有文件路径的列表
    """
    filelist = os.listdir(path)

    for filename in filelist:
        filepath = os.path.join(path, filename)
        if os.path.isdir(filepath):
            dirlist(filepath, allfile)
        else:
            allfile.append(filepath)
    return allfile

def load_adfa_java_files(rootdir):
    """
    加载ADFA-LD数据集中的Java Meterpreter攻击数据
    Args:
        rootdir: 攻击数据根目录
    Returns:
        x: 特征数据列表
        y: 标签列表（攻击数据标记为1）
    """
    x=[]
    y=[]
    allfile=dirlist(rootdir,[])
    for file in allfile:
        if re.match(r"./data/ADFA-LD/Attack_Data_Master/Java_Meterpreter_\d+/UAD-Java-Meterpreter*",file):
            print("Load file(%s)" % file)
            x.append(load_one_flle(file))
            y.append(1)  # 攻击数据标记为1
    return x,y

主函数

if __name__ == '__main__':
    # 加载正常训练数据和攻击数据
    x1,y1=load_adfa_training_files("./data/ADFA-LD/Training_Data_Master/")
    x2,y2=load_adfa_java_files("./data/ADFA-LD/Attack_Data_Master/")

    # 合并数据集
    x=x1+x2
    y=y1+y2

    # 使用CountVectorizer进行文本特征提取
    vectorizer = CountVectorizer(min_df=1)  # min_df=1表示词至少出现1次就被纳入特征
    x=vectorizer.fit_transform(x)
    x=x.toarray()  # 转换为数组形式

    # 创建神经网络分类器
    mlp = MLPClassifier(hidden_layer_sizes=(150,50),  # 两个隐藏层，分别有150和50个神经元
                        max_iter=10,                   # 最大迭代次数
                        alpha=1e-4,                    # L2正则化参数
                        solver='sgd',                  # 随机梯度下降优化器
                        verbose=10,                    # 打印训练过程
                        tol=1e-4,                     # 优化收敛容差
                        random_state=1,               # 随机种子
                        learning_rate_init=.1)        # 初始学习率

    # 使用10折交叉验证评估模型性能
    score=model_selection.cross_val_score(mlp, x, y, n_jobs=-1, cv=10)
    print(np.mean(score))  # 打印平均准确率

代码中

vectorizer = CountVectorizer(min_df=1)
x=vectorizer.fit_transform(x)
x=x.toarray()

这一段代码的作用是把原始的文本列表（每一条是一个“文档”）转换成数值化的特征向量，具体来说：

1. vectorizer = CountVectorizer(min_df=1)
   • CountVectorizer 是 sklearn 中用来做「词袋模型」的工具。
   • min_df=1 表示：只有那些在整个语料里至少出现过 1 次的词，才会被纳入到特征中。
   • 结果是，它会根据你提供的所有文本，自动建立一个「词表」（vocabulary），词表里的每个词就是一个特征维度。
2. x = vectorizer.fit_transform(x)
   • fit_transform 是两步合二为一：
     1. fit：扫描所有文本，学习出词表（即哪些词应该保留，以及它们在词表中的索引位置）；
     2. transform：把每个文本变成一个向量，向量长度等于词表大小，每个分量是该词在文档中出现的次数。
   • 返回值是一个 稀疏矩阵（scipy.sparse），因为绝大多数文档里只会出现词表中极少的一部分词，用稀疏存储能节省空间。
3. x = x.toarray() # 转换为数组形式
   • 这里把稀疏矩阵转换成一个标准的 NumPy 二维数组（ndarray）。
   • 好处是后续某些算法或函数可能不支持稀疏矩阵输入，或者你想要直接对矩阵做密集运算时更方便。
   • 坏处是，如果数据量很大，转成稠密数组会占用更多内存。

运行结果：

最后得出平均准确率为0.8746162280701754

收敛警告：随机优化器在最大迭代次数（10次）内未收敛。

优化代码

mlp = MLPClassifier(
    hidden_layer_sizes=(150,50),     # 神经网络结构：两个隐藏层，第一层150个神经元，第二层50个神经元
    max_iter=100,                    # 最大迭代次数：允许模型最多训练100轮
    alpha=1e-3,                      # L2正则化参数：用于防止过拟合，值越大正则化越强
    solver='adam',                   # 优化器：使用Adam优化算法，比SGD更稳定
    verbose=10,                      # 打印训练过程：每10轮打印一次训练信息
    tol=1e-3,                        # 收敛容差：当损失函数变化小于这个值时认为收敛
    random_state=1,                  # 随机种子：保证每次训练结果可复现
    learning_rate_init=0.01,         # 初始学习率：控制参数更新的步长
    batch_size=32,                   # 批量大小：每次训练使用的样本数
    early_stopping=True,             # 早停机制：当验证集性能不再提升时自动停止训练
)

运行结果：

最后得出平均准确率为0.9676315789473685

优化部分

• 最大迭代次数 (max_iter)
  原始设置：10
  现在设置：100
  优化效果：给模型更多机会收敛，避免过早停止训练

• 正则化强度 (alpha)
  原始设置：1e-4
  现在设置：1e-3
  优化效果：更强的正则化可以防止过拟合

• 优化器 (solver)
  原始设置：‘sgd’ (随机梯度下降)
  现在设置：‘adam’
  优化效果：Adam优化器通常比SGD更稳定，能更好地处理梯度

• 学习率 (learning_rate_init)
  原始设置：0.1
  现在设置：0.01

  优化效果：更小的学习率可以更稳定地收敛，避免梯度爆炸

• 批量大小 (batch_size)
  原始设置：未设置
  现在设置：32
  优化效果：使用小批量梯度下降，可以提高训练的稳定性和效率

• 早停机制 (early_stopping)
  原始设置：未设置
  现在设置：True
  优化效果：当验证集性能不再提升时自动停止训练，防止过拟合

• 收敛容差 (tol)
  原始设置：1e-4
  现在设置：1e-3
  优化效果：更宽松的收敛条件，允许模型在性能提升较小时继续训练

示例4：基于MLP的入侵检测

使用NSL-KDD数据集³。


采用了多层感知机（MLP）分类器进行攻击识别。以下是该段代码的执行流程总结：

一、数据读取和列命名

1. 定义列名：
   • 使用 col_names 列表为 NSL-KDD 数据集添加列名。
2. 读取训练集和测试集：
   • 使用 pd.read_csv() 分别加载训练集 (KDDTrain.csv) 和测试集 (KDDTest.csv)。
   • 打印训练集中标签 label 的分布情况。

二、类别特征分析

3. 识别类别型特征：

   • 遍历所有列，找出类型为 object（即字符串/类别）的列，这些列是需要编码处理的特征。
   • 输出每个类别特征的不同类别数量。
   • 特别查看了 service 列中出现频率最高的前几个类别。

4. 对测试集做同样检查：

   • 检查测试集中类别型特征的类别数是否一致。

三、类别特征编码与 One-Hot 编码

5. 提取类别特征：

   • 提取三个类别特征：protocol_type, service, flag。

6. Label Encoding（标签编码）：

   • 对训练集和测试集分别使用 LabelEncoder 将类别字符串转换为整数。

7. One-Hot Encoding（独热编码）：

   • 使用 OneHotEncoder 对已编码的数值进行One-Hot编码，生成新的二进制特征列。
   • 对测试集中缺失的某些类别列进行补零处理，确保与训练集维度一致。

8. 合并编码后的特征到原始 DataFrame：

   • 将新生成的 One-Hot 编码特征合并回原数据集。
   • 删除原始的类别特征列（如 protocol_type, service, flag）以避免重复。

四、标签编码（Label Transformation）

9. 将文本标签映射为数值标签：

   • 将原始文本类型的 label 转换为数值，分为五类：
     • 正常（normal）: 0
     • DoS 攻击（如 neptune, back 等）: 1
     • 探测攻击（如 ipsweep, nmap 等）: 2
     • 远程到本地攻击（R2L，如 ftp_write, guess_passwd 等）: 3
     • 用户到超级用户攻击（U2R，如 buffer_overflow, perl 等）: 4

10. 创建二分类目标变量：

    • 新增一个 class 列，表示是否为攻击：
      • normal: 0
      • 其他攻击类型: 1

五、特征选择与归一化

11. 划分训练集和测试集特征与标签：

    • 特征 x: 训练集所有非目标列
    • 标签 y: class 列
    • 同样处理测试集得到 xtest 和 ytest

12. 检查特征数量一致性：

    • 确保训练集和测试集的特征维度一致。

13. 特征标准化（归一化）：

    • 使用 StandardScaler 对特征进行标准化处理，使特征值分布在均值为0、方差为1的范围内。

六、模型训练与评估

14. 构建 MLPClassifier 模型：

    • 隐藏层：100个神经元的单个隐藏层
    • 设置参数包括优化器（solver）：adam
    • 初始学习率（learning_rate_init）:0.005
    • 激活函数：relu（Rectified Linear Unit, 线性整流单元）一种常用的激活函数，定义为 f(x) = max(0, x)，它有助于缓解梯度消失问题，并允许构建更深层次的网络。
    • 最大迭代次数：2000
    • random_state 参数用于控制随机数生成器的种子值。设置此参数可确保结果的可重复性，即使用相同的种子值，在相同条件下运行算法会得到同样的结果。
      

15. 训练模型：

    • 使用 mlp.fit(x, y) 在训练集上训练模型。

16. 评估模型性能：

    • 使用 mlp.score(xtest, ytest) 计算模型在测试集上的准确率。

---

总结图示

数据读取 → 类别特征识别 → Label Encoding → One-Hot Encoding → 标签映射 → 特征归一化 → MLP训练 → 测试集评估

运行的结果为：

精准度为：0.9535131298793471

完整的代码如下：

import pandas as pd
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
from sklearn.preprocessing import MinMaxScaler
from sklearn import preprocessing
from sklearn.neural_network import MLPClassifier

# 添加列的名称并读取KDDTrain和KDDTest数据集
col_names = ["duration","protocol_type","service","flag","src_bytes",
    "dst_bytes","land","wrong_fragment","urgent","hot","num_failed_logins",
    "logged_in","num_compromised","root_shell","su_attempted","num_root",
    "num_file_creations","num_shells","num_access_files","num_outbound_cmds",
    "is_host_login","is_guest_login","count","srv_count","serror_rate",
    "srv_serror_rate","rerror_rate","srv_rerror_rate","same_srv_rate",
    "diff_srv_rate","srv_diff_host_rate","dst_host_count","dst_host_srv_count",
    "dst_host_same_srv_rate","dst_host_diff_srv_rate","dst_host_same_src_port_rate",
    "dst_host_srv_diff_host_rate","dst_host_serror_rate","dst_host_srv_serror_rate",
    "dst_host_rerror_rate","dst_host_srv_rerror_rate","label"]

# 训练集
df = pd.read_csv("Deep-learning-for-intrusion-detection-using-Recurrent-Neural-network-RNN-main/NSL_KDD_Train.csv",header=None, names = col_names)
# 测试集
df_test = pd.read_csv("Deep-learning-for-intrusion-detection-using-Recurrent-Neural-network-RNN-main/NSL_KDD_Test.csv", header=None, names = col_names)

print(df['label'].value_counts())

# 列是分类的，还不是二进制的：协议类型（第2列）、服务（第3列）、标志（第4列）。
# 数据预处理
for col_name in df.columns:
    if df[col_name].dtypes == 'object' :
        unique_cat = len(df[col_name].unique())
        print("Feature '{col_name}' has {unique_cat} categories".format(col_name=col_name, unique_cat=unique_cat))

print(df['service'].value_counts().sort_values(ascending=False).head())

#测试集
# Test set
print('Test set:')
for col_name in df_test.columns:
    if df_test[col_name].dtypes == 'object' :
        unique_cat = len(df_test[col_name].unique())
        print("Feature '{col_name}' has {unique_cat} categories".format(col_name=col_name, unique_cat=unique_cat))


# 将类别型特征插入到一个二维的 NumPy 数组中
categorical_columns=['protocol_type', 'service', 'flag']

df_categorical_values = df[categorical_columns]
testdf_categorical_values = df_test[categorical_columns]

df_categorical_values.head()

# protocol type
unique_protocol=sorted(df.protocol_type.unique())
string1 = 'Protocol_type_'
unique_protocol2=[string1 + x for x in unique_protocol]
print(unique_protocol2)

# service
unique_service=sorted(df.service.unique())
string2 = 'service_'
unique_service2=[string2 + x for x in unique_service]
print(unique_service2)

# flag
unique_flag=sorted(df.flag.unique())
string3 = 'flag_'
unique_flag2=[string3 + x for x in unique_flag]
print(unique_flag2)

# put together
dumcols=unique_protocol2 + unique_service2 + unique_flag2

#do it for test set
unique_service_test=sorted(df_test.service.unique())
unique_service2_test=[string2 + x for x in unique_service_test]
testdumcols=unique_protocol2 + unique_service2_test + unique_flag

# 使用 LabelEncoder() 将类别型特征转换为数值
# train set
df_categorical_values_enc=df_categorical_values.apply(LabelEncoder().fit_transform)
print(df_categorical_values.head())
print('--------------------')
print(df_categorical_values_enc.head())
# test set
testdf_categorical_values_enc=testdf_categorical_values.apply(LabelEncoder().fit_transform)

# One-Hot-Encoding
# train set
enc = OneHotEncoder(categories='auto')
df_categorical_values_encenc = enc.fit_transform(df_categorical_values_enc)
df_cat_data = pd.DataFrame(df_categorical_values_encenc.toarray(),columns=dumcols)
# test set
testdf_categorical_values_encenc = enc.fit_transform(testdf_categorical_values_enc)
testdf_cat_data = pd.DataFrame(testdf_categorical_values_encenc.toarray(),columns=testdumcols)

# 添加测试集中缺失的列
trainservice=df['service'].tolist()
testservice= df_test['service'].tolist()
difference=list(set(trainservice) - set(testservice))
string = 'service_'
difference=[string + x for x in difference]

for col in difference:
    testdf_cat_data[col] = 0

print(df_cat_data.shape)    
print(testdf_cat_data.shape)

# 新的数字列被添加到主数据框架中

newdf=df.join(df_cat_data)
newdf.drop('flag', axis=1, inplace=True)
newdf.drop('protocol_type', axis=1, inplace=True)
newdf.drop('service', axis=1, inplace=True)

# test data
newdf_test=df_test.join(testdf_cat_data)
newdf_test.drop('flag', axis=1, inplace=True)
newdf_test.drop('protocol_type', axis=1, inplace=True)
newdf_test.drop('service', axis=1, inplace=True)

print(newdf.shape)
print(newdf_test.shape)

# 将“label”分类值转换为数值

labeldf=newdf['label']
labeldf_test=newdf_test['label']

# 更改标签列
newlabeldf=labeldf.replace({ 'normal' : 0, 'neptune' : 1 ,'back': 1, 'land': 1, 'pod': 1, 'smurf': 1, 'teardrop': 1,'mailbomb': 1, 'apache2': 1, 'processtable': 1, 'udpstorm': 1, 'worm': 1,
                           'ipsweep' : 2,'nmap' : 2,'portsweep' : 2,'satan' : 2,'mscan' : 2,'saint' : 2
                           ,'ftp_write': 3,'guess_passwd': 3,'imap': 3,'multihop': 3,'phf': 3,'spy': 3,'warezclient': 3,'warezmaster': 3,'sendmail': 3,'named': 3,'snmpgetattack': 3,'snmpguess': 3,'xlock': 3,'xsnoop': 3,'httptunnel': 3,
                           'buffer_overflow': 4,'loadmodule': 4,'perl': 4,'rootkit': 4,'ps': 4,'sqlattack': 4,'xterm': 4})
newlabeldf_test=labeldf_test.replace({ 'normal' : 0, 'neptune' : 1 ,'back': 1, 'land': 1, 'pod': 1, 'smurf': 1, 'teardrop': 1,'mailbomb': 1, 'apache2': 1, 'processtable': 1, 'udpstorm': 1, 'worm': 1,
                           'ipsweep' : 2,'nmap' : 2,'portsweep' : 2,'satan' : 2,'mscan' : 2,'saint' : 2
                           ,'ftp_write': 3,'guess_passwd': 3,'imap': 3,'multihop': 3,'phf': 3,'spy': 3,'warezclient': 3,'warezmaster': 3,'sendmail': 3,'named': 3,'snmpgetattack': 3,'snmpguess': 3,'xlock': 3,'xsnoop': 3,'httptunnel': 3,
                           'buffer_overflow': 4,'loadmodule': 4,'perl': 4,'rootkit': 4,'ps': 4,'sqlattack': 4,'xterm': 4})

# 将新标签列放回原处
newdf['label'] = newlabeldf
newdf_test['label'] = newlabeldf_test

# 将“label”转换为KDDTrain的normal=0和attack=1
newdf['class']=newdf['label'].apply(lambda x: 1 if x>=1 else 0)
newdf.drop(['label'], axis=1)

# 将“label”转换为KDDTest的normal=0和attack=1
newdf_test['class']=newdf_test['label'].apply(lambda x: 1 if x>=1 else 0)
newdf_test.drop(['label'], axis=1)

# 分割训练集和测试集
x=newdf.drop('class',axis=1) #X-train
y=newdf["class"] #y-Train
xtest=newdf_test.drop("class",axis=1) #X-test
ytest=newdf_test['class'] # y-test

# 检查特征数量是否一致
print(f"训练集特征数量: {x.shape[1]}")
print(f"测试集特征数量: {xtest.shape[1]}")

# 步骤2：将每个特征的值线性映射到[0,1]范围
# Training Set
scale = MinMaxScaler()
scale= preprocessing.StandardScaler().fit(x)
x=scale.transform(x)
scaletest= preprocessing.StandardScaler().fit(xtest)
xtest=scaletest.transform(xtest)


mlp = MLPClassifier(
    hidden_layer_sizes=(100,),
    solver='adam',
    learning_rate_init = 0.005,
    learning_rate = 'adaptive',
    activation="relu",
    max_iter=2000,
    random_state=42
    )
mlp.fit(x,y)
accuracy = mlp.score(xtest, ytest)
print("MLP的精准度为:",accuracy)

参考

---

1. https://blog.csdn.net/weixin_39910711/article/details/100775918?fromshare=blogdetail&sharetype=blogdetail&sharerId=100775918&sharerefer=PC&sharesource=m0_52754338&sharefrom=from_link ↩︎

2. https://github.com/duoergun0729/1book ↩︎

3. https://github.com/Ahamasaleh/Deep-learning-for-intrusion-detection-using-Recurrent-Neural-network-RNN/ ↩︎