2022.11.20 第三十一次周报

目录

前言

文献阅读

题目

作者

背景

存在的问题

提出的方案

主要贡献

实验评估

RNN-循环神经网络

RNN定义

RNN结构

 RNN前向传播

代码-RNN框架实现

总结

---

前言

This week read a paper on a secure intelligent fuzzy blockchain framework based on blockchain.The framework is designed with blockchain security support and fuzzy logic to track and trace IoT device transactions and perform threat detection in IoT networks.On deep learning, RNN models were learned, and simple codes were reproduced.

本周阅读了一篇基于区块链的一个安全智能模糊区块链框架的论文。该框架设计有区块链安全支持和模糊逻辑，以跟踪和追踪物联网设备交易，并在物联网网络中执行威胁检测。在深度学习上，学习了RNN模型，以及复现简单的代码。

文献阅读

--Abbas Yazdinejad, Ali Dehghantanha, Reza M. Parizi, Gautam Srivastava, Hadis Karimipour,
Secure Intelligent Fuzzy Blockchain Framework: Effective Threat Detection in IoT Networks,
Computers in Industry,
Volume 144,
2023,
103801,
ISSN 0166-3615,
https://doi.org/10.1016/j.compind.2022.103801.
Keywords: Threat detection; Fuzzy blockchain; IoT; Fuzzy DNN; ANFIS; Fuzzy matching

题目

安全智能模糊区块链框架：物联网网络中的有效威胁检测

作者

Abbas Yazdinejad, Ali Dehghantanha, Reza M. Parizi, Gautam Srivastava, Hadis Karimipour,

背景

将区块链集成到物联网（IoT）中以确保安全是计算通信系统的新发展。虽然安全威胁正在改变他们的策略，并在基于区块链的物联网系统上构建新的威胁。此外，在将区块链与物联网网络相结合时，恶意交易和主动攻击会带来更多的漏洞、隐私问题和安全威胁。基于区块链的物联网攻击的概念是物联网和区块链学科的热门话题。网络攻击是一种安全和隐私威胁，涵盖了与物联网和区块链组合相关的威胁的确切范围。尽管区块链具有潜在的安全优势，但新的网络攻击已经出现，使得区块链本身不足以应对物联网网络中的威胁和攻击，因为物联网数据中不可避免地存在模糊和歧义问题。物联网源的异构性使不确定性成为物联网网络中的一个关键问题。深度学习（DL）模型难以处理不确定性问题，并且无法将其作为安全技术中的基本工具进行有效管理。因此，我们需要更好的安全性、隐私性和实用方法，例如在基于区块链的物联网环境中针对网络攻击进行有效的威胁检测。当DL模型面临不确定性时，考虑模糊逻辑以解决确定性问题也有助于考虑模糊逻辑。

存在的问题

目前，由于安全威胁、恶意攻击和犯罪活动不断增加，调查网络攻击已成为一个关键问题，尤其是在物联网环境中。物联网安全是一个持续关注的问题，因为物联网网络和应用程序为黑客留下了充足的空间。在金融任务、智能家居和智能汽车应用中考虑物联网网络时，这种安全性的缺乏可能是一个真正的问题。

提出的方案

我们提出的框架在支持区块链的物联网环境中的网络攻击中创建有效的威胁检测。物联网系统容易受到各种网络攻击，其中对物联网系统的常见攻击是在网络层，例如拒绝服务 （DoS） 和远程到本地 （R2L）。此外，网络钓鱼攻击以及异常和欺诈易在区块链中很常见，威胁到用户的隐私。这些威胁促使我们在基于区块链的物联网系统中选择网络攻击。如图所示，所提出的框架概述包括三个主要层：物联网层、智能模糊层和区块链层。为了展示所提出的框架概述的简单摘要，我们将其分为3层。因此，该框架设计有区块链安全支持和模糊逻辑，以跟踪和追踪物联网设备交易，并在物联网网络中执行威胁检测。在工作流程中，区块链已经集成到物联网层中，而模糊层在该层，集成区块链和物联网方面具有控制平面作用。除了提供更高的安全性外，此功能还将提高区块链层在延迟和吞吐量方面的效率。如图所示，所有这些层相互作用，为支持区块链的物联网网络提供安全通信并检测安全威胁。物联网层包括所有在区块链环境中相互连接和通信的智能设备和硬件设备，如无人机、手机、传感器和执行器。区块链层处理物联网设备管理、云存储和基于区块链的安全模块。区块链为物联网设备之间的数据和交易传输提供了安全的通道。所提出的框架中最重要和可操作的层是智能模糊层，这是我们在本文中的主要讨论。该层具有一些组件来解决安全问题，检测流程和区块链层的效率。

​

主要贡献

安全智能模糊区块链框架的设计与实现。该框架在智能模糊层应用威胁检测（TD）、ANFIS、模糊控制系统（FCS）和模糊匹配（FM）模块，以监控物联网设备、活动以及与物联网和区块链层连接过程中的实时处理，以检测安全和隐私威胁。

在所提出的框架中提出了一种用于威胁检测的新型模糊DL模型。该模糊DL模型由模糊层、神经表示层、模糊层和模糊Choquet积分组成，具有强大的非线性聚合功能来检测威胁。

为物联网网络设计优化的基于ANFIS的攻击检测系统。我们在设计中使用元启发式算法，如遗传算法（GA），差分进化（DE）和粒子群优化（PSO），而不是经典的ANFIS训练算法。

使用FM方法验证交易以获得所提出的框架中的欺诈检测功能。

在利用模糊逻辑原理的力量的拟议框架中提供FCS。FCS基于安全威胁级别（低，中，高），可以在威胁检测中有效地呈现我们的系统。

实验评估

在本节中，我们将我们的FCS评估为所提出的框架中模糊智能层的关键元素，这是一个非线性控制器。FCS 考虑在复杂安全状态下要处理的其他组件的情况。为了在检测过程中评估我们的食品接触物质，它应该了解基于 TD、ANFIS 和 FM 组件的威胁检测和安全级别。图12显示了基于模糊层中组件的 FCS 的域和隶属函数。三角隶属函数将清晰的输入转换为模糊推理系统。

 

在考虑了我们的规则并将其应用于 FCS 之后，隶属函数的输出如图13 所示。必须合并每个输出的活动成员身份。如上所述满足上述方面以实现聚合。聚合是使用 max 运算符执行的。在这种情况下，累积意味着将多个元素组合成一个集群，在这里，多个成员输出组合成一组输出。进行聚合以收集所有可能的输出并使用媒介获得结果。

 

最后，我们从隶属函数的模糊世界中回到清晰的逻辑，以获得有意义的结果。基于模糊规则，如果TD = 9.8（高），ANFIS = 7.8，FM = 6.5（低），则安全威胁级别结果将为79%，图14说明了所提出的框架中的有效威胁检测。

 

为了证明我们的FCS工作正常，并且我们的设计是正确的，我们绘制了FCS的3D表面，如图15所示，它显示了所有输入和输出，更光滑的表面证明我们有一个好的设计（稳定）来考虑检测过程。设计的平滑模糊模型为模型提供了足够的稳定性条件。此外，这个问题已被证明，与非平滑模型相比，更平滑的模糊设计对恢复稳定的噪声和干扰具有更高的容忍度。

 

RNN-循环神经网络

RNN定义

循环神经网络（Recurrent Neural Network, RNN）是一类以序列（sequence）数据为输入，在序列的演进方向进行递归（recursion）且所有节点（循环单元）按链式连接的递归神经网络（recursive neural network） 。

对循环神经网络的研究始于二十世纪80-90年代，并在二十一世纪初发展为深度学习（deep learning）算法之一   ，其中双向循环神经网络（Bidirectional RNN, Bi-RNN）和长短期记忆网络（Long Short-Term Memory networks，LSTM）是常见的循环神经网络  。

循环神经网络具有记忆性、参数共享并且图灵完备（Turing completeness），因此在对序列的非线性特征进行学习时具有一定优势。循环神经网络在自然语言处理（Natural Language Processing, NLP），例如语音识别、语言建模、机器翻译等领域有应用，也被用于各类时间序列预报。引入了卷积神经网络（Convolutional Neural Network,CNN）构筑的循环神经网络可以处理包含序列输入的计算机视觉问题。

RNN结构

我们可以看到RNN层级结构较之于CNN来说比较简单, 它主要有输入层,Hidden Layer, 输出层组成。并且会发现在Hidden Layer 有一个箭头表示数据的循环更新, 这个就是实现时间记忆功能的方法。

 RNN前向传播

如下图所示为Hidden Layer的层级展开图. t-1, t, t+1表示时间序列。 X表示输入的样本.。St表示样本在时间t处的的记忆,St = f(W*St-1 +U*Xt)。 W表示输入的权重, U表示此刻输入的样本的权重, V表示输出的样本权重。

 

  在t =1时刻, 一般初始化输入S0=0, 随机初始化W,U,V, 进行下面的公式计算:

                                                    

 

    其中,f和g均为激活函数.。其中f可以是tanh,relu,sigmoid等激活函数，g通常是softmax也可以是其他。

    时间就向前推进，此时的状态s1作为时刻1的记忆状态将参与下一个时刻的预测活动，也就是:

                                                                          

 

    以此类推, 可以得到最终的输出值为:

                                                                          

 

    注意: 1. 这里的W,U,V在每个时刻都是相等的(权重共享)。

             2. 隐藏状态可以理解为:  S=f(现有的输入+过去记忆总结) 。

代码-RNN框架实现

import torch
from torch import nn
from torch.nn import functional as F
from torch.nn.parameter import Parameter


#
class Simple_RNN_Cell(nn.Module):
    def __init__(self, token_dim, hidden_dim
                 , activation=nn.Tanh()
                 , use_bias=True
                 , kernel_initializer=nn.init.xavier_uniform_
                 , recurrent_initializer=nn.init.orthogonal_
                 , bias_initializer=nn.init.zeros_
                 , device="cpu"):
        super().__init__()
        # 超参定义
        self.hidden_dim = hidden_dim
        self.device = device
        self.kernel_initializer = kernel_initializer
        self.recurrent_initializer = recurrent_initializer
        self.bias_initializer = bias_initializer
        #
        self.Hidden = nn.Linear(token_dim, hidden_dim, bias=use_bias).to(self.device)
        self.RecurHidden = nn.Linear(hidden_dim, hidden_dim, bias=use_bias).to(self.device)
        self.Activation = activation.to(self.device)
        # 参数初始化
        self.kernel_initializer(self.Hidden.weight)
        self.recurrent_initializer(self.RecurHidden.weight)
        self.bias_initializer(self.Hidden.bias), self.bias_initializer(self.RecurHidden.bias)

    def forward(self, inputs, last_state: list):
        hidden = self.Hidden(inputs)
        recur_hidden = self.RecurHidden(last_state[-1])
        hidden = self.Activation(
           hidden + recur_hidden
        )
        return [hidden]

    def zero_initialization(self, batch_size):
        return [torch.zeros([batch_size, self.hidden_dim]).to(self.device)]


#
class RNN_Layer(nn.Module):
    """
    bidirectional:  If ``True``, becomes a bidirectional RNN network. Default: ``False``.
    padding:        String, 'pre' or 'post' (optional, defaults to 'pre'): pad either before or after each sequence.
    """
    def __init__(self, rnn_cell, bidirectional=False, pad_position='post'):
        super().__init__()
        self.RNNCell = rnn_cell
        self.bidirectional = bidirectional
        self.padding = pad_position

    def forward(self, inputs, mask=None, initial_state=None):
        """
        inputs:   it's shape is [batch_size, time_steps, token_dim]
        mask:     it's shape is [batch_size, time_steps]
        :return
        sequence:    it is hidden state sequence, and its' shape is [batch_size, time_steps, hidden_dim]
        last_state: it is the hidden state of input sequences at last time step,
                    but, attentively, the last token wouble be a padding token,
                    so this last state is not the real last state of input sequences;
                    if you want to get the real last state of input sequences, please use utils.get_rnn_last_state(hidden state sequence).
        """
        batch_size, time_steps, token_dim = inputs.shape
        #
        if initial_state is None:
            initial_state = self.RNNCell.zero_initialization(batch_size)
        if mask is None:
            if batch_size == 1:
                mask = torch.ones([1, time_steps]).to(inputs.device.type)
            elif self.padding == 'pre':
                raise ValueError('请给定掩码矩阵(mask)')
            elif self.padding == 'post' and self.bidirectional is True:
                raise ValueError('请给定掩码矩阵(mask)')

        # 正向时间步循环
        hidden_list = []
        hidden_state = initial_state
        last_state = None
        for i in range(time_steps):
            hidden_state = self.RNNCell(inputs[:, i], hidden_state)
            hidden_list.append(hidden_state[-1])
            if i == time_steps - 1:
                """获取最后一时间步的输出隐藏状态"""
                last_state = hidden_state
            if self.padding == 'pre':
                """如果padding值填充在序列尾端，则正向时间步传播应加 mask 操作"""
                hidden_state = [
                    hidden_state[j] * mask[:, i:i + 1] + initial_state[j] * (1 - mask[:, i:i + 1])  # 重新初始化（加数项作用）
                    for j in range(len(hidden_state))
                ]
        sequence = torch.reshape(
            torch.unsqueeze(
                torch.concat(hidden_list, dim=1)
                , dim=1)
            , [batch_size, time_steps, -1]
        )

        # 反向时间步循环
        if self.bidirectional is True:
            hidden_list = []
            hidden_state = initial_state
            for i in range(time_steps, 0, -1):
                hidden_state = self.RNNCell(inputs[:, i - 1], hidden_state)
                hidden_list.insert(0, hidden_state[-1])
                if i == time_steps:
                    """获取最后一时间步的cell_state"""
                    last_state = [
                        torch.concat([last_state[j], hidden_state[j]], dim=1)
                        for j in range(len(hidden_state))
                    ]
                if self.padding == 'post':
                    """如果padding值填充在序列首端，则正反时间步传播应加 mask 操作"""
                    hidden_state = [
                        hidden_state[j] * mask[:, i - 1:i] + initial_state[j] * (1 - mask[:, i - 1:i])  # 重新初始化（加数项作用）
                        for j in range(len(hidden_state))
                    ]
            sequence = torch.concat([
                sequence,
                torch.reshape(
                    torch.unsqueeze(
                        torch.concat(hidden_list, dim=1)
                        , dim=1)
                    , [batch_size, time_steps, -1]
                )
            ], dim=-1)

        return sequence, last_state

总结

本周只是对RNN有了一个简单的了解。下周我们要基于RNN的数学底层逻辑展开研究。主要针对于RNN的反向传播等相关内容。