边写代码边学习之LSTM

这篇具有很好参考价值的文章主要介绍了边写代码边学习之LSTM。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.  什么是LSTM

长短期记忆网络 LSTM(long short-term memory)是 RNN 的一种变体,其核心概念在于细胞状态以及“门”结构。细胞状态相当于信息传输的路径,让信息能在序列连中传递下去。你可以将其看作网络的“记忆”。理论上讲,细胞状态能够将序列处理过程中的相关信息一直传递下去。因此,即使是较早时间步长的信息也能携带到较后时间步长的细胞中来,这克服了短时记忆的影响。信息的添加和移除我们通过“门”结构来实现,“门”结构在训练过程中会去学习该保存或遗忘哪些信息。
 

边写代码边学习之LSTM,DeepLearning总结,学习

 边写代码边学习之LSTM,DeepLearning总结,学习

2. 实验代码

2.1. 搭建一个只有一层LSTM和Dense网络的模型。

def simple_rnn_layer():

    # Create a dense layer with 10 output neurons and input shape of (None, 20)
    model = Sequential()
    model.add(LSTM(units=3, return_sequences=True, input_shape=(3, 2)))  # 4 units in the RNN layer, input_shape=(timesteps, features)
    model.add(Dense(1))  # Output layer with one neuron

    # Print the summary of the dense layer
    print(model.summary())

if __name__ == '__main__':
    simple_rnn_layer()

输出

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 lstm (LSTM)                 (None, 3, 3)              72        
                                                                 
 dense (Dense)               (None, 3, 1)              4         
                                                                 
=================================================================
Total params: 76
Trainable params: 76
Non-trainable params: 0

2.2. 验证LSTM里的逻辑

 假设我的输入数据是x = [1,0], 

kernel = [[[2, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0],

              [1, 1, 0, 1, 1, 0, 0, 1, 1 ,0, 0, 0],]]

recurrent_kernel = [[1, 0, 0, 1, 2,1,0,1,2,0,1,0],

                              [1, 1, 0, 0, 2,1,0,1,2,2,0,0],

                              [1, 0, 1, 2, 0,1,0,1,1,0,1,0]]

biase = [3, 1, 0, 1, 1,0,0,1,0,2,0.0,0]

通过下面手算,h的结果是[0, 4,1], c 的结果是[0,4,1].  注意无激活函数。

边写代码边学习之LSTM,DeepLearning总结,学习

 代码验证上面的结果


def change_weight():
    # Create a simple Dense layer
    lstm_layer = LSTM(units=3, input_shape=(3, 2), activation=None, recurrent_activation=None, return_sequences=True,
                      return_state= True)

    # Simulate input data (batch size of 1 for demonstration)
    input_data = np.array([
                [[1.0, 2], [2, 3], [3, 4]],
                [[5, 6], [6, 7], [7, 8]],
                [[9, 10], [10, 11], [11, 12]]
        ])

    # Pass the input data through the layer to initialize the weights and biases
    lstm_layer(input_data)

    kernel, recurrent_kernel, biases = lstm_layer.get_weights()

    # Print the initial weights and biases
    print("recurrent_kernel:", recurrent_kernel, recurrent_kernel.shape ) # (3,3)
    print('kernal:',kernel, kernel.shape) #(2,3)
    print('biase: ',biases , biases.shape) # (3)


    kernel = np.array([[2, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0],
                       [1, 1, 0, 1, 1, 0, 0, 1, 1 ,0, 0, 0],])

    recurrent_kernel = np.array([[1, 0, 0, 1, 2,1,0,1,2,0,1,0],
                                 [1, 1, 0, 0, 2,1,0,1,2,2,0,0],
                                 [1, 0, 1, 2, 0,1,0,1,1,0,1,0]])

    biases = np.array([3, 1, 0, 1, 1,0,0,1,0,2,0.0,0])

    lstm_layer.set_weights([kernel, recurrent_kernel, biases])
    print(lstm_layer.get_weights())

    # test_data = np.array([
    #     [[1.0, 3], [1, 1], [2, 3]]
    # ])

    test_data = np.array([
        [[1,0.0]]
    ])

    output, memory_state, carry_state  = lstm_layer(test_data)

    print(output)
    print(memory_state)
    print(carry_state)
if __name__ == '__main__':
    change_weight()

执行结果:

recurrent_kernel: [[-0.36744034 -0.11181469 -0.10642298  0.5450207  -0.30208975  0.5405432
   0.09643812 -0.14983998  0.1859854   0.2336958  -0.16187981  0.11621032]
 [ 0.07727922 -0.226477    0.1491096  -0.03933501  0.31236103 -0.12963092
   0.10522162 -0.4815724  -0.2093935   0.34740582 -0.60979587 -0.15877807]
 [ 0.15371156  0.01244636 -0.09840634 -0.32093546  0.06523462  0.18934932
   0.38859126 -0.3261706  -0.05138849  0.42713478  0.49390993  0.37013963]] (3, 12)
kernal: [[-0.47606698 -0.43589187 -0.5371355  -0.07337284  0.30526626 -0.18241835
  -0.03675252  0.2873094   0.33218485  0.24838251  0.17765659  0.4312396 ]
 [ 0.4007727   0.41280174  0.40750778 -0.6245315   0.6382301   0.42889225
   0.11961156 -0.6021105  -0.43556038  0.39798307  0.6390712   0.16719025]] (2, 12)
biase:  [0. 0. 0. 1. 1. 1. 0. 0. 0. 0. 0. 0.] (12,)
[array([[2., 1., 1., 0., 0., 0., 0., 1., 1., 0., 1., 0.],
       [1., 1., 0., 1., 1., 0., 0., 1., 1., 0., 0., 0.]], dtype=float32), array([[1., 0., 0., 1., 2., 1., 0., 1., 2., 0., 1., 0.],
       [1., 1., 0., 0., 2., 1., 0., 1., 2., 2., 0., 0.],
       [1., 0., 1., 2., 0., 1., 0., 1., 1., 0., 1., 0.]], dtype=float32), array([3., 1., 0., 1., 1., 0., 0., 1., 0., 2., 0., 0.], dtype=float32)]
tf.Tensor([[[0. 4. 0.]]], shape=(1, 1, 3), dtype=float32)
tf.Tensor([[0. 4. 0.]], shape=(1, 3), dtype=float32)
tf.Tensor([[0. 4. 1.]], shape=(1, 3), dtype=float32)

可以看出h=[0,4,0], c=[0,4,1]

2.3.  sequence-to-sequence 的例子

边写代码边学习之LSTM,DeepLearning总结,学习

代码

这就是我们的sequence-to-sequence的训练模型。 它利用了 Keras RNN 的三个关键特性:

return_state 构造函数参数,配置 RNN 层返回一个列表,其中第一个条目是输出,下一个条目是内部 RNN 状态。 这用于恢复编码器的状态。
inital_state 调用参数,指定 RNN 的初始状态。 这用于将编码器状态作为初始状态传递给解码器。
return_sequences 构造函数参数,将 RNN 配置为返回其完整的输出序列(而不是仅返回默认行为的最后一个输出)。 这在解码器中使用。

from keras.models import Model
from keras.layers import Input, LSTM, Dense

# Define an input sequence and process it.
encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]

# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens))
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the 
# return states in the training model, but we will use them in inference.
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
                                     initial_state=encoder_states)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

A ten-minute introduction to sequence-to-sequence learning in Keras文章来源地址https://www.toymoban.com/news/detail-643434.html

到了这里,关于边写代码边学习之LSTM的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Qt】边学边写之Qt教程(零基础)

    打开Qt Creator 界面选择 New Project或者选择菜单栏 【文件】-【新建文件或项目】菜单项 弹出New Project对话框,选择Qt Widgets Application, 选择【Choose】按钮,弹出如下对话框 设置项目名称和路径,按照向导进行下一步, 选择编译套件 向导会默认添加一个继承自QMainWindow的类,可

    2024年01月23日
    浏览(38)
  • 写点东西《边学边写7 种常见的攻击前端的安全性攻击》

    随着网络应用程序对业务运营变得越来越关键,它们也成为网络攻击更具吸引力的目标。但不幸的是,许多网络开发人员在构建安全前端方面落后于他们的后端和 DevOps 同行。这种差距增加了破坏性数据泄露的风险。 最近发生的事件,例如 Balancer Protocol 漏洞,揭示了攻击者在

    2024年02月02日
    浏览(44)
  • 机器学习之MATLAB代码--CNN预测 _LSTM预测 (十七)

    下列代码按照下列顺序依次: 1、 2、 3、 4、 结果 如有需要代码和数据的同学请在评论区发邮箱,一般一天之内会回复,请点赞+关注谢谢!!

    2024年02月11日
    浏览(40)
  • 机器学习之MATLAB代码--MATLAB量子粒子群优化LSTM超参数负荷预测(十三)

    代码按照下列顺序依次: 1、 2、 3、 4、 5、 6、 7、 8、 9、 10、 11、 结果 如有需要代码和数据的同学请在评论区发邮箱,一般一天之内会回复,请点赞+关注谢谢!!

    2024年02月11日
    浏览(45)
  • DeepLearning - 余弦退火热重启学习率 CosineAnnealingWarmRestartsLR

    欢迎关注我的CSDN:https://spike.blog.csdn.net/ 本文地址:https://spike.blog.csdn.net/article/details/134249925 CosineAnnealingWarmRestartsLR,即 余弦退火热重启学习率,周期性修改学习率的下降和上升,间隔幅度逐渐增大,避免模型的性能抖动。其中核心参数: optimizer 的参数, lr 学习率,默认学

    2024年02月19日
    浏览(42)
  • 【DeepLearning】Ubuntu中深度学习环境配置完整流程

    支持 cuda 的所有显卡型号: Link 查询显卡型号 即 Vendor ID:Device ID 为 10de:21c4,在浏览器或者 Link 中搜索。 填写显卡信息: Link 选择要下载的版本(可以选个新一点的 ) 运行 .run 文件 测试 参考官方文档: Link 选择要安装的版本: Link 先通过 nvidia-smi 查看驱动支持的 cuda 最高版本,

    2024年02月10日
    浏览(61)
  • 机器学习之LSTM的Python实现

    LSTM (长短期记忆人工神经网络),是一种可以学习长期依赖特殊的 RNN (循环神经网络)。 传统循环网络 RNN 虽然可以通过记忆体,实现短期记忆,进行连续数据的预测。但是当连续数据的序列变长时,会使展开时间步过长,反向传播更新参数时梯度要按时间步连续相乘,会

    2024年02月01日
    浏览(30)
  • 时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

    目录 引言 LSTM的预测效果图 LSTM机制 了解LSTM的结构 忘记门 输入门 输出门 LSTM的变体 只有忘记门的LSTM单元 独立循环(IndRNN)单元 双向RNN结构(LSTM) 运行代码 代码讲解 LSTM(Long Short-Term Memory)是一种常用的循环神经网络(RNN)模型,用于处理序列数据,具有记忆长短期的能力。

    2024年02月08日
    浏览(82)
  • 深度学习RNN,GRU,LSTM文本生成解码器的训练损失讲解(附代码)

    以下以GRU为例讲解RNN作为解码器时如何根据用户、商品特征信息 hidden 生成评价。 解码器部分代码如下: 在训练时,解码器会有两个输入:一是编码器提取的用户、商品特征,二是用户对商品的评价。 评价是文字,在训练开始前已经转换成了Token ID, 比如 I love this item , 每个

    2024年04月12日
    浏览(40)
  • 自制ESP8266 WIFI模块 ESP-01/阻抗匹配、射频天线高频电路学习笔记 射频模块天线匹配思路总结

    1 引言 存在决定意识。野火的指南者开发板板载ESP8266模块,一次比赛使用过ESP-01,并且这次比赛总结大会上老师说高集成度才算有技术含量,萌生了自制一个WIFI模块的想法,算是大学四年的心愿。春招在一次电话技术面试中坐了40min牢,被教训:做项目要把每个地方搞懂,否

    2024年02月16日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包