加密流量分类torch实践2：CNN+LSTM模型训练与测试

已于 2023-10-31 15:27:26 修改
阅读量4.2k 收藏 65
点赞数 8
分类专栏： 加密流量分类 实验 文章标签： cnn 深度学习 分类
于 2023-03-09 16:28:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45125356/article/details/129425682
版权

加密流量分类torch实践2：CNN+LSTM模型训练与测试

1、原理

  • 一维卷积处理负载数据，处理流前n个包的前m个字节
  • Bi-LSTM处理包长序列，取流前seq_length的长度序列
  • 模型结构类似于APP-Net
  • 模型代码：
"""
cnn处理负载
lstm处理包长序列
"""

import torch
import torch.nn as nn


class Cnn_Lstm(nn.Module):
    def __init__(self,input_size, hidden_size, num_layers,bidirectional,num_classes=12):
        super(Cnn_Lstm, self).__init__()
        # rnn配置
        self.bidirectional = bidirectional
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,bidirectional=bidirectional,batch_first=True)
        self.fc0 = nn.Linear(hidden_size, num_classes)
        self.fc1= nn.Linear(hidden_size*2,num_classes)

        self.cnn_feature = nn.Sequential(
            # 卷积层1
            nn.Conv1d(kernel_size=25, in_channels=1, out_channels=32, stride=1, padding=12),  # (1,1024)->(32,1024)
            nn.BatchNorm1d(32),  # 加上BN的结果
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3, padding=1),  # (32,1024)->(32,342)

            # 卷积层2
            nn.Conv1d(kernel_size=25, in_channels=32, out_channels=64, stride=1, padding=12),  # (32,342)->(64,342)
            nn.BatchNorm1d(64),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3, padding=1),  # (64,342)->(64,114)
        )
        # 全连接层
        self.cnn_classifier = nn.Sequential(
            # 64*114
            nn.Flatten(),
            nn.Linear(in_features=64*114, out_features=1024), # 784:88*64, 1024:114*64, 4096:456*64
        )

        self.cnn=nn.Sequential(
            self.cnn_feature,
            self.cnn_classifier,
        )


        self.rnn = nn.Sequential(
            nn.LSTM(input_size, hidden_size, num_layers, bidirectional=bidirectional, batch_first=True),
        )
        self.classifier=nn.Sequential(
            nn.Linear(in_features=2048,out_features=num_classes),
            # nn.Dropout(p=0.7),
            # nn.Linear(in_features=1024,out_features=num_classes)
        )


    def forward(self, x_payload,x_sequence):
        x_payload=self.cnn(x_payload)
        x_sequence=self.rnn(x_sequence)
        x_sequence=x_sequence[0][:, -1, :]
        x=torch.cat((x_payload,x_sequence),1)
        x=self.classifier(x)
        return x


def cnn_rnn(model_path, pretrained=False, **kwargs):
    model = Cnn_Lstm(**kwargs)
    if pretrained:
        checkpoint = torch.load(model_path)
        model.load_state_dict(checkpoint['state_dict'])
    return model


# 仅仅是CNN
class Cnn(nn.Module):
    def __init__(self,input_size, hidden_size, num_layers,bidirectional,num_classes=12):
        super(Cnn, self).__init__()
        # rnn配置
        self.bidirectional = bidirectional
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,bidirectional=bidirectional,batch_first=True)
        self.fc0 = nn.Linear(hidden_size, num_classes)
        self.fc1= nn.Linear(hidden_size*2,num_classes)

        self.cnn_feature = nn.Sequential(
            # 卷积层1
            nn.Conv1d(kernel_size=25, in_channels=1, out_channels=32, stride=1, padding=12),  # (1,1024)->(32,1024)
            nn.BatchNorm1d(32),  # 加上BN的结果
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3, padding=1),  # (32,1024)->(32,342)

            # 卷积层2
            nn.Conv1d(kernel_size=25, in_channels=32, out_channels=64, stride=1, padding=12),  # (32,342)->(64,342)
            nn.BatchNorm1d(64),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3, padding=1),  # (64,342)->(64,114)
        )
        # 全连接层
        self.cnn_classifier = nn.Sequential(
            # 64*114
            nn.Flatten(),
            nn.Linear(in_features=64*114, out_features=1024), # 784:88*64, 1024:114*64, 4096:456*64
        )

        self.cnn=nn.Sequential(
            self.cnn_feature,
            self.cnn_classifier,
        )
        self.classifier=nn.Sequential(
            nn.Linear(in_features=1024,out_features=num_classes),
            # nn.Dropout(p=0.7),
            # nn.Linear(in_features=1024,out_features=num_classes)
        )


    def forward(self, x_payload,x_sequence):
        x_payload=self.cnn(x_payload)
        x=self.classifier(x_payload)
        return x_payload


def cnn(model_path, pretrained=False, **kwargs):
    model = Cnn(**kwargs)
    if pretrained:
        checkpoint = torch.load(model_path)
        model.load_state_dict(checkpoint['state_dict'])
    return model


class Lstm(nn.Module):
    def __init__(self,input_size, hidden_size, num_layers,bidirectional,num_classes=12):
        super(Lstm, self).__init__()
        # rnn配置
        self.bidirectional = bidirectional
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,bidirectional=bidirectional,batch_first=True)
        self.fc0 = nn.Linear(hidden_size, num_classes)
        self.fc1= nn.Linear(hidden_size*2,num_classes)

        self.rnn = nn.Sequential(
            nn.LSTM(input_size, hidden_size, num_layers, bidirectional=bidirectional, batch_first=True),
        )
        self.classifier=nn.Sequential(
            nn.Linear(in_features=1024,out_features=num_classes),
            # nn.Dropout(p=0.7),
            # nn.Linear(in_features=1024,out_features=num_classes)
        )


    def forward(self, x_payload,x_sequence):
        x_sequence=self.rnn(x_sequence)
        x_sequence=x_sequence[0][:, -1, :]
        x=self.classifier(x_sequence)
        return x


def rnn(model_path, pretrained=False, **kwargs):
    model = Lstm(**kwargs)
    if pretrained:
        checkpoint = torch.load(model_path)
        model.load_state_dict(checkpoint['state_dict'])
    return model

2、运行

  • 在自己的环境下修改路径，包括删除from sequence_payload.xx import xx下面的sequence_payload.
  • 修改配置文件entry下面的traffic_classification.yaml的路径，与模型参数，名字
    • 训练流程代码
from utils.helper import AverageMeter, accuracy
from TrafficLog.setLog import logger


def train_process(train_loader, model, criterion, optimizer, epoch, device, print_freq):
    """训练一个 epoch 的流程

    Args:
        train_loader (dataloader): [description]
        model ([type]): [description]
        criterion ([type]): [description]
        optimizer ([type]): [description]
        epoch (int): 当前所在的 epoch
        device (torch.device): 是否使用 gpu
        print_freq ([type]): [description]
    """
    losses = AverageMeter()  # 在一个 train loader 中的 loss 变化
    top1 = AverageMeter()  # 记录在一个 train loader 中的 accuracy 变化

    model.train()  # 切换为训练模型

    for i, (pcap, seq,target) in enumerate(train_loader):
        pcap = pcap.reshape(-1,1,1024)
        seq = seq.reshape(-1,64,1)
        pcap = pcap.to(device)
        seq = seq.to(device)
        target = target.to(device)

        output = model(pcap,seq)  # 得到模型预测结果
        loss = criterion(output, target)  # 计算 loss

        # 计算准确率, 记录 loss 和 accuracy
        # print(pcap.size(0))
        prec1 = accuracy(output.data, target)
        losses.update(loss.item(), pcap.size(0))
        top1.update(prec1[0].item(), pcap.size(0))

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % print_freq == 0:
            logger.info('Epoch: [{0}][{1}/{2}], Loss {loss.val:.4f} ({loss.avg:.4f}), Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
                epoch, i, len(train_loader), loss=losses, top1=top1))
    return losses.val,top1.val
  • 验证流程代码：

2.1 数据预处理

原理：

  • 使用flowcontainer包提取含有tcp或者udp负载的包，提取负载与ip数据包序列长度

    使用：

  • 将原始pcap文件放在traffic_data下

    • 格式:
      |---traffic_data
    |---bilibili
      |--- xx.pcap
      |--- xxx.pcap
    |---qq
      |--- xx.pcap
      |--- xxx.pcap
    |--- 今日头条
      |--- xx.pcap
      |--- xxx.pcap

  • 运行entry/preprocess.py,完成后复制控制台输出的__label2index__,粘贴到traffic_classification.yaml/test/traffic_classification.yaml

  • 得到处理好的 npy_data

2.2 训练

  • 打开entry/train.py，注释或者取消注释40、41、42行，选择cnn、lstm、cnn+lstm进行训练，记得改配置文件的model_name

  • 可以打开tensorboard查看loss与acc曲线

    • loss:
      在这里插入图片描述

    • acc:
      在这里插入图片描述

      两图为lstm处理序列数据的tensorboard示例

2.3 测试

  • 修改traffic_classification.yaml/test/evaluate为True，打开entry/train.py运行，得到评估结果
    /evaluate为True，打开entry/train.py``运行，得到评估结果
    在这里插入图片描述

代码参考：露露云的GitHub

烟玉蓝田
关注
  • 8
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 38
    评论
专栏目录
pytorch实现用CNN和LSTM对文本进行分类方式
01-21
model.py： #!/usr/bin/python # -*- coding: utf-8 -*- import torch from torch import nn import numpy as np from torch.autograd import Variable import torch.nn.functional as F class TextRNN(nn.Module): 文本分类，RNN模型 def __init__(self): super(TextRNN, self).__init__() # 三个待输入的数据 self
torch-metrics:pytorch中模型评估的指标
05-04
火炬指标 PyTorch的模型评估指标 火炬指标作为自定义库，以提供Pytorch共同ML评价指标，类似于tf.keras.metrics 。 如，Pytorch没有用于模型评估指标的内置库torch.metrics 。 这类似于的指标库。 用法 pip install --upgrade torch-metrics from torch_metrics import Accuracy ## define metric ## metric = Accuracy ( from_logits = False ) y_pred = torch . tensor ([ 1 , 2 , 3 , 4 ]) y_true = torch . tensor ([ 0 , 2 , 3 , 4 ]) print ( metric ( y_pred , y_true )) ## define metri
基于cnn和lstm的网络流量分类
2302_82079084的博客
12-22 951
最近做了一个基于cnn的网络流量分类系统，文章最后附有代码下载地址，以及数据集。基于cnn和lstm的网络流量分类。其他库版本无要求，安装最新版即可。测试代码test.py。界面代码main.py。
【论文阅读】An LSTM-Based Deep Learning Approach for Classifying Malicious Traffic at the Packet Level
airen的博客
05-04 1714
原文标题：An LSTM-Based Deep Learning Approach for Classifying Malicious Traffic at the Packet Level 原文作者：Ren-Hung Hwang * , Min-Chun Peng, Van-Linh Nguyen and Yu-Lun Chang 发表会议：IEEE ICASI 2019 原文链接：https://www.mdpi.com/2076-3417/9/16/3414 中文标题：一种基于LSTM的包级恶意流量.
基于贝叶斯优化CNN-LSTM混合神经网络预测（Matlab代码实现）
最新发布
qq_57231208的博客
04-18 278
然而，基于 BO 的超参数寻优的缺点可以归结为两类：训练时间和 BO 参数的调整。此外，BO 的核函数很难调整,最近的一项研究工作解决了这些问题，如标准化BO 参数。积核参数共享以及层间连接的稀疏性使得 CNN 能够以较小的计算量从高维数据中提取深层次局部特征，并通过卷积层和池化层获得有效的表示[34]。第2 次池化操作后，再利用全连接层将高维数据展平为 1 维数据，从而更加方便的对数据进行处理。而 GRU 则是在 LSTM 的基础上提出，其结 构更简单，参数更少，训练时间短，训练速度也比更快[37]。
CNN+LSTM 的模型结合（keras代码实现）
热门推荐
haosen
12-05 4万+
CNN-LSTM模型 运行环境：python3.6.5 、Keras2.1.5 、tensorflow 2.3.1等 from keras.preprocessing import sequence from keras.models import Sequential from keras.layers import Dense, Dropout, Activation from keras.layers import Embedding from keras.layers import LSTM.
CNN-LSTM-torch.zip
08-19
项目上传，压缩包里面包含数据以及对应的代码
CNN_BiLSTM_Attention模型，LSTM模型，DNN(全连接神经网络)三种模型对短期日负荷曲线的预测
04-13
CNN_BiLSTM_Attention模型，LSTM模型，DNN(全连接神经网络)三种模型对短期日负荷曲线的预测
【深度学习】——CNN结合LSTM模型
qq_48108092的博客
04-07 1万+
需要注意的是，CNN与LSTM结合的具体架构和超参数设置需要根据具体的数据和任务需求进行调整，以获得最佳的性能。这样，LSTM可以利用卷积层提取的空间特征，并结合序列数据的时序信息进行建模。池化层：在卷积层之后添加池化层，以降低特征图的维度，并保留重要的特征信息。通常情况下，序列数据可以表示为三维的张量，其中第一维表示样本数，第二维表示时间步，第三维表示特征数。模型评估：使用验证集或测试集对训练好的模型进行评估，可以使用各种评估指标如准确率、精确率、召回率、F1分数等来评估模型的性能。
神经网络的并行连接（CNN+LSTM）
CYK246的博客
04-20 7213
1. 数据集预处理 1. 加载csv文件 obj = pd.read_csv("文件路径", header=0) 2. 提取数据 data = np.asarray(obj.iloc[:, m:n+1]) # 数据集中在m~n列 3. 数据归一化 参考数据标准化处理 4. 数据输入格式基本处理 # 如将样本处理成三维数据，可利用reshape() data = data.reshape(.........
CNN+LSTM--一种运动想象分类新模型
脑机接口社区
01-08 7268
说到运动想象（motor imagenation, MI), 我们都很熟悉，它是指个体在心理上模拟给定动作时的动态状态。如何通过运动想象的脑电信号来分类个体的心理意图，一直是研究人员关注的重点，MI信号可以用于控制外部设备，如大脑控制的机器人、大脑控制的外骨骼、自动驾驶汽车等， 因此提高MI信号的分类准确性是极其有意义的。脑电图（EEG）的信噪比较低，因此如何从脑电图信号中提取特征并正确分类是BC...
TensorFlow搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）
KI的博客
08-30 1万+
TensorFlow搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）
基于torch实现cnn+lstm+attention 模型时间序列预测 代码模板 通用
04-17
基于torch实现cnn+lstm+attention 模型时间序列预测代码模板 通用
torch_ort:使用onnxruntime训练Pytorch模型
03-05
火炬手 使用onnxruntime训练Pytorch模型
基于CNN+LSTM时空神经网络的在线流量分类模型源码+全部数据+PDF文档.zip
01-12
基于CNN+LSTM时空神经网络的在线流量分类模型源码+全部数据+PDF文档.zip当时的题目为构建一个在线流量识分析与识别系统，能够实时识别出网络上的正常业务流量、恶意软件流量和网络攻击流量，并对各种流量随时序的变化进行进行可视化展示，我们采用CNN+LSTM时空神经网络，其中CNN对流量空间特征进行提取，LSTM对流量时序特征进行提取，从而完成不同种类流量分类功能。我们将思博伦官方给出的流量pcap包解析为流量的URL进行训练, 最终在官方给出的测试流量包上达到 93.5% 的准确率。 基于CNN+LSTM时空神经网络的在线流量分类模型源码+全部数据+PDF文档.zip当时的题目为构建一个在线流量识分析与识别系统，能够实时识别出网络上的正常业务流量、恶意软件流量和网络攻击流量，并对各种流量随时序的变化进行进行可视化展示，我们采用CNN+LSTM时空神经网络，其中CNN对流量空间特征进行提取，LSTM对流量时序特征进行提取，从而完成不同种类流量分类功能。我们将思博伦官方给出的流量pcap包解析为流量的URL进行训练, 最终在官方给出的测试流量包上达到 93.5% 的准确率。
基于Pytorch框架的CNN-LSTM模型在CWRU轴承故障诊断的应用
02-05
一个模型+主程序，然后里面还有CWRU轴承的数据，直接可以运行。 想修改模型可以在model.py里修改，这样就可以拿来自己搞点东西。
【网络流量识别】【深度学习】【三】CNN和LSTM—基于信息获取和深度学习的网络流量异常检测
杨的博客
10-01 1万+
本文是北京大学陆祥林等人，2019年四月发表于ICISDM的一篇文章，收录于ACM网站。 文章题目：基于信息获取和深度学习的网络流量异常检测 原文网址：基于信息获取和深度学习的网络流量异常检测|2019年第三届信息系统和数据挖掘国际会议纪要 (acm.org) 看文章前注意： 本文利用了IG信息增益将来自KDDCUP-99数据集的41个特征提取出28个作为神经网络的训练数据。然后使用CNN和LSTM构建神经网络对网络流量进行二分类。最后训练结果训练精度达到0.99，测试精度达到0.925。 .
LSTM与CNN结合：如何提升图像处理能力
禅与计算机程序设计艺术
12-31 1386
1.背景介绍 图像处理是人工智能领域的一个关键技术，它涉及到图像的获取、处理、分析和理解。随着数据量的增加和计算能力的提升，深度学习技术在图像处理领域取得了显著的进展。在这里，卷积神经网络(CNN)是一种非常有效的深度学习方法，它在图像识别、分类和检测等方面取得了显著的成果。然而，传统的CNN在处理长期依赖关系和时间序列数据方面存在一些局限性，这就是Long Short-Term Memory(...
使用pytorch构建三层一维CNN+LSTM+attention网络模型
03-26
以下是使用PyTorch构建3层1D CNN LSTM Attention网络模型的代码示例： ```python import torch.nn as nn import torch.nn.functional as F class CNN_LSTM_Attention(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim, num_layers, dropout_prob, kernel_size, stride): super(CNN_LSTM_Attention, self).__init__() self.input_dim = input_dim self.hidden_dim = hidden_dim self.output_dim = output_dim self.num_layers = num_layers self.dropout_prob = dropout_prob self.kernel_size = kernel_size self.stride = stride self.conv_layers = nn.ModuleList() self.conv_layers.append(nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, kernel_size=kernel_size, stride=stride)) self.conv_layers.append(nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=kernel_size, stride=stride)) self.conv_layers.append(nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=kernel_size, stride=stride)) self.lstm = nn.LSTM(hidden_dim, hidden_size=hidden_dim, num_layers=num_layers, bidirectional=True, batch_first=True, dropout=dropout_prob) self.attention_layer = nn.Linear(hidden_dim*2, 1, bias=False) self.output_layer = nn.Linear(hidden_dim*2, output_dim) def forward(self, x): batch_size, seq_len, num_channels = x.size() x = x.permute(0, 2, 1) for conv_layer in self.conv_layers: x = conv_layer(x) x = F.relu(x) x = F.max_pool1d(x, kernel_size=self.kernel_size, stride=self.stride) x = x.permute(0, 2, 1) # LSTM layer h_0 = torch.zeros(self.num_layers*2, batch_size, self.hidden_dim).to(device) c_0 = torch.zeros(self.num_layers*2, batch_size, self.hidden_dim).to(device) lstm_out, (h_n, c_n) = self.lstm(x, (h_0, c_0)) lstm_out = lstm_out.view(batch_size, seq_len, self.hidden_dim*2) # Attention layer attention_weights = F.softmax(self.attention_layer(lstm_out), dim=1) attention_weights = attention_weights.permute(0,2,1) attention_weights = F.dropout(attention_weights, p=self.dropout_prob, training=self.training) output = torch.bmm(attention_weights, lstm_out).squeeze() # Output layer output = self.output_layer(output) return output ``` 在上面的代码中，我们首先定义了类`CNN_LSTM_Attention`，它继承自PyTorch的`nn.Module`基类。该类的主要部分包括三层1D卷积层、一层双向LSTM层、一层Attention层和一层输出层。 在`__init__`函数中，我们定义了输入维度`input_dim`、隐藏维度`hidden_dim`、输出维度`output_dim`、层数`num_layers`、dropout概率`dropout_prob`、卷积核大小`kernel_size`和步长`stride`。我们使用`nn.ModuleList`来保存卷积层。 在`forward`函数中，我们首先对数据进行转置，以便将序列长度放在第二维，这将便于进行卷积操作。我们然后依次通过三层1D卷积层，每层都是一个卷积层，一个ReLU激活层和一个最大池化层。 接下来，我们将数据传递给双向LSTM层，这将返回一个输出张量和一个元组，其中包含LSTM层的最后一个状态和单元状态。我们将输出张量重塑为(batch_size, seq_len, hidden_dim*2)的形状。 在Attention层中，我们首先将LSTM层的输出传递给一个线性层，以产生注意力权重。将注意力权重限制为0到1之间，以便它们可以被解释为加权和。我们随机丢弃注意力权重中的一部分，以减少过拟合，然后将它们与LSTM层的输出相乘，以得到加权和。最后，我们将加权和传递给输出层来生成最终的预测。 通过使用此三层1D CNN LSTM Attention网络，我们可以实现一种有效的序列到序列的建模方法，并应用于多种语音识别、自然语言处理、视频分析等场景中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 38
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值