精华内容
下载资源
问答
  • SS LSTM全文翻译

    千次阅读 2019-12-05 16:36:49
    SS-LSTM:一种用于行人轨迹预测的分层LSTM模型 ...在本文中,提出了一种新颖的基于LSTM的层次化网络,以同时考虑社会邻域和场景布局的影响。我们的SS-LSTM是Social-Scene-LSTM的缩写,它使用三种不同的LSTM来捕获...

    SS-LSTM:一种用于行人轨迹预测的分层LSTM模型

     

    由于场景的拥挤和杂乱,行人轨迹预测是一个极具挑战性的问题。以往的基于深度学习的LSTM方法关注的是行人对周围环境的影响,而忽略了行人轨迹预测中的场景布局。在本文中,提出了一种新颖的基于LSTM的层次化网络,以同时考虑社会邻域和场景布局的影响。我们的SS-LSTM是Social-Scene-LSTM的缩写,它使用三种不同的LSTM来捕获人、社会和场景尺度信息。在社会尺度上,我们也使用圆形邻里设置,而不是传统的矩形邻里。我们在三个公共数据集上针对两种基线方法和一种最新技术对我们提出的方法进行了评估。结果表明,我们的方法优于其他方法,并且使用圆形邻域提高了预测精度。

     

    1. Introduction

    基于深度学习方法的行人未来轨迹预测问题近年来在计算机视觉和人工智能领域重新引起了人们的兴趣[1,22,14,23,26]。这个预测是关于根据行人先前观察到的轨迹生成轨迹方面的未来位置。拥挤场景中行人运动轨迹的预测对于社会机器人的人类感知导航和智能跟踪具有重要意义。然而,由于拥挤场景中复杂的运动行为和杂乱,自动预测行人的轨迹对于人工智能系统来说并不是一件容易的任务。

     

    现有的行人轨迹预测算法可以分为两类:基于模型的方法和基于长短期记忆(LSTM)架构的深度学习方法。基于模型的方法[8,19,28]依赖于人工设计的行为模型函数和行人属性的手工制作的设置,而不是从训练数据中学习行人的运动行为。这些方法不能在更拥挤和复杂的场景中可靠地预测轨迹,因为很难将所有运动模式组合到一个模型中。对于基于LSTM的方法[1,6,14,23],在训练过程中结合来自行人邻居的信息并使用场景上下文来细化轨迹都已被尝试。然而,场景的布局对行人在导航过程中的路径规划具有更多的全局影响,还没有得到广泛的研究

     

    图1.我们的SS-LSTM网络融合了3种不同尺度的信息,用于行人轨迹预测:Person Scale,捕获个体行人过去的轨迹信息;Social Scale,捕获每个行人的邻居信息;以及Scene Scale,捕获场景布局特征。

     

    在本文中,我们提出了一种由三个尺度组成的层次化LSTM网络来克服上述限制。我们将这个网络命名为Social-Scene-LSTM(SS-LSTM)。当行人在拥挤的地方行走时,其他邻近的行人和场景布局会影响他们的移动轨迹。例如,行人通常与陌生人保持一段舒适的距离,但与朋友或家人走得更近;行人会稍微绕道避开障碍物或朝某个特定出口步行。如图1所示,我们使用三种不同的尺度处理行人轨迹预测问题:Person Scale,捕获每个人过去的轨迹信息;Social Scale,捕获每个行人周围邻居的信息;Scene Scale,捕获有关场景布局的信息。我们关于使用社会规模的工作是受到最先进的社会LSTM技术的启发[1]。我们使用占用图来提取邻域特征。我们还使用了更健壮的圆形邻域,而不是广泛使用的矩形占用网格[1,26]。这种新颖的SS-LSTM网络可以从数据中自动学习社会邻居和场景影响。

     

    本文的贡献在于:(1)提出了一种新颖的分层LSTM人体轨迹预测模型,该模型具有三个层次尺度,综合了影响行人导航的所有可能因素;(2)实现了三种不同类别的占用地图(网格地图、圆形地图和对数地图)来全面模拟社会尺度的人-人交互,并比较了这些占用地图的预测性能。

     

    1. Related Work

    2.1. Model-Based Trajectory Prediction

    最初的社会力模型[8]是为了模拟行人的运动行为而提出的。这个社会作用力模型包括三种力:朝向所需运动速度的加速度、排斥力和吸引力。在原始社会力量模型的基础上,Yamaguchi et al.。[28]通过利用更多的行为因素,如阻尼、碰撞和社会互动,改进了轨迹预测模型。在轨迹研究文献中使用的另一个行为因素是碰撞时间因子[11],它描述了如果两个行人继续以目前的行走速度相撞之前的持续时间。


    基于代理的建模[3,13]也被用于建模行人的行为模式。Yi等人。[29]将静止人群组因子、移动行人因子和场景布局因子结合在一种新颖的基于Agent的模型中,以提高密集人群中的预测性能。Pellegrini等人。[19]提出了一种用于短期行人轨迹预测的线性轨迹回避(LTA)模型。最近,Vmula et al.。[26]在交互高斯过程(IGP)模型的基础上,提出了一种描述拥挤场景中合作人类行为的交互模型[25]。

     

    基于模型的方法的一个缺点是它们在很大程度上依赖于手工制作的因素,如行人的首选步行速度。此外,将所有的弹道影响因素组合成一个单一的模型也不是一件简单的事情。这限制了基于模型的方法在拥挤场景中进行轨迹预测的应用。

     

      1. LSTM-based Trajectory Prediction

    递归神经网络(RNNs)被设计用于基于网络中的递归结构来处理时间序列数据。然而,当持有相关信息的单元与需要信息的单元之间的距离变得更大时,由于梯度消失或爆炸问题,RNN在学习连接信息方面存在困难[18]。因此,通过引入三门结构(输入门、忘记门和输出门),设计了长期短期记忆(LSTM)网络[9]来改进原有的RNN。最近,RNN和LSTM都证明了它们在时序数据处理领域的成功,例如语音识别[7,20],语言翻译[24],动作识别[30,16]和图像字幕[12,4]。

     

    直观地说,行人的轨迹可以被认为是时间序列数据,所以LSTM可以用于预测行人的轨迹。与基于模型的方法相比,使用LSTM进行轨迹预测是一种更通用的数据驱动方法。Alahi等人。[1]提出了一种社会-LSTM模型,它结合了大社区内其他人的行为。然而,该Social-LSTM在预测中不包括重要的场景上下文信息。最近,Lee等人提出了深度随机逆最优控制RNN编解码器(Deep Stochastic Inverse Optimal Control RNN Encoder-Decder)框架。[14]使用场景上下文融合来对生成的轨迹进行排序和细化,而不是将场景信息合并到轨迹预测过程中。与SocialLSTM和Desire相比,我们提出的分层SS-LSTM在预测过程中既考虑了人与人的交互影响,又考虑了场景尺度特征。

    最近,基于LSTM的方法已经被用于城市层面的应用,如公共交通预测[21]和位置预测问题[17]。分层LSTM架构也被用于上下文事件预测[10]和活动识别[27]。然而,据我们所知,分层的LSTM架构还没有被设计用于行人轨迹预测。

     

    1. Our Method

    在实际应用中,行人所走的路线会受到附近其他行人的位置的影响。在复杂的场景中,行人会稍微绕行或绕道,以避开树木、垃圾桶和长凳等障碍物。在我们的方法中,每个行人的过去轨迹(即预测时间步长之前的轨迹)被称为人尺度上的信息。我们使用另外两个LSTM来处理受邻近行人和场景布局影响的轨迹。我们将它们称为社会尺度和场景尺度下的LSTM。因此,我们提出的分层框架,即我们创造的Social-Scene-LSTM(SS-LSTM),由这三个尺度的三个LSTM编码器和一个用于预测轨迹坐标的LSTM解码器组成(图2)。我们建议的方法的细节将在LSTM简要回顾之后的小节中描述。

     

    3.1. Brief Review on LSTM

    在基本的LSTM网络体系结构中,给定由表示的输入序列,可以通过迭代计算来获得输出序列对于

    其中项表示不同的权重矩阵,表示输出的偏差向量,h表示隐藏状态。在单元函数LSTM(·)中,隐藏状态由输入门i、忘记门f、输出门o和单元状态c通过以下等式确定:

    其中是从a层到b层的权重矩阵;σ(·)表示Sigmoid激活函数;每个带下标的b项是适当层的偏置矢量。

     

      1. Person Scale

    Person Scale LSTM对观察到的轨迹进行编码,其中包含用于轨迹预测的基本信息。在时间步t,第i个行人的轨迹由图像坐标。我们观察从时间t=1到t=obs的所有行人的位置,并且我们的目标是从t=obs+1到t=pred预测他们的位置。因此,轨迹预测的问题可以被定义为来自输入观察轨迹的未来轨迹的序列生成问题,∀i

     

    对于Person Scale LSTM编码器,第i个行人的观测轨迹坐标Xi OBS被读入作为输入。该行人在时间t的隐藏状态pi t通过以下方式更新:

    其中表示Person Scale LSTM编码器,是在训练过程中估计的未知权重矩阵。

      1. Social Scale

    为了捕捉附近其他行人的影响,我们为每个行人构建了一张占用地图,将社会比例因子纳入我们的模型中。通过将行人的邻居划分为不重叠的单元来构建占用图。在时间步长t处第i个行人和周围邻居之间的空间关系在占用映射矩阵中建模。

     

    在社会尺度LSTM中,我们采用两种邻域形状,如图3所示,形成三种不同类别的占用地图:网格地图、圆形地图和日志地图。对于网格映射类别,使用矩形邻域;对于圆形映射和对数映射类别,使用圆形邻域。圆形贴图和对数贴图之间的区别在于如何定义贴图的半径在圆形映射中,使用半径的线性比例在对数映射中,使用对数比例。与传统的矩形邻域设置[1,26]相比,圆形邻域是更合适的形状,因为社会影响的重要性主要由第i个行人与相邻行人之间的距离决定。

    图3.传统的矩形和我们提出的圆形占用图。占用地图用于模拟研究中行人(绿色)周围其他行人(红色)的影响。

     

    占用图的大小由划分该图的单元格的数量确定。例如,在图3中,网格地图的大小为4×4,圆形地图的大小为3×4。根据占用每个小区的相邻行人的数量,计算占用地图矩阵如下:

    其中是区分第j个行人的坐标是否在占用地图的(a,b)单元的第i个行人的邻域集合中的判别函数。

     

    使用占用图作为输入,社会规模LSTM编码器如下计算隐藏状态

    其中是相应的权重矩阵

      1. Scene Scale

    与社会尺度相比,在行人轨迹预测的文献中,场景尺度并没有受到太多的关注。可以手动指定场景布局,如入口、出口、固定障碍物等。但是,更好的替代方法是使用更通用的数据驱动方法。与捕捉行人与其邻居之间的局部交互的社会尺度类似,我们引入场景尺度LSTM来捕捉预测框架中的场景特征(参见图2中的场景尺度LSTM编码器)。使用场景尺度的另一个动机是,虽然社会尺度更关注行人的局部邻域,但场景特征捕获场景的全局信息以进行轨迹预测。当需要预测长轨迹时,这种全局信息很有价值。

     

    对于场景尺度,我们训练CNN在时间步长t提取每帧的场景特征Ft。与传统的CNN不同的是,我们的CNN是为分类任务而训练的,我们的CNN是在我们的框架中与其他LSTM一起专门训练来进行轨迹预测的。它包含三个卷积层和最大池层(图4)。在CNN的卷积部分之后使用两个完全连接的层。批处理归一化层也用于避免过度拟合。由最后一个完全连接层产生的输出Ft是256维特征向量。传递给CNN的每个输入视频帧都包含移动的行人。由于拍摄场景的摄像头是固定的,所以视频帧之间CNN特征的变化主要是由行人的运动引起的。

     

    图4.场景规模CNN中用于提取全局特征的卷积架构,包括3个卷积层、3个最大池层和2个批次归一化层(一个在最大池化1之后;一个在最大池化2之后)。网络不同层次的特征图既捕捉了静态场景结构,又捕捉了由行人运动引起的动态场景特征。

     

    在我们的情况下,当从视频帧中提取的CNN特征通过针对时间序列预测的LSTM网络进行微调时,静态和动态场景特征都将被提供给预测网络。此外,这种特征变化与在社会和人物尺度上捕获的行人信息同步。这个场景特征矩阵被馈送到我们的场景尺度,以计算在时间t的第i个行人的隐藏状态向量

    其中W3是关联的权重矩阵

    我们建议的网络的下一部分是合并层ϕ(.)。其将上面计算的所有矢量pit,si,to和si,tc连接起来,给出了三个比例LSTM编码器的隐藏状态hi,如下所示:

    其中⊕表示串联运算符。连接状态hi t由行人i的所有过去轨迹信息、所有行人邻域信息和时间步长t处的场景布局信息组成。

     

      1. Trajectory prediction

    为了在稍后的时间预测行人的轨迹坐标,图2中的lstm解码器将编码的作为输入,并预测行人i在时间t通过的位置

    图2.我们建议的SS-LSTM网络的管道。三种刻度有三个LSTM编码器。场景比例还包括CNN。将编码向量连接以形成LSTM解码器的输入,以产生每个输入观察轨迹的预测轨迹。

    类似于EQ(1)和(2)中的基本LSTM,是LSTM解码器和输出层的权重矩阵,是输出层的偏置项。

     

    3.6.。实施细节

    在我们的SS-LSTM模型中,所有的LSTM层都有128维,并且隐藏状态具有非线性RELU(整流线性单元)激活。人、社会和场景尺度LSTM的输入维度分别基于观察轨迹的长度、占用图的大小和CNN特征矩阵的大小。为了避免过度拟合,将丢失值设置为0.2。我们提出的网络的参数用RMSprop优化器[5]进行训练,学习率设置为0.003。所有的模型都经过了1000个纪元的训练。我们的SS-LSTM模型是在KERAS上使用PythonTensorFlow后端构建的,并使用NVIDIA GTX-1080GPU进行培训(代码可在https://github.com/xuehaouwa/SSLSTM).获得

     

    4. Experiments

    4.1. Datasets

    ETH和UCY:ETH[19]和UCY[15]是两个公开可用的行人轨迹数据集,涵盖了具有挑战性的运动模式,如一起行走和避免碰撞。从这两个数据集中总共有5个子集,包含数百个注释的行人轨迹。这些子集是ETHhotel、ETHuniv、UCYuniv、zara01和zara02。

     

    类似于Alahi等人采用的设置。[1],我们在训练/测试集上实现了留一分策略,并使用归一化像素单元。在这些数据集的实验过程中,我们使用4个子集训练我们的网络,并在剩余的1个子集上测试它。观察轨迹和预测轨迹的长度分别为3.2秒和4.8秒,这意味着我们观察8帧并预测接下来的12帧。邻域和网格大小设置为32像素和4像素,给出8×8网格占用图。对于圆形映射和对数映射,我们使用相同大小的占用映射。

     

    城镇中心数据集:城镇中心数据集[2]包含真实世界拥挤场景中的数百个人的轨迹。城市中心数据集的注释文件提供了每个行人头部和身体的边界框。在我们的实验中,身体包围盒的中心被认为是轨迹坐标。视频每秒25帧,分辨率为1920×1080像素。我们通过每隔5帧向下采样对注释轨迹进行预处理。

     

    在实验过程中,我们还观察了每个轨迹的前8帧(1.6秒,5fps)。由于视频的高分辨率和图像中相对较大的行人(摄像机靠近人),我们选择160×160像素的邻域和20像素作为网格大小。在此设置中,占用图的大小与ETH和UCY实验中使用的占用图相同。

     

    4.2.。基线和评估指标

    我们比较了以下方法和不同占用地图设置的性能:

    ·线性:基于线性回归的基线方法。这种方法假设每个行人都在笔直的路径上行走。

    ·LSTM:这是基本的基于普通LSTM的轨迹预测方法,不考虑任何社会或场景尺度信息。这是基于LSTM的轨迹预测的基线方法。

    ·S-LSTM:一种基于LSTM的预测方法,它包含了与Alahi等人提出的SocialLSTM相同的社会池层。[1]。有3种变体:S-LSTM-g、S-LSTM-c和S-LSTM-l,分别表示使用网格映射、圆形映射和对数映射。

    ·SS-LSTM:这是我们建议的Social-Scene-LSTM方法。类似地,根据所使用的占用地图,有3种变体,由SS-LSTM-g,SS-LSTM-c,SS-LSTM-l表示

     

    因为我们采用Alahi等人的公共代码中的设置,其中使用归一化像素单元,所以我们不能将我们的方法与使用其他单位的其他行人轨迹预测算法(例如,山口等人使用的米)进行比较。[28])。我们也不与Desire方法[14]进行比较,因为在那里使用了不同的数据集,并且作者的计算机代码不是公开可用的。

     

    4.3. Quantitative Results

    4.3.1 ETH and UCY

     

    表1给出了我们的实验的定量结果。一般来说,我们提出的SS-LSTM-l方法在大多数情况下都优于其他方法。此外,对于基于S-LSTM的方法,日志映射也具有更好的性能。从ADE和FDE值可以清楚地看出,圆形映射和对数映射的性能优于传统的网格映射。使用圆形邻域设置的优势是显而易见的。值得注意的是,即使是基本的线性预测方法在某些情况下(如ETHuniv和UCYuniv)也具有可比性。这是因为在这些场景中行人的运动模式很简单。例如,如果行人和他/她的目标目的地之间没有障碍物,他/她将直接前往目的地。

     

    表2.SS-LSTM对城镇中心数据集的预测误差(以像素为单位)。观察到的轨迹长度为8帧。Tp值分别对应于4、8、12和16帧。

    从平均结果来看,SS-LSTM-l相对于ADE和FDE都具有最好的结果。这意味着我们的方法可以生成更好的预测轨迹,并给出更准确的目的地预测。此外,所有包含人-人交互的方法(S-LSTM和SS-LSTM)的性能都优于基线方法(线性和香草LSTM方法)。这表明行人周围的环境对该行人的轨迹预测有着极其重要的影响。我们提出的分层SS-LSTM的性能优于具有相同类别占用映射的S-LSTM。这些实验表明,场景尺度信息有助于轨迹预测。

     

    4.3.2 Town Centre

    对于城市中心实验,我们重点研究了SS-LSTM在不同Tp值下具有不同占用地图的性能。在轨迹预测术语中,术语预测地平线(由Venula等人介绍。[26]),此后用TP表示,通常用于描述预测轨迹的长度。在我们的实验中,给定相同的1.6秒的观察轨迹长度,我们预测了一系列不同预测视界的轨迹,即TP=0.8,1.6,2.4,3.2秒。在训练和测试阶段,过滤掉小于4.8秒的轨迹(帧速率为5的24帧)。

     

    SS-LSTM的预测结果(以像素为单位)如表2所示。为每个TP值提供最佳性能的占用映射类别以粗体突出显示。虽然有些FDE值超过100个像素,但如果图像分辨率为1920×1080,则认为100个像素的位移误差是可以接受的。当预测时域TP大于输入观测轨迹时,使用圆形映射和对数映射可以显著降低ADE和FDE。当观测轨迹长度大于Tp时,矩形和圆形邻域的性能大致相同。这是因为矩形邻域和圆形邻域之间的差异是在远离行人的区域中。例如,如果网格地图矩阵和圆形地图矩阵的大小相同(实验中均为8×8),则邻域最外面的人与圆形预测行人的距离相同。对于矩形形状,邻里角落里的人比旁边的行人有更大的距离。因此,当Tp较小时,所有三类占用映射具有几乎相同的性能。当TP较大时,圆形邻域给出比传统矩形邻域设置更好的性能。此外,由于社会影响力的大小取决于两个行人之间的距离,因此原木地图显示出更好地描述这种距离关系。因此,一般而言,就所有Tp值的最终位移误差而言,对数贴图的性能优于圆形贴图和网格贴图。

     

    表3.城市中心数据集的小预测和大预测水平的预测误差。

    图5.我们的SS-LSTM方法的几个预测轨迹的图示。前两行显示了ETH和UCY数据集的结果。最后一行显示了预测结果稍差的四个示例。每个子图中的黄色轨迹表示地面真实轨迹。使用网格地图、圆圈地图和对数地图预测的轨迹分别以绿色、红色和蓝色显示(彩色效果更好)。

     

    为了展示使用场景尺度的优势,我们比较了香草LSTM,S-LSTM-l和SS-LSTM-l对于小的和大的预测范围TP。表3列出了结果。在两种情况下,S-LSTM-l和SS-LSTM-l的性能都优于香草LSTM方法。当Tp较小时,S-LSTM-l和SS-LSTM-l都表现良好。结果表明,当Tp较小时,场景尺度信息的影响是有限的。但是,当TP较大时,SS-LSTM-l的性能明显优于S-LSTM-l。以上结果证实了我们在SS-LSTM中学习的场景级特征捕获了更多关于场景的全局信息,并且它们有助于提高长轨迹的预测精度。

     

    4.4.。定性结果

    在图5中,我们展示了在ETH(第一行)和UCY(第二行)数据集上具有不同占用映射的SS-LSTM的一些预测轨迹。在社会尺度和场景尺度的帮助下,SS-LSTM能够预测人们与他人一起行走或附近的树木和停放的汽车等障碍物时的轨迹。我们的SS-LSTM不仅可以在行人直线行走时做出成功的预测,而且当行人转过街角进入另一条街道时,它们还能稳健地处理这种情况。

     

    图5的第三行显示了预测结果不太理想的一些示例。在这些情况下,我们预测的轨迹比地面真实轨迹短。这些行人的速度被错误地预测了。然而,就行人的一般移动方向而言,预测的轨迹仍然是可以接受的。一个可能的原因是我们认为不同距离的邻居(离目标人)是相同的(在占用图中给定相同的权重)。

     

    香草LSTM、S-LSTM和SS-LSTM之间的比较如图6所示。我们选择小的(TP=0.8秒)和大的(TP=3.2秒)预测范围。对于S-LSTM和SS-LSTM方法,在社会尺度中使用对数映射。对于较小的TP值(图6,第1行),这三种预测方法的性能大致相同。S-LSTM和SS-LSTM的预测轨迹都非常接近地面真实。在这种情况下,场景比例的影响是最小的;仅使用行人的邻居就足以获得良好的预测。在图6(F)中,行人与附近的邻居走得很近,与S-LSTM和SS-LSTM相比,香草LSTM给出的预测轨迹更差。这个例子显示了社会规模信息的重要性。

    图6.从不同方法预测的几个轨迹的图示。在情况(A)至(C)中,Tp=0.8秒;在情况(D)-(I)中,Tp=3.2秒。在所有情况下,观察到的轨迹都是1.6秒(即8帧)长。

     

    在图6(H)中,因为只有穿白色长袍的女人在穿黑衣服的女人的附近,所以使用SLSTM,产生的红色轨迹是朝向相反方向行走的人群。然而,全局场景信息使得SS-LSTM能够克服这个问题。对于香草LSTM方法,情况更糟,因为第一个预测点已经很远了。在图6(I)中,行人的潜在路径上存在障碍。在没有场景尺度信息的情况下,LSTM和S-LSTM生成的轨迹朝向明显无效的障碍物。因此,在预测网络中,考虑全局场景尺度是必不可少的。

     

    5Conclusions and Future Work

    我们提出了一种新的基于分层LSTM的拥挤场景下行人轨迹预测方法。我们已经在三个基准数据集上证明了我们提出的SS-LSTM优于其他方法。此外,我们还证明了使用圆形邻域比传统的矩形邻域占有率图给出了更好的轨迹预测结果。从我们在城市中心数据集上预测不同长度轨迹的实验中,我们已经证明了当Tp较大时,我们的SS-LSTM和LOG地图在社会规模中更好。

     

    虽然我们的SS-LSTM在预测视界较大时优于其他方法,但预测结果仍然不如短轨迹的预测结果准确。在未来,我们将致力于进一步提高预测性能,根据邻居之间的行人距离为邻居分配影响权重。我们还打算在SS-LSTM预测模型中加入时空注意机制和额外的网络来学习其他运动因素,例如与其他行人之间的舒适距离。

    展开全文
  • self).__init__() self.lstm_size = lstm_size self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_size) self.lstm = tf.keras.layers.LSTM( lstm_size, return_sequences=True, return_state=...
    import tensorflow as tf
    import numpy as np
    import unicodedata
    import re
    
    raw_data = (
        ('What a ridiculous concept!', 'Quel concept ridicule !'),
        ('Your idea is not entirely crazy.', "Votre idée n'est pas complètement folle."),
        ("A man's worth lies in what he is.", "La valeur d'un homme réside dans ce qu'il est."),
        ('What he did is very wrong.', "Ce qu'il a fait est très mal."),
        ("All three of you need to do that.", "Vous avez besoin de faire cela, tous les trois."),
        ("Are you giving me another chance?", "Me donnez-vous une autre chance ?"),
        ("Both Tom and Mary work as models.", "Tom et Mary travaillent tous les deux comme mannequins."),
        ("Can I have a few minutes, please?", "Puis-je avoir quelques minutes, je vous prie ?"),
        ("Could you close the door, please?", "Pourriez-vous fermer la porte, s'il vous plaît ?"),
        ("Did you plant pumpkins this year?", "Cette année, avez-vous planté des citrouilles ?"),
        ("Do you ever study in the library?", "Est-ce que vous étudiez à la bibliothèque des fois ?"),
        ("Don't be deceived by appearances.", "Ne vous laissez pas abuser par les apparences."),
        ("Excuse me. Can you speak English?", "Je vous prie de m'excuser ! Savez-vous parler anglais ?"),
        ("Few people know the true meaning.", "Peu de gens savent ce que cela veut réellement dire."),
        ("Germany produced many scientists.", "L'Allemagne a produit beaucoup de scientifiques."),
        ("Guess whose birthday it is today.", "Devine de qui c'est l'anniversaire, aujourd'hui !"),
        ("He acted like he owned the place.", "Il s'est comporté comme s'il possédait l'endroit."),
        ("Honesty will pay in the long run.", "L'honnêteté paye à la longue."),
        ("How do we know this isn't a trap?", "Comment savez-vous qu'il ne s'agit pas d'un piège ?"),
        ("I can't believe you're giving up.", "Je n'arrive pas à croire que vous abandonniez."),
    )
    
    
    def unicode_to_ascii(s):
        return ''.join(
            c for c in unicodedata.normalize('NFD', s)
            if unicodedata.category(c) != 'Mn')
    
    
    def normalize_string(s):
        s = unicode_to_ascii(s)
        s = re.sub(r'([!.?])', r' \1', s)
        s = re.sub(r'[^a-zA-Z.!?]+', r' ', s)
        s = re.sub(r'\s+', r' ', s)
        return s
    
    
    raw_data_en, raw_data_fr = list(zip(*raw_data))
    raw_data_en, raw_data_fr = list(raw_data_en), list(raw_data_fr)
    raw_data_en = [normalize_string(data) for data in raw_data_en]
    raw_data_fr_in = ['<start> ' + normalize_string(data) for data in raw_data_fr]
    raw_data_fr_out = [normalize_string(data) + ' <end>' for data in raw_data_fr]
    
    en_tokenizer = tf.keras.preprocessing.text.Tokenizer(filters='')
    en_tokenizer.fit_on_texts(raw_data_en)
    data_en = en_tokenizer.texts_to_sequences(raw_data_en)
    data_en = tf.keras.preprocessing.sequence.pad_sequences(data_en,
                                                            padding='post')
    
    fr_tokenizer = tf.keras.preprocessing.text.Tokenizer(filters='')
    fr_tokenizer.fit_on_texts(raw_data_fr_in)
    fr_tokenizer.fit_on_texts(raw_data_fr_out)
    data_fr_in = fr_tokenizer.texts_to_sequences(raw_data_fr_in)
    data_fr_in = tf.keras.preprocessing.sequence.pad_sequences(data_fr_in,
                                                               padding='post')
    
    data_fr_out = fr_tokenizer.texts_to_sequences(raw_data_fr_out)
    data_fr_out = tf.keras.preprocessing.sequence.pad_sequences(data_fr_out,
                                                                padding='post')
    
    BATCH_SIZE = 5
    dataset = tf.data.Dataset.from_tensor_slices(
        (data_en, data_fr_in, data_fr_out))
    dataset = dataset.shuffle(20).batch(BATCH_SIZE)
    
    
    class Encoder(tf.keras.Model):
        def __init__(self, vocab_size, embedding_size, lstm_size):
            super(Encoder, self).__init__()
            self.lstm_size = lstm_size
            self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_size)
            self.lstm = tf.keras.layers.LSTM(
                lstm_size, return_sequences=True, return_state=True)
    
        def call(self, sequence, states):
            embed = self.embedding(sequence)
            output, state_h, state_c = self.lstm(embed, initial_state=states)
    
            return output, state_h, state_c
    
        def init_states(self, batch_size):
            return (tf.zeros([batch_size, self.lstm_size]),
                    tf.zeros([batch_size, self.lstm_size]))
    
    
    class Decoder(tf.keras.Model):
        def __init__(self, vocab_size, embedding_size, lstm_size):
            super(Decoder, self).__init__()
            self.lstm_size = lstm_size
            self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_size)
            self.lstm = tf.keras.layers.LSTM(
                lstm_size, return_sequences=True, return_state=True)
            self.dense = tf.keras.layers.Dense(vocab_size)
    
        def call(self, sequence, state):
            embed = self.embedding(sequence)
            lstm_out, state_h, state_c = self.lstm(embed, state)
            logits = self.dense(lstm_out)
    
            return logits, state_h, state_c
    
        def init_states(self, batch_size):
            return (tf.zeros([batch_size, self.lstm_size]),
                    tf.zeros([batch_size, self.lstm_size]))
    
    
    en_vocab_size = len(en_tokenizer.word_index) + 1
    fr_vocab_size = len(fr_tokenizer.word_index) + 1
    
    EMBEDDING_SIZE = 32
    LSTM_SIZE = 64
    
    encoder = Encoder(en_vocab_size, EMBEDDING_SIZE, LSTM_SIZE)
    decoder = Decoder(fr_vocab_size, EMBEDDING_SIZE, LSTM_SIZE)
    
    initial_states = encoder.init_states(1)
    encoder_outputs = encoder(tf.constant([[1, 2, 3]]), initial_states)
    decoder_outputs = decoder(tf.constant([[1, 2, 3]]), encoder_outputs[1:])
    
    
    def loss_func(targets, logits):
        crossentropy = tf.keras.losses.SparseCategoricalCrossentropy(
            from_logits=True)
        mask = tf.math.logical_not(tf.math.equal(targets, 0))
        mask = tf.cast(mask, dtype=tf.int64)
        loss = crossentropy(targets, logits, sample_weight=mask)
    
        return loss
    
    
    optimizer = tf.keras.optimizers.Adam(lr=1e-3)
    
    
    def predict(test_source_text=None):
        if test_source_text is None:
            test_source_text = raw_data_en[np.random.choice(len(raw_data_en))]
        print(test_source_text)
        test_source_seq = en_tokenizer.texts_to_sequences([test_source_text])
        print(test_source_seq)
    
        en_initial_states = encoder.init_states(1)
        en_outputs = encoder(tf.constant(test_source_seq), en_initial_states)
    
        de_input = tf.constant([[fr_tokenizer.word_index['<start>']]])
        de_state_h, de_state_c = en_outputs[1:]
        out_words = []
    
        while True:
            de_output, de_state_h, de_state_c = decoder(
                de_input, (de_state_h, de_state_c))
            de_input = tf.argmax(de_output, -1)
            out_words.append(fr_tokenizer.index_word[de_input.numpy()[0][0]])
    
            if out_words[-1] == '<end>' or len(out_words) >= 20:
                break
    
        print(' '.join(out_words))
    
    
    @tf.function
    def train_step(source_seq, target_seq_in, target_seq_out, en_initial_states):
        loss = 0
        with tf.GradientTape() as tape:
            en_outputs = encoder(source_seq, en_initial_states)
            en_states = en_outputs[1:]
            de_states = en_states
    
            de_outputs = decoder(target_seq_in, de_states)
            logits = de_outputs[0]
            loss = loss_func(target_seq_out, logits)
    
        variables = encoder.trainable_variables + decoder.trainable_variables
        gradients = tape.gradient(loss, variables)
        optimizer.apply_gradients(zip(gradients, variables))
    
        return loss
    
    
    NUM_EPOCHS = 300
    
    for e in range(NUM_EPOCHS):
        en_initial_states = encoder.init_states(BATCH_SIZE)
    
        predict()
    
        for batch, (source_seq, target_seq_in, target_seq_out) in enumerate(dataset.take(-1)):
            loss = train_step(source_seq, target_seq_in,
                              target_seq_out, en_initial_states)
    
        print('Epoch {} Loss {:.4f}'.format(e + 1, loss.numpy()))
    
    test_sents = (
        'What a ridiculous concept!',
        'Your idea is not entirely crazy.',
        "A man's worth lies in what he is.",
        'What he did is very wrong.',
        "All three of you need to do that.",
        "Are you giving me another chance?",
        "Both Tom and Mary work as models.",
        "Can I have a few minutes, please?",
        "Could you close the door, please?",
        "Did you plant pumpkins this year?",
        "Do you ever study in the library?",
        "Don't be deceived by appearances.",
        "Excuse me. Can you speak English?",
        "Few people know the true meaning.",
        "Germany produced many scientists.",
        "Guess whose birthday it is today.",
        "He acted like he owned the place.",
        "Honesty will pay in the long run.",
        "How do we know this isn't a trap?",
        "I can't believe you're giving up.",
    )
    
    for test_sent in test_sents:
        test_sequence = normalize_string(test_sent)
        predict(test_sequence)
    

    参考:
    LSTM机器翻译详解

    展开全文
  • 基于深度学习lstmMalware development has seen diversity in terms of architecture and features. This advancement in the competencies of malware poses a severe threat and opens new research dimensions in...

    基于深度学习lstm

    Malware development has seen diversity in terms of architecture and features. This advancement in the competencies of malware poses a severe threat and opens new research dimensions in malware detection. This study is focused on metamorphic malware that is the most advanced member of the malware family. It is quite impossible for anti-virus applications using traditional signature-based methods to detect metamorphic malware, which makes it difficult to classify this type of malware accordingly. Recent research literature about malware detection and classification discusses this issue related to malware behaviour.

    恶意软件的开发在体系结构和功能方面具有多样性。 恶意软件能力的提高带来了严重威胁,并为恶意软件检测打开了新的研究领域。 这项研究的重点是变形恶意软件,它是恶意软件家族中最先进的成员。 使用传统的基于签名的方法的防病毒应用程序几乎不可能检测到变形的恶意软件,这使得很难对此类恶意软件进行分类。 有关恶意软件检测和分类的最新研究文献讨论了与恶意软件行为有关的问题。

    Cite The Work If you find this implementation useful please cite it:

    引用工作如果您发现此实现有用,请引用:

    @article{10.7717/peerj-cs.285,
    title = {Deep learning based Sequential model for malware analysis using Windows exe API Calls},
    author = {Catak, Ferhat Ozgur and Yazı, Ahmet Faruk and Elezaj, Ogerta and Ahmed, Javed},
    year = 2020,
    month = jul,
    keywords = {Malware analysis, Sequential models, Network security, Long-short-term memory, Malware dataset},
    volume = 6,
    pages = {e285},
    journal = {PeerJ Computer Science},
    issn = {2376-5992},
    url = {https://doi.org/10.7717/peerj-cs.285},
    doi = {10.7717/peerj-cs.285}
    }

    You can access the dataset from my My GitHub Repository.

    您可以从我的GitHub存储库中访问数据集。

    介绍 (Introduction)

    Malicious software, commonly known as malware, is any software intentionally designed to cause damage to computer systems and compromise user security. An application or code is considered malware if it secretly acts against the interests of the computer user and performs malicious activities. Malware targets various platforms such as servers, personal computers, mobile phones, and cameras to gain unauthorized access, steal personal data, and disrupt the normal function of the system.

    恶意软件(通常称为恶意软件)是故意设计成对计算机系统造成损害并危及用户安全的任何软件。 如果应用程序或代码秘密地危害计算机用户的利益并执行恶意活动,则被认为是恶意软件。 恶意软件针对服务器,个人计算机,移动电话和相机等各种平台,以获取未经授权的访问,窃取个人数据并破坏系统的正常功能。

    One approach to deal with malware protection problem is by identifying the malicious software and evaluating its behaviour. Usually, this problem is solved through the analysis of malware behaviour. This field closely follows the model of malicious software family, which also reflects the pattern of malicious behaviour. There are very few studies that have demonstrated the methods of classification according to the malware families.

    解决恶意软件保护问题的一种方法是识别恶意软件并评估其行为。 通常,此问题是通过分析恶意软件行为来解决的。 该领域紧密遵循恶意软件家族的模型,它也反映了恶意行为的模式。 很少有研究证明了根据恶意软件家族进行分类的方法。

    All operating system API calls made to act by any software show the overall direction of this program. Whether this program is a malware or not can be learned by examining these actions in-depth. If it is malware, then what is its malware family. The malware-made operating system API call is a data attribute, and the sequence in which those API calls are generated is also critical to detect the malware family. Performing specific API calls is a particular order that represents a behaviour. One of the deep learning methods LSTM (long-short term memory) has been commonly used in the processing of such time-sequential data.

    由任何软件执行的所有操作系统API调用均显示该程序的总体方向。 可以通过深入检查这些操作来了解该程序是否为恶意软件。 如果是恶意软件,那么其恶意软件家族是什么。 恶意软件进行的操作系统API调用是一个数据属性,并且生成这些API调用的顺序对于检测恶意软件家族也很关键。 执行特定的API调用是代表行为的特定顺序。 深度学习方法之一LSTM(长期短期记忆)已普遍用于处理此类按时间顺序排列的数据。

    系统架构 (System Architecture)

    This research has two main objectives; first, we created a relevant dataset, and then, using this dataset, we did a comparative study using various machine learning to detect and classify malware automatically based on their types.

    这项研究有两个主要目标; 首先,我们创建了一个相关的数据集,然后,使用此数据集,我们进行了一项比较研究,使用各种机器学习来根据恶意软件的类型自动检测和分类恶意软件。

    数据集创建 (Dataset Creation)

    One of the most important contributions of this work is the new Windows PE Malware API sequence dataset, which contains malware analysis information. There are 7107 malware from different classes in this dataset. The Cuckoo Sandbox application, as explained above, is used to obtain the Windows API call sequences of malicious software, and VirusTotal Service is used to detect the classes of malware.

    这项工作最重要的贡献之一就是新的Windows PE恶意软件API序列数据集,其中包含恶意软件分析信息。 该数据集中有7107个来自不同类别的恶意软件。 如上所述,Cuckoo Sandbox应用程序用于获取恶意软件的Windows API调用序列,而VirusTotal Service用于检测恶意软件的类别。

    The following figure illustrates the system architecture used to collect the data and to classify them using LSTM algorithms.

    下图说明了用于收集数据并使用LSTM算法对其进行分类的系统体系结构。

    Our system consists of three main parts, data collection, data pre-processing and analyses, and data classification.

    我们的系统包括三个主要部分,数据收集,数据预处理和分析以及数据分类。

    The following steps were followed when creating the dataset.

    创建数据集时,遵循以下步骤。

    Cuckoo Sandbox application is installed on a computer running Ubuntu Linux distribution. The analysis machine was run as a virtual server to run and analyze malware. The Windows operating system is installed on this server.

    Cuckoo Sandbox应用程序安装在运行Ubuntu Linux发行版的计算机上。 分析机作为虚拟服务器运行,以运行和分析恶意软件。 Windows操作系统已安装在此服务器上。

    让我们编码 (Let’s coding)

    We import the usual standard libraries to build an LSTM model to detect the malware.

    我们导入常用的标准库以构建LSTM模型来检测恶意软件。

    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import confusion_matrix
    from keras.preprocessing.text import Tokenizer
    from keras.layers import LSTM, Dense, Dropout, Embedding
    from keras.preprocessing import sequence
    from keras.utils import np_utils
    from keras.models import Sequential
    from keras.layers import SpatialDropout1D
    from mlxtend.plotting import plot_confusion_matrix

    In this work, we will use standard our malware dataset to show the results. You can access the dataset from My GitHub Repository. We need to merge the call and the label datasets.

    在这项工作中,我们将使用标准的恶意软件数据集来显示结果。 您可以从My GitHub Repository访问数据集。 我们需要合并调用和标签数据集。

    malware_calls_df = pd.read_csv("calls.zip", compression="zip",
    sep="\t", names=["API_Calls"])
    malware_labels_df = pd.read_csv("types.zip", compression="zip",
    sep="\t", names=["API_Labels"])
    malware_calls_df["API_Labels"] = malware_labels_df.API_Labels
    malware_calls_df["API_Calls"] = malware_calls_df.API_Calls.apply(lambda x: " ".join(x.split(",")))
    malware_calls_df["API_Labels"] = malware_calls_df.API_Labels.apply(lambda x: 1 if x == "Virus" else 0)

    Let’s analyze the class distribution

    让我们分析类的分布

    sns.countplot(malware_calls_df.API_Labels)
    plt.xlabel('Labels')
    plt.title('Class distribution')
    plt.savefig("class_distribution.png")
    plt.show()
    Class distribution

    Now we can create our sequence matrix. In order to build an LSTM model, you need to create a tokenization based sequence matrix as the input dataset

    现在我们可以创建序列矩阵。 为了构建LSTM模型,您需要创建一个基于标记化的序列矩阵作为输入数据集

    max_words = 800
    max_len = 100
    X = malware_calls_df.API_Calls
    Y = malware_calls_df.API_Labels.astype('category').cat.codes
    tok = Tokenizer(num_words=max_words)
    tok.fit_on_texts(X)
    print('Found %s unique tokens.' % len(tok.word_index))
    X = tok.texts_to_sequences(X.values)
    X = sequence.pad_sequences(X, maxlen=max_len)
    print('Shape of data tensor:', X.shape)
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y,
    test_size=0.15)
    le = LabelEncoder()
    Y_train_enc = le.fit_transform(Y_train)
    Y_train_enc = np_utils.to_categorical(Y_train_enc)
    Y_test_enc = le.transform(Y_test)
    Y_test_enc = np_utils.to_categorical(Y_test_enc)Found 278 unique tokens.
    Shape of data tensor: (7107, 100)

    The LSTM based classification model is then given for example as exercise here:

    然后在此处作为示例给出基于LSTM的分类模型:

    def malware_model(act_func="softsign"):
    model = Sequential()
    model.add(Embedding(max_words, 300, input_length=max_len))
    model.add(SpatialDropout1D(0.1))
    model.add(LSTM(32, dropout=0.1, recurrent_dropout=0.1,
    return_sequences=True, activation=act_func))
    model.add(LSTM(32, dropout=0.1, activation=act_func, return_sequences=True))
    model.add(LSTM(32, dropout=0.1, activation=act_func))
    model.add(Dense(128, activation=act_func))
    model.add(Dropout(0.1))
    model.add(Dense(256, activation=act_func))
    model.add(Dropout(0.1))
    model.add(Dense(128, activation=act_func))
    model.add(Dropout(0.1))
    model.add(Dense(1, name='out_layer', activation="linear"))
    return model

    The next step is to train the model. I trained and saved my model. Because of the dataset, the training stage takes lots of time. In order to reduce the execution time, you can load my previous trained model from the GitHub repository.

    下一步是训练模型。 我训练并保存了模型。 由于存在数据集,训练阶段需要很多时间。 为了减少执行时间,您可以从GitHub存储库加载我以前训练有素的模型。

    model = malware_model()
    print(model.summary())
    model.compile(loss='mse', optimizer="rmsprop",
    metrics=['accuracy'])
    filepath = "lstm-malware-model.hdf5"
    model.load_weights(filepath)
    history = model.fit(X_train, Y_train, batch_size=1000, epochs=10,
    validation_data=(X_test, Y_test), verbose=1)Model: "sequential"
    _________________________________________________________________
    Layer (type) Output Shape Param #
    =================================================================
    embedding (Embedding) (None, 100, 300) 240000
    _________________________________________________________________
    spatial_dropout1d (SpatialDr (None, 100, 300) 0
    _________________________________________________________________
    lstm (LSTM) (None, 100, 32) 42624
    _________________________________________________________________
    lstm_1 (LSTM) (None, 100, 32) 8320
    _________________________________________________________________
    lstm_2 (LSTM) (None, 32) 8320
    _________________________________________________________________
    dense (Dense) (None, 128) 4224
    _________________________________________________________________
    dropout (Dropout) (None, 128) 0
    _________________________________________________________________
    dense_1 (Dense) (None, 256) 33024
    _________________________________________________________________
    dropout_1 (Dropout) (None, 256) 0
    _________________________________________________________________
    dense_2 (Dense) (None, 128) 32896
    _________________________________________________________________
    dropout_2 (Dropout) (None, 128) 0
    _________________________________________________________________
    out_layer (Dense) (None, 1) 129
    =================================================================
    Total params: 369,537
    Trainable params: 369,537
    Non-trainable params: 0
    _________________________________________________________________
    None
    Epoch 1/10
    7/7 [==============================] - 22s 3s/step - loss: 0.0486 - accuracy: 0.9487 - val_loss: 0.0311 - val_accuracy: 0.9672
    Epoch 2/10
    7/7 [==============================] - 21s 3s/step - loss: 0.0378 - accuracy: 0.9591 - val_loss: 0.0302 - val_accuracy: 0.9672
    Epoch 3/10
    7/7 [==============================] - 21s 3s/step - loss: 0.0364 - accuracy: 0.9604 - val_loss: 0.0362 - val_accuracy: 0.9625
    Epoch 4/10
    7/7 [==============================] - 20s 3s/step - loss: 0.0378 - accuracy: 0.9593 - val_loss: 0.0328 - val_accuracy: 0.9616
    Epoch 5/10
    7/7 [==============================] - 22s 3s/step - loss: 0.0365 - accuracy: 0.9609 - val_loss: 0.0351 - val_accuracy: 0.9606
    Epoch 6/10
    7/7 [==============================] - 21s 3s/step - loss: 0.0369 - accuracy: 0.9601 - val_loss: 0.0369 - val_accuracy: 0.9606
    Epoch 7/10
    7/7 [==============================] - 22s 3s/step - loss: 0.0371 - accuracy: 0.9594 - val_loss: 0.0395 - val_accuracy: 0.9625
    Epoch 8/10
    7/7 [==============================] - 22s 3s/step - loss: 0.0378 - accuracy: 0.9601 - val_loss: 0.0365 - val_accuracy: 0.9588
    Epoch 9/10
    7/7 [==============================] - 22s 3s/step - loss: 0.0358 - accuracy: 0.9618 - val_loss: 0.0440 - val_accuracy: 0.9456
    Epoch 10/10
    7/7 [==============================] - 21s 3s/step - loss: 0.0373 - accuracy: 0.9589 - val_loss: 0.0354 - val_accuracy: 0.9644

    模型评估 (Model Evaluation)

    Now, we have finished the training phase of the LSTM model. We can evaluate our model’s classification performance using the confusion matrix. According to the confusion matrix, the model’s classification performance quite good.

    现在,我们已经完成了LSTM模型的训练阶段。 我们可以使用混淆矩阵评估模型的分类性能。 根据混淆矩阵,该模型的分类性能相当好。

    y_test_pred = model.predict_classes(X_test)
    cm = confusion_matrix(Y_test, y_test_pred)
    plot_confusion_matrix(conf_mat=cm,
    show_absolute=True,
    show_normed=True,
    colorbar=True)
    plt.savefig("confusion_matrix.png")
    plt.show()
    Confusion matrix

    Let’s continue with the training history of our model.

    让我们继续我们模型的训练历史。

    plt.plot(history.history['accuracy'])
    plt.plot(history.history['val_accuracy'])
    plt.title('model accuracy')
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.grid()
    plt.savefig("accuracy.png")
    plt.show()
    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title('model loss')
    plt.ylabel('loss')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.grid()
    plt.savefig("loss.png")
    plt.show()
    Accuracy history
    Loss history

    结论 (Conclusion)

    The purpose of this study was to create an LSTM based malware detection model using my previous malware dataset. Although our dataset contains instances that belong to some malware families with unbalanced distribution, we have shown that this problem does not affect classification performance.

    这项研究的目的是使用我以前的恶意软件数据集创建基于LSTM的恶意软件检测模型。 尽管我们的数据集包含的实例属于不均衡分布的某些恶意软件家族,但我们已经表明此问题不会影响分类性能。

    翻译自: https://towardsdatascience.com/deep-lstm-based-malware-analysis-6b36ac247f34

    基于深度学习lstm

    展开全文
  • 基于LSTM的哔哩哔哩股票预测·超详细教程

    千次阅读 热门讨论 2020-08-22 19:57:36
    基于LSTM的哔哩哔哩股票预测的超详细python教程,也有对应视频可以参考
    图片来源:https://www.bilibili.com/read/cv328714/

    文章内容分为以下8个部分

    本视频也有对应的视频(6min):
    https://www.bilibili.com/video/BV1dk4y117nz

    本教程的完整代码:
    https://github.com/kisaragiRY/Bilibili-Stock-Prediction

    并且作为补充,想了解LSTM具体原理的同学可以看一下colah的博文:
    英文原版:
    http://colah.github.io/posts/2015-08-Understanding-LSTMs/
    中文翻译版:
    https://www.jianshu.com/p/95d5c461924c

    让我们正式开始吧!

    1 问题描述


    在这篇文章中,我们将应用一个叫Long short-term memory (LSTM) 的循环神经网络(Recurrent Neural Network, RNN),对bilibili(NASDAQ: BILI)从上市2018-3-282020-8-18的股票数据进行分析及预测,并详细介绍其Python代码的实现。

    想要预测精确的股票价格是不可能的,神经网络算法仅能帮助探索一下股票的大致走势,所以

    注意!!:此篇文章内容不建议用于股票投资决策使用,所有结果仅作为参考!!

    2 模块准备


    如果没有某个模块,如pandas_datareader,可以在命令窗口输入以下代码来下载

    pip install pandas_datareader
    

    几乎所有Python的模块或包的下载方式都是这样

    pip install [模块的名字]
    

    接下来引入本篇文章要用上的所有模块

    #引入相关模块
    #读取数据用的模块
    from pandas_datareader import data as pdr
    #数据预处理用的模块
    import math
    from sklearn.preprocessing import MinMaxScaler
    import numpy as np
    #建立模型用的模块
    from keras.models import Sequential
    from keras.layers import Dense, Dropout, LSTM, TimeDistributed
    #作图用的模块
    import missingno as msno
    import matplotlib.pyplot as plt
    import seaborn as sns
    sns.set(color_codes='Ture')
    

    3 数据准备


    3.1 获取数据

    #根据股票代码BILI,从雅虎财经上获取从2018-3-28到2020-8-18的股票数据
    df=pdr.get_data_yahoo('BILI',start='2018-03-28',end='2020-08-18')
    #查看数据
    df
    

    输出:

    数据有603行,6列。即样本量(samples)是603,特征数(features)是6,分别是当日最高价(High),最低价(Low),开盘价(Open),收盘价(Close),成交量(Volume),调整后的收盘价(Adj Close)。
    本篇文章只对收盘价这一列数据进行拟合及预测。

    3.2 缺失值处理

    接下来我们要查看一下缺失值,若存在缺失值,我们则需要做一些相应处理,根据情况看是删除还是填充

    #可视化缺失值
    msno.matrix(df)
    

    输出:

    由上图可以看出,此数据是完整数据,没有缺失值,可以继续接下来的步骤

    3.3 拆分训练集与测试集

    我们将取前80%的数据作为训练集来训练模型,后20%的数据作为测试集来测试模型的预测能力

    #将dataframe按索引降序排列
    data = df.sort_index(ascending=True, axis=0)
    #只用Close这一列,即只使用股票的收盘价来进行拟合和预测
    dataset=data[['Close']].values
    
    #取80%的数据作为训练集
    training_data_len=math.ceil(len(dataset)*.8)
    train_data=dataset[0:training_data_len,:]
    #取剩下的数据作为测试集
    #在做预测时,余下的数据的第一个数据,需要前60天的数据来预测,因此这倒溯了60天
    test_data = dataset[training_data_len-60: , : ]
    
    

    3.4 数据归一化

    这一步,会将数据映射到[0,1]区间,目的是为了提升模型的收敛速度,提升模型的精度。
    这里采用的方法叫min-max标准化(Min-max normalization)或0-1标准化(0-1 normalization)
    xnorm=xmin(x)max(x)min(x) x_{norm}=\frac{x-min(x)}{max(x)-min(x)}

    #特征缩放
    scaler=MinMaxScaler(feature_range=(0,1))
    scaled_train=scaler.fit_transform(train_data)
    scaled_test=scaler.fit_transform(test_data)
    

    3.5 重构数据

    这一节的目的是使数据能符合算法的输入要求,分为三步

    1. 将数据集拆分成x和y两部分,用x来预测y,将数据转变成时间序列和有监督学习问题
      为了图像说明简便,假如我们以3天为一个timestep,即用前3天的数据(橙色大框,绿色大框,x)来预测第4天的数据(橙色小框,绿色小框,y)。在此博客中,实际的timesteps取的是60,即用前60天数据预测第61天数据。
    1. 将list类型数据转变成array数据,以便第三步使用
    2. 将二维数据转成三维数据。LSTM的输入需要一个三维数组(samples, timesteps, feature) 分别指样本量,时间步数,特征数目。
      x_train和x_test会作为LSTM的输入数据,而此时它俩是二维数据(samples, timsteps=60),我们需要给这俩数据再添一维feature,因为我们只取了收盘价来分析,所以此处的feature=1。
    #训练集的重构
    #1 分离x和y
    x_train=[]
    y_train=[]
    for i in range(60,len(scaled_train)):
        x_train.append(scaled_train[i-60:i,0])
        y_train.append(scaled_train[i,0])
    #2 将list类型数据转变成array数据
    x_train,y_train=np.array(x_train),np.array(y_train)
    #3 将二维数据变成三维数据
    x_train=np.reshape(x_train,(x_train.shape[0],x_train.shape[1],1))
    
    #测试集的重构
    #1 分离x和y
    x_test = []
    y_test = dataset[training_data_len: , : ] 
    for i in range(60,len(scaled_test)):
        x_test.append(scaled_test[i-60:i,0])
    #2 将list类型数据转变成array数据
    x_test = np.array(x_test)
    #3 将二维数据变成三维数据
    x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1))
    

    4. 模型建立


    • 初始化神经网络:Sequential()

    • LSTM层:LSTM()
      一般两层LSTM就能比较好的拟合数据了,多层的LSTM会提升模型的拟合度,但同时也增加了模型的复杂度和训练的难度,有兴趣的读者也可以试试多层LSTM效果。
      参数units=50的意思是该层有50个LSTM神经元,并且这一层输出的是一个50维的向量
      参数input_shape需要我们输入一个二维数组,包含timesteps和features,即时间步数和特征数目
      参数return_sequences是用来设定是否返回含有timesteps这一维的数组

      • True返回的是一个三维数组(batch size,timesteps,number of units),分别指批数目,时间步数,神经元数目,
      • False返回的是一个二维数组(batch size, number of units)
    • 防止过拟合的dropout层:Dropout()
      函数Dropout(0.2)意思是上一层输出的数据中,随机删除20%的数据

    • 全连接的神经网络层:Dense()
      也叫Densely connected layer,意思是这一层的每个节点与上一层的所有节点相连,参数unites=1的意思是这一层有一个神经元。

    • 神经网络编译:compile()
      用Adam来优化,以MSE(均方误差)为损失函数

    #构建模型
    #初始化模型
    model = Sequential()
    #LSTM层
    model.add(LSTM(units=50, return_sequences=True,input_shape=(x_train.shape[1],1)))
    #Dropout层
    model.add(Dropout(.2))
    #LSTM层
    model.add(LSTM(units=50, return_sequences=False))
    #Dropout层
    model.add(Dropout(.2))
    #全连接层
    model.add(Dense(units=1))
    #模型编译
    model.compile(optimizer='adam', loss='mean_squared_error')
    

    整体神经网络的结构如图

    #模型结构
    model.summary()
    

    输出:(能看到每层输出的数据结构以及参数个数)

    5. 模型拟合


    用训练集数据x_train,y_train来训练上一步建立好的模型,本文不涉及调整参数的步骤,在这笔者只是对参数batch_sizeepochs随机给了两个值25和10

    • batch_size:将完整的数据分为多次输入,一次输入的样本大小叫做batch_size
    • epochs:完整的数据通过一次神经网络,称为一次epoch

    而其实这两个值对模型拟合的好坏影响很大,笔者会在以后的文章中再仔细探讨一下如何调整参数。

    #拟合模型
    model.fit(x_train, y_train, batch_size=25, epochs=10)
    

    6. 模型预测


    用训练集训练好模型后,用测试集来做预测;
    又因之前对x_test做过归一化处理,这里需要用inverse_transform()这个函数来将它复原

    #预测
    predictions = model.predict(x_test) 
    #还原 特征缩放
    predictions = scaler.inverse_transform(predictions)
    

    7. 预测结果可视化


    #创建用来画图的dataframe
    train = data[:training_data_len]
    valid = data[training_data_len:]
    #给valid添加新的一列,把预测值predictions赋值给新的一列
    valid['Predictions'] = predictions
    #开始作图
    #图像大小
    plt.figure(figsize=(16,8))
    #图像标题
    plt.title('Model')
    #x轴
    plt.xlabel('Date', fontsize=18)
    #y轴
    plt.ylabel('Close Price USD ($)', fontsize=18)
    #画训练集的折线图
    plt.plot(train['Close'])
    #分别画出真实值和预测值的折线图
    plt.plot(valid[['Close', 'Predictions']])
    #展示图例
    plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
    plt.show()
    

    输出:

    由图可以看出算法LSTM的确能较为精确的预测出股票的浮动趋势

    8. 本文的缺陷


    • 本文只用了一种办法LSTM来做预测,其实还有很多别的方法,如传统的ARIMA,还有机器学习的办法比如k近邻等等
    • 本文未涉及参数调整。参数调整的方法有很多,除了手动调参,还可以借用一些算法比如网格搜索(Grid Search),随机网格搜索(Random Search),以及贝叶斯的办法。
    1. 神经网络结构里的参数,比如unites(神经元数目);
    2. 拟合模型时batch size和epochs这两个参数只是随便给了两个值。
    • …(如果你发现更多的不足,请一定私信或在评论区留言~~
    展开全文
  • 基于LSTM的音乐生成学习全过程的总结

    千次阅读 热门讨论 2020-03-04 12:44:09
    基于LSTM的音乐生成学习全过程的总结 由于笔者日常酷爱唱歌,酷爱音乐,再加上现在是计算机专业硕士在读。也是这个假期确定下来要做人工智能音乐的方向,也就开始了我对AI音乐的学习。 从最基本的旋律生成开始,也...
  • tensorflow2.0 基于LSTM模型的文本生成

    千次阅读 2020-11-11 15:29:53
    基于LSTM模型的唐诗文本生成实验背景实验数据下载LSTM模型分析实验过程文本预处理编解码模型LSTM模型设置实验代码实验结果总结 实验背景   在自然语言处理(NLP)领域,大多对话机器人的对话形成都会采用基于语料...
  • Group LSTM全文翻译

    2019-11-27 19:59:56
    基于行人的精确运动历史,专注于预测个人的未来路径。然而,由于跟踪算法在高密度场景中通常是不可靠的,因此这些方法在实际环境中不容易应用。然而,人们(朋友、夫妇、家庭成员等)。倾向于表现出连贯的...
  • Social LSTM全文翻译

    千次阅读 2019-11-25 15:23:35
    社会LSTM:拥挤空间中的人体轨迹预测 行人遵循不同的轨迹以避开障碍物并容纳同行的行人。任何在这种场景中导航的自动车辆都应该能够预见行人的未来位置,并相应地调整其路径以避免碰撞。这个轨迹预测问题可以看作...
  • 基于深度学习lstmMalware development has seen diversity in terms of architecture and features. This advancement in the competencies of malware poses a severe threat and opens new research dimensions in...
  • 基于LSTM分类文本情感分析

    千次阅读 2020-08-19 17:36:08
    本文将采用LSTM模型,训练一个能够识别文本postive, neutral, negative三种情感的分类器。 本文的目的是快速熟悉LSTM做情感分析任务,所以本文提到的只是一个baseline,并在最后分析了其优劣。对于真正的文本情感...
  • LSTM 网络工作示意图什么... LSTM 能够通过更新单元状态来学习参数间的长期依赖关系,目前在机器翻译、语言识别等领域有着广泛应用。LSTM 的使用背景当你读这篇文章的时候,你可以根据你对前面所读单词的理解来理解...
  • LSTM 能够通过更新单元状态来学习参数间的长期依赖关系,目前在机器翻译、语言识别等领域有着广泛应用。 LSTM 的使用背景 当你读这篇文章的时候,你可以根据你对前面所读单词的理解来理解上下文。 你不会从一开始...
  • 三、什么是LSTM神经元? 四、简单正弦波示例 五、 不那么简单的股票市场 六、多维LSTM预测 七、结论 一、前言 最近需要用到时间序列,在网上也找到了一篇相关的文章及源代码,在此分享给大家。 1.文章原文:...
  • 基于 LSTM 的 POI 个性化推荐框架AbstractQuestionMethodModelIntroduction作者为什么研究这个课题?参考模型介绍① word2vec②CBOW模型③ LSTM长依赖存在的问题LSTM 网络LSTMs的核心思想一步一步理解LSTM相关工作与...
  • 1. 循环神经网络(RNNs)人们并不是每一秒都重新开始新的思考的,就像你读这篇论文,你基于以前对词句的认知来理解每一个词,而不是丢掉以前所有的知识,重新开始构思新的想法。人们的思维是持续的。传统的神经网络...
  • 为了保障基础资源之一主机的稳定可靠,笔者对运行中的主机健康度做了基于LSTM循环神经网络的预测。 本次分享分为四个部分: 1、LSTM简介 2、基本数据准备 3、多元LSTM预测 4、模型优化01LSTM简介 随着深度学习技术...
  •  感觉很多chatbot的博文都是直接拿seq2seq开刀,上来就堆了一堆RNN(或者LSTM,Attention)模型的原理和公式。本篇从初学者的角度出发更想将机器学习基础(目标函数,优化方法,正则化等思想)贯穿始终。并结合...
  • 由于可以对文本进行更有效的编码及表达,基于深度学习的情感分类对比传统的浅层机器学习和统计学方法,可以取得更高的分类准确率。当前,情感分析在互联网业务中已经具有比较广泛的应用场景,成为了一个重要的业务...
  • 一、LSTM网络结构 二、数据预处理 三、训练与模型生成 四、藏头诗生成效果 拓展部分(古诗生成) 五、总结与展望 代码和数据下载: 完整代码在我的github,链接为:...
  • ♚作者:沂水寒城,CSDN博客专家,个人研究方向:机器学习、深度学习、NLP、CVBlog:http://yishuihancheng.blog.csdn.net本文翻译自大神Jaso...
  • 基于LSTM网络全局上下文注意力机制和人的基本骨架实现动作识别 摘要 三维骨架序列中的人体动作识别(action recognition)已经引起了很多研究人员的注意。近期,长短期记忆网络(LSTM)由于其在依赖关系方面和...
  • Long Sort Term Memory(LSTM)突破,语音识别、文本分类、语言模型、自动对话、机器翻译、图像标注领域。 长程依赖(Long-term Dependencies),传统RNN关键缺陷。LSTM,Schmidhuber教授1997年提出,解决长程依赖,...
  • 方向有很多:机器学习、深度学习,python,情感分析、意见挖掘、句法分析、机器翻译、人机对话、知识图谱、语音识别等。 记得备注呦 推荐阅读: 【ACL 2019】腾讯AI Lab解读三大前沿方向及20篇入选论文 【一分钟...
  • 由于可以对文本进行更有效的编码及表达,基于深度学习的情感分类对比传统的浅层机器学习和统计学方法,可以取得更高的分类准确率。当前,情感分析在互联网业务中已经具有比较广泛的应用场景,成为了一个重要的业务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,962
精华内容 4,384
关键字:

基于lstm的机器翻译