精华内容
下载资源
问答
  • 2018-06-15 01:37:52

      读这篇文章的时候,默认你已经对LSTM神经网络有了一个初步的认识,当你深入理解时,可能会对多层LSTM内部的隐藏节点数,有关cell的定义或者每一层的输入输出是什么样子的特别好奇,虽然神经网络就像是一个黑箱子一样,但是我们仍然试图去理解他们。
      我们所说的LSTM的cell就是这样子的一个结构:(图中标识的A就是一个cell,图中一共是三个cell)

       其中的X.t代表t时刻的输入,h.t代表这一时刻cell的输出,中间的cell中给我们展示了具体的数值传递计算的这么一个过程,不太清楚的同学可以下去自行查阅,就是三个门,首先是遗忘门,然后是更新门,最后是输出门。依靠三个门之间的记忆关系就可以实现对远距离信息的记忆

        那么重点来了,在多层的LSTM网络中,我们会经常见到说比如 hidden layer 1的隐藏节点数为100,hidden layer 2的隐藏节点数为64 等等,那么这些100、64分别代表了什么呢,在图里面又能怎么样表示呢?
       还是借鉴上一个图示,其中 h.t就是我们的隐藏节点(好神奇),你有可能会问 h.t就是一个节点啊,怎么回事100个节点数呢?(我这里没有合适的图了)联想一下CNN中的网络,如何实现从n个节点映射到m个节点的,靠的是矩阵之间的计算-权重W和偏置b,举一个简单的例子:输入X是一维的(比如时序信号),我的输出 h.t想要是100维的,大家知道我的每个cell里面是上图这样的结构,但是有一点不要忽视了,里面的计算都是要有参数的,便是W b的计算,所以我们可以设置W为1*100的矩阵,和输入X相乘以后,经过cell的操作,变成维度为100的输出。如果在上图的上面再加一层LSTM网络形成多层的呢?此时第二层的t时刻的输入就为 h.t了,他现在是100维的输入了,同样的道理,我们也可以经过矩阵W b的运算让其输出为64维。这样大家就明白了吧。
       这里有一个数据为一维,但是实际输入(数据的维度加上上一时刻状态的维度)为3维,cell输出为二维的网络,最后在cell的上面又加了一层,让最终的输出为一维。可以参考着理解一下。

    对于LSTM神经网络,大家肯定关心输入的格式是什么样子的,肯定的告诉大家格式为:
    
    
    [batchs,time_steps,input_dim]

       其中 batch就是我们在CNN里面常见到的batch定义一样,就是多少个样本数目; time_steps是LSTM特有的,他表示你有多少个时刻的输入,比如上图中就是t-1,t,t+1,三个时刻,所以这个时候的 time_steps就是3;input_dim就是输入的维度,这里的维度指的是每个时刻的输入向量的维度,比如上面说到的,一开始的输入X的input_dim就是一维的,第二层的input_dim就是100维。

    接下来会有两个案例讲解来帮助你更好的学习LSTM神经网络:
    1、minist手写集图像利用LSTM进行分类,分类问题,输入为多维

    2、利用LSTM进行异常信号的检测,预测问题,时序问题,输入为一维

    更多相关内容
  • feed_dict={X: test_data, Y: test_label})) 多层的也很简单,在单层的基础上用tf.compat.v1.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_nums)就可以完成多层LSTM网络的构建了 #-*- codeing = utf-8 -*- #@...
    #-*- codeing = utf-8 -*-
    #@Time :2021/5/20 19:40
    #@Author :Onion
    #@File :LSTMMNISTDemo.py
    #@Software :PyCharm
    
    import tensorflow as tf
    import os
    from tensorflow.examples.tutorials.mnist import input_data
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
    # 获取MNIST数据
    # tf.disable_v2_behavior()
    mnist = input_data.read_data_sets("./MNIST_data", one_hot=True)
    tf.compat.v1.disable_eager_execution()
    tf.compat.v1.reset_default_graph()
    
    # MNIST数据的大小为28*28,把输入的x当成28个时间段,每段内容为28个值
    # 这28个时序一次送入RNN中
    n_input = 28    # 序列的长度(时间段)
    n_steps = 28    # 序列的个数
    n_hidden = 128  # 隐藏层的个数(128个cell)
    n_classes = 10  # MNIST的输出为10个数,(0~9)表示分类
    
    # 参数设置
    learning_rate = 0.001
    training_iters = 100000
    batch_size = 128
    display_step = 10
    
    # 定义占位符
    X = tf.compat.v1.placeholder("float",[None,n_steps,n_input])
    Y = tf.compat.v1.placeholder("float",[None,n_classes])
    # 使用unstack将原始的输入28*28调整成具有28个元素的list,每个元素为1*28的数组
    X1 = tf.unstack(X, n_steps, 1)
    
    
    # 构建LSTM网络
    # num_units 表示LSTM单元中的单位数,即Cell的个数
    # RNN以前是非常难以训练的, 因为随时间传递的状态C如果有一个小的误差delta, 这个误差会在传递的过程中指数级别增加或者减少, 造成输出爆炸(Explosion)或者消失(Vanish)LSTM的forget GATE就是解决这个问题用的. 刚开始初始化成1, LSTM不会传递任何状态C, 因为forget GATE把C归零了. 这避免了刚开始训练就有输出爆炸或者消失的问题.
    lstm_cell = tf.compat.v1.nn.rnn_cell.BasicLSTMCell(num_units=n_hidden,forget_bias=1.0)
    
    # 输出
    outputs,states = tf.compat.v1.nn.static_rnn(lstm_cell,X1,dtype=tf.float32)
    
    # 全连接函数dense,将LSTM的Cell层的输出做一次全连接,并将激活函数设置为None表示线性激活
    # 全连接层之前的作用是提取特征、分类
    # 全连接层的每一个结点都与上一层的所有结点相连,用来把前边提取到的特征综合起来。
    pred = tf.compat.v1.layers.dense(outputs[-1],n_classes,activation=None)
    
    # 损失函数,(输出值与Y标签之间的损失值)
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=Y))
    # 优化器
    optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
    
    # 计算平均错误率
    correct_prediction = tf.equal(tf.argmax(pred,1), tf.argmax(Y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    init = tf.compat.v1.global_variables_initializer()
    with tf.compat.v1.Session() as sess:
        sess.run(init)
        step = 1
        # Keep training until reach max iterations
        while step * batch_size < training_iters:
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # Reshape data to get 28 seq of 28 elements
            batch_x = batch_x.reshape((batch_size, n_steps, n_input))
            # Run optimization op (backprop)
            sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y})
            if step % display_step == 0:
                # 计算批次数据的准确率
                acc = sess.run(accuracy, feed_dict={X: batch_x, Y: batch_y})
                # Calculate batch loss
                # 这里返回值不可以用loss来命名变量,因为计算loss的时候必须是一个Tensor,如果把loss改了,返回的就是一个float,会报错
                newloss = sess.run(loss, feed_dict={X: batch_x, Y: batch_y})
                print ("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
                      "{:.5f}".format(newloss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))
            step += 1
        print (" Finished!")
    
        # 计算准确率 for 128 mnist test images
        test_len = 128
        test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
        test_label = mnist.test.labels[:test_len]
        print ("Testing Accuracy:", \
            sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))
    

    在这里插入图片描述
    多层的也很简单,在单层的基础上用tf.compat.v1.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_nums)就可以完成多层LSTM网络的构建了

    #-*- codeing = utf-8 -*-
    #@Time :2021/5/21 0:31
    #@Author :Onion
    #@File :MultiLSTMMNISTDemo.py
    #@Software :PyCharm
    
    import tensorflow as tf
    import os
    from tensorflow.examples.tutorials.mnist import input_data
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
    # 获取MNIST数据
    # tf.disable_v2_behavior()
    mnist = input_data.read_data_sets("./MNIST_data", one_hot=True)
    tf.compat.v1.disable_eager_execution()
    tf.compat.v1.reset_default_graph()
    
    # MNIST数据的大小为28*28,把输入的x当成28个时间段,每段内容为28个值
    # 这28个时序一次送入RNN中
    n_input = 28    # 序列的长度(时间段)
    n_steps = 28    # 序列的个数
    n_hidden = 128  # 单个隐藏层的cell的个数(128个cell)
    n_classes = 10  # MNIST的输出为10个数,(0~9)表示分类
    hidden_layer_nums = 3# 三层LSTM网络
    
    # 参数设置
    learning_rate = 0.001
    training_iters = 100000
    batch_size = 128    # 每一批128张图片
    display_step = 10 # 每训练10次打印一次结果
    
    # 定义占位符
    X = tf.compat.v1.placeholder("float",[None,n_steps,n_input])
    Y = tf.compat.v1.placeholder("float",[None,n_classes])
    # 使用unstack将原始的输入28*28调整成具有28个元素的list,每个元素为1*28的数组
    X1 = tf.unstack(X, n_steps, 1)
    
    
    # 构建LSTM网络
    # num_units 表示LSTM单元中的单位数,即Cell的个数
    # RNN以前是非常难以训练的, 因为随时间传递的状态C如果有一个小的误差delta, 这个误差会在传递的过程中指数级别增加或者减少, 造成输出爆炸(Explosion)或者消失(Vanish)LSTM的forget GATE就是解决这个问题用的. 刚开始初始化成1, LSTM不会传递任何状态C, 因为forget GATE把C归零了. 这避免了刚开始训练就有输出爆炸或者消失的问题.
    lstm_cell = tf.compat.v1.nn.rnn_cell.BasicLSTMCell(num_units=n_hidden,forget_bias=1.0)
    
    # 构建3层LSTM网络
    lstm_cells = tf.compat.v1.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_nums)
    # 输出
    outputs,states = tf.compat.v1.nn.static_rnn(lstm_cells,X1,dtype=tf.float32)
    
    # 全连接函数dense,将LSTM的Cell层的输出做一次全连接,并将激活函数设置为None表示线性激活
    # 全连接层之前的作用是提取特征、分类
    # 全连接层的每一个结点都与上一层的所有结点相连,用来把前边提取到的特征综合起来。
    pred = tf.compat.v1.layers.dense(outputs[-1],n_classes,activation=None)
    # 损失函数,(输出值与Y标签之间的损失值)
    
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=Y))
    # 优化器
    optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
    
    # 计算平均错误率
    # 【Tensorflow】 tf.equal(tf.argmax(y, 1),tf.argmax(y_, 1))用法
    # 作用:输出正确的预测结果
    # 利用tf.argmax()按行求出真实值y_、预测值y最大值的下标,用tf.equal()求出真实值和预测值相等的数量,也就是预测结果正确的数量,tf.argmax()和tf.equal()一般是结合着用
    correct_prediction = tf.equal(tf.argmax(pred,1), tf.argmax(Y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    init = tf.compat.v1.global_variables_initializer()
    with tf.compat.v1.Session() as sess:
        sess.run(init)
        step = 1
        # Keep training until reach max iterations
        while step * batch_size < training_iters:
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # Reshape data to get 28 seq of 28 elements
            batch_x = batch_x.reshape((batch_size, n_steps, n_input))
            # Run optimization op (backprop)
            # 在run执行的时候,内部做了128次运算,每一次取batch_x(128)个中的一个,传入X,并unpack成X1,,做这样的运算在内部进行了128次
            sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y})
            if step % display_step == 0:
                # 计算批次数据的准确率
                acc = sess.run(accuracy, feed_dict={X: batch_x, Y: batch_y})
                # Calculate batch loss
                # 这里返回值不可以用loss来命名变量,因为计算loss的时候必须是一个Tensor,如果把loss改了,返回的就是一个float,会报错
                newloss = sess.run(loss, feed_dict={X: batch_x, Y: batch_y})
                print ("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
                      "{:.5f}".format(newloss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))
            step += 1
        print (" Finished!")
    
        # 计算准确率 for 128 mnist test images
        test_len = 128
        test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
        test_label = mnist.test.labels[:test_len]
        print ("Testing Accuracy:", \
            sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))
    

    在这里插入图片描述
    当然,还可以将单层的GRU网络和多层的LSTM网络连接起来构成一个多层的RNN网络

    #-*- codeing = utf-8 -*-
    #@Time :2021/5/21 0:56
    #@Author :Onion
    #@File :MixRNNDemo.py
    #@Software :PyCharm
    
    #-*- codeing = utf-8 -*-
    #@Time :2021/5/20 19:40
    #@Author :Onion
    #@File :LSTMMNISTDemo.py
    #@Software :PyCharm
    
    # 构建GRU和LSTM混合的网络
    import tensorflow as tf
    import os
    from tensorflow.examples.tutorials.mnist import input_data
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
    # 获取MNIST数据
    # tf.disable_v2_behavior()
    mnist = input_data.read_data_sets("./MNIST_data", one_hot=True)
    tf.compat.v1.disable_eager_execution()
    tf.compat.v1.reset_default_graph()
    
    # MNIST数据的大小为28*28,把输入的x当成28个时间段,每段内容为28个值
    # 这28个时序一次送入RNN中
    n_input = 28    # 序列的长度(时间段)
    n_steps = 28    # 序列的个数
    n_hidden = 128  # 隐藏层的cell的个数(128个cell)
    n_classes = 10  # MNIST的输出为10个数,(0~9)表示分类
    
    # 参数设置
    learning_rate = 0.001
    training_iters = 100000
    batch_size = 128    # 每一批128张图片
    display_step = 10 # 每训练10次打印一次结果
    hidden_layer_nums =3
    # 定义占位符
    X = tf.compat.v1.placeholder("float",[None,n_steps,n_input])
    Y = tf.compat.v1.placeholder("float",[None,n_classes])
    # 使用unstack将原始的输入28*28调整成具有28个元素的list,每个元素为1*28的数组
    X1 = tf.unstack(X, n_steps, 1)
    
    
    # 构建单层GRU网络
    gru_cell = tf.compat.v1.nn.rnn_cell.GRUCell(num_units=n_hidden*2)
    # 构建3层LSTM网络
    # num_units 表示LSTM单元中的单位数,即Cell的个数
    # RNN以前是非常难以训练的, 因为随时间传递的状态C如果有一个小的误差delta, 这个误差会在传递的过程中指数级别增加或者减少, 造成输出爆炸(Explosion)或者消失(Vanish)LSTM的forget GATE就是解决这个问题用的. 刚开始初始化成1, LSTM不会传递任何状态C, 因为forget GATE把C归零了. 这避免了刚开始训练就有输出爆炸或者消失的问题.
    lstm_cell = tf.compat.v1.nn.rnn_cell.BasicLSTMCell(num_units=n_hidden,forget_bias=1.0)
    lstm_cells = tf.compat.v1.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_nums)
    
    # 将3层LSTM网络和单层的GRU网络连接成一个4层的RNN网络
    RNN_cells =  tf.compat.v1.nn.rnn_cell.MultiRNNCell([lstm_cells.gru])
    # 输出
    outputs,states = tf.compat.v1.nn.static_rnn(lstm_cell,X1,dtype=tf.float32)
    
    # 全连接函数dense,将LSTM的Cell层的输出做一次全连接,并将激活函数设置为None表示线性激活
    # 全连接层之前的作用是提取特征、分类
    # 全连接层的每一个结点都与上一层的所有结点相连,用来把前边提取到的特征综合起来。
    pred = tf.compat.v1.layers.dense(outputs[-1],n_classes,activation=None)
    
    # 损失函数,(输出值与Y标签之间的损失值)
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=Y))
    # 优化器
    optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
    
    # 计算平均错误率
    # 【Tensorflow】 tf.equal(tf.argmax(y, 1),tf.argmax(y_, 1))用法
    # 作用:输出正确的预测结果
    # 利用tf.argmax()按行求出真实值y_、预测值y最大值的下标,用tf.equal()求出真实值和预测值相等的数量,也就是预测结果正确的数量,tf.argmax()和tf.equal()一般是结合着用
    correct_prediction = tf.equal(tf.argmax(pred,1), tf.argmax(Y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    init = tf.compat.v1.global_variables_initializer()
    with tf.compat.v1.Session() as sess:
        sess.run(init)
        step = 1
        # Keep training until reach max iterations
        while step * batch_size < training_iters:
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # Reshape data to get 28 seq of 28 elements
            batch_x = batch_x.reshape((batch_size, n_steps, n_input))
            # Run optimization op (backprop)
            # 在run执行的时候,内部做了128次运算,每一次取batch_x(128)个中的一个,传入X,并unpack成X1,,做这样的运算在内部进行了128次
            sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y})
            if step % display_step == 0:
                # 计算批次数据的准确率
                acc = sess.run(accuracy, feed_dict={X: batch_x, Y: batch_y})
                # Calculate batch loss
                # 这里返回值不可以用loss来命名变量,因为计算loss的时候必须是一个Tensor,如果把loss改了,返回的就是一个float,会报错
                newloss = sess.run(loss, feed_dict={X: batch_x, Y: batch_y})
                print ("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
                      "{:.5f}".format(newloss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))
            step += 1
        print (" Finished!")
    
        # 计算准确率 for 128 mnist test images
        test_len = 128
        test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
        test_label = mnist.test.labels[:test_len]
        print ("Testing Accuracy:", \
            sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))
    

    在这里插入图片描述

    展开全文
  • 多层LSTM

    2021-07-02 10:49:28
    以上是按时间展开的堆叠循环神经网络。一般的,我们定义 ht(l)为在时刻 t 时第 l 层的隐状态,则它是由时刻t-1第l层的隐状态与时刻t第l-1层的隐状态共同决定: 其中U(l)、W(l)是权重矩阵,b(l)是偏置,ht(0) = .....

    我们扩展了单层 RNN,使它们具有两层。对于原始的单层版本,请参阅上一章简介中的绘图。左侧架构说明了使用多层 RNN 预测输出序列中的一个输出的方法。正确的架构显示了使用多层 RNN 预测输出序列的方法,该输出序列使用输出作为输入。
    比如下面的例子
    以上是按时间展开的堆叠循环神经网络。一般的,我们定义 ht(l)为在时刻 t 时第 l 层的隐状态,则它是由时刻t-1第l层的隐状态与时刻t第l-1层的隐状态共同决定:
    其中U (l) 、W (l) 是权重矩阵,b (l) 是偏置,h t (0) = x
    我们可以看到,如果一共有T步,那么会有T个输出:y 1 ,y 2 ,...,y T 。但一般只取最后一个输出y T ,相应的隐状态也取最后时刻最后一个循环层的隐状态,比如上面就是取h T (3) ,这是代码中需要注意的地方。
    参考链接:
    展开全文
  • 再给出一个多层LSTM的例子,取自Keras文档。 from keras.models import Sequential from keras.layers import LSTM, Dense import numpy as np data_dim = 16 timesteps = 8 num_classes = 10 # 期望输入数据尺寸: ...

    首先明确一点,RNN单元的输入输出的维度,点击参考keras.layers.RNN()文档

    输入尺寸

    3D 张量,尺寸为 (batch_size, timesteps, input_dim)。

    输出尺寸

    1. 如果 return_state:返回张量列表。 第一个张量为输出。剩余的张量为最后的状态, 每个张量的尺寸为 (batch_size, units)。
    2. 如果 return_sequences:返回 3D 张量, 尺寸为 (batch_size, timesteps, units)。
    3. 否则,返回尺寸为 (batch_size, units) 的 2D 张量。
      每层LSTM的输入是前一层的LSTM的输出,所以自第二层LSTM开始,input_shape参数是可以忽略的

    以双层的LSTM为例

    #参数
    time_steps = 10
    features = 2
    input_shape = [time_steps, features]
    batch_size = 32
    model = Sequential()
    model.add(LSTM(64, input_shape=input_shape,  return_sequences=True))
    model.add(LSTM(32,input_shape=input_shape))
    model.summary()
    >>>
    Model: "sequential_1"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    lstm_2 (LSTM)                (None, 10, 64)            17152     
    _________________________________________________________________
    lstm_3 (LSTM)                (None, 32)                12416     
    =================================================================
    Total params: 29,568
    Trainable params: 29,568
    Non-trainable params: 0
    

    调整模型,查看输出

    model.add(LSTM(32,input_shape=(10000,10000)))	#调整了第二层的input_shape
    Model: "sequential_2"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    lstm_4 (LSTM)                (None, 10, 64)            17152     
    _________________________________________________________________
    lstm_5 (LSTM)                (None, 32)                12416     
    =================================================================
    Total params: 29,568
    Trainable params: 29,568
    Non-trainable params: 0
    

    可以看到模型的输出维度并未改变。
    如果第二层LSTM的return_sequences=True,会怎样?

    model.add(LSTM(32,return_sequences=True))
    Model: "sequential_3"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    lstm_6 (LSTM)                (None, 10, 64)            17152     
    _________________________________________________________________
    lstm_7 (LSTM)                (None, 10, 32)            12416     
    =================================================================
    Total params: 29,568
    Trainable params: 29,568
    Non-trainable params: 0
    

    从结果发现,两者之间的时间步都是10,也就是第一层的输入维度,也就是说,32并不是第二层LSTM单元的个数,而应该是每个时间步X的维度为32.第二层LSTM单元的个数仍然为10个。如果要更改时间步的数量,可使用masking层,点击见文档Masking
    在每个时间步,LSTM-64将传递给LSTM-32形状为[batch_size,time_step,input_dim]的向量
    从我们的模型来看,Input应该就是10,对应着我们的时间步,而每个时间步对应着64,32个特征。
    看到这里,不禁要问,那输出中的第三个数,也就是我们的64,32是什么?答案是我们的每个时间步对应的特征的个数。
    那是怎么从64变为32的呢?让我们从单个LSTM单元说起。

    我们可以简单的将LSTM内部的各种计算想象成全连接的之间的矩阵计算。

    所以units代表的不是一层单元的个数,而是单元内部隐藏层的大小。
    对于LSTM而言,每个单元有3个门,对应了4个激活函数(3个sigmoid,一个tanh)。也就是说有4个神经元数量为32的前馈网络层。
    在这里插入图片描述
    对于LSTM的计算过程,我们这里举一个简单的例子:(此例转自对LSTM层的参数units 的理解)

    假如我们样本的每一句话包含5个单词,每个单词用16维的词向量表示。对于LSTM(units=32),我们可以把LSTM内部的计算过程计算过程简化为:

    Y=XW,这里X为(1,16)的向量,W为(16,32)的矩阵,所以运用矩阵乘法,将16维的X转化为32维的向量。
    如下图所示
    在这里插入图片描述
    另外一张表示LSTM内部计算的图示。

    在这里插入图片描述

    再给出一个多层LSTM的例子,取自Keras文档。
    图为下述代码的模型结构示意图

    from keras.models import Sequential
    from keras.layers import LSTM, Dense
    import numpy as np
    
    data_dim = 16
    timesteps = 8
    num_classes = 10
    
    # 期望输入数据尺寸: (batch_size, timesteps, data_dim)
    model = Sequential()
    model.add(LSTM(32, return_sequences=True,
                   input_shape=(timesteps, data_dim)))  # 返回维度为 32 的向量序列
    model.add(LSTM(32, return_sequences=True))  # 返回维度为 32 的向量序列
    model.add(LSTM(32))  # 返回维度为 32 的单个向量
    model.add(Dense(10, activation='softmax'))
    
    model.compile(loss='categorical_crossentropy',
                  optimizer='rmsprop',
                  metrics=['accuracy'])
    
    # 生成虚拟训练数据
    x_train = np.random.random((1000, timesteps, data_dim))
    y_train = np.random.random((1000, num_classes))
    
    # 生成虚拟验证数据
    x_val = np.random.random((100, timesteps, data_dim))
    y_val = np.random.random((100, num_classes))
    
    model.fit(x_train, y_train,
              batch_size=64, epochs=5,
              validation_data=(x_val, y_val))
    

    参考文章:

    1. Keras 基于栈式 LSTM 的序列分类
    2. StackOverflow-在栈式LSTM中,每层LSTM的输入是什么?
    3. 对LSTM层的参数units 的理解
    展开全文
  • 多层LSTM的坑:如何定义多层LSTM

    万次阅读 2018-08-24 21:07:24
    多层LSTM定义的两种方式,其中方式2是正确的,方式1挥出现错误: 多层LSTM需要每次都定义一个新的BasicCell, 而不是定义一个BasicCell之后多次调用。 def lstm_model(X,Y,is_training): ###方式1:错误!! #...
  • Keras实现多层LSTM模型进行时间序列预测
  • 多层 LSTM的实现

    千次阅读 2019-02-13 20:10:51
    tensorflow笔记:多层LSTM代码分析 但是感觉这些例子还是太复杂了,所以这里写了个比较简单的版本,虽然不优雅,但是还是比较容易理解。 如果你想了解 LSTM 的原理的话(前提是你已经理解了普...
  • 单层LSTM和多层LSTM的输入与输出

    万次阅读 多人点赞 2020-06-10 11:44:09
    是单层LSTM的输入输出结构。其实它是由一个LSTM单元的一个展开,如下所示: 所以从左到右的每个LSTM Block只是对应一个时序中的不同的步。 在第一个中,输入的时序特征有S个,长度记作:seq_len,每个...
  • 堆叠LSTM(Stacked LSTM)是此模型的扩展,具有多个LSTM层。 文章结构 为什么要堆叠LSTM? 堆叠LSTM结构 堆叠LSTM的Tensorflow实现 为什么要堆叠LSTM? 堆叠LSTM使模型深度更深,提取的特征更深层次,从而使预测...
  • lstm结构_LSTM模型结构的可视化

    千次阅读 2020-11-20 17:25:00
    2、LSTM网络 3、LSTM的输入结构 4、pytorch中的LSTM 4.1 pytorch中定义的LSTM模型 4.2 喂给LSTM的数据格式 4.3 LSTM的output格式 5、LSTM和其他网络组合最近在学习LSTM应用在时间序列的预测上,但是遇到一个很大的...
  • TensorFlow入门(五)多层 LSTM 通俗易懂版

    万次阅读 多人点赞 2017-03-10 12:28:59
    欢迎转载,但请务必注明原文出处及作者信息。@author: huangyongye @creat_date: 2017-03-09 前言: 根据我本人学习 TensorFlow 实现 LSTM 的经历,发现网上... tensorflow笔记:多层LSTM代码分析 但是感觉这些例子还
  • “他山之石,可以攻玉”,站在巨人的肩膀才能看得更高,走得更远。在科研的道路上,更需借助...作者:知乎—master苏地址:https://www.zhihu.com/people/zhenyu22最近在学习LSTM应用在时间序列的预测上,但是遇到...
  • 机器翻译模型一多层LSTM__Pytorch实现

    千次阅读 2021-04-10 14:31:44
    其中源端与目标端的网络深度均为4层(原文也是4层) import torch.nn as nn class Encoder(nn.Module): #src_vocab_size德语词汇表大小,emb_model词向量维度,hidden_size隐藏向量维度,n_layers lstm深度 def __...
  • 前言循环神经网络(recurrent neural networks, RNNs)及其改进算法长短期记忆网络(Long Short-Term Memory, LSTM)能够很好地对时序数据进行建模,本文实现了两层 LSTM 对 MNIST 数据集进行分类预测以及结果可视化...
  • 利用PTB数据实现多层LSTM网络

    千次阅读 2018-07-18 09:54:48
    tensorflow笔记:多层LSTM代码分析 标签(空格分隔): tensorflow笔记 tensorflow笔记系列: (一) tensorflow笔记:流程,概念和简单代码注释 (二) tensorflow笔记:多层CNN代码分析 (三) tensorflow笔记:...
  • tf实现多层LSTM

    千次阅读 2018-02-28 17:46:37
    # 在 tf 1.0.0 版本中,可以使用上面的 三个步骤创建多层 lstm, 但是在 tf 1.2.1 版本中,可以通过下面方式来创建 def lstm_cell(): cell = rnn.LSTMCell(hidden_size, reuse=tf.get_variable_scope().reuse) ...
  • tensorflow笔记:多层LSTM代码分析

    万次阅读 多人点赞 2016-10-08 17:33:34
    (二) tensorflow笔记:多层CNN代码分析之前讲过了tensorflow中CNN的示例代码,现在我们来看RNN的代码。不过好像官方只给了LSTM的代码。那么我们就来看LSTM吧。LSTM的具体原理就不讲了,可以参见深度学习笔记(五):...
  • RNN、LSTM、GRU、多层LSTM、Bi-LSTM

    千次阅读 2020-03-16 21:35:58
    有些时候,主要考虑的是哪些输入,有时候,考虑的是(输入,输出)之间的模型; 一、RNN f,g 就是普通的激活函数,可能是tanh...三、多层RNN/LSTM 多层RNN中,第一层的输入是Ht1~ (Xt, Ht-1),后面层的输入不再...
  • TF之LSTM:利用多层LSTM算法对MNIST手写数字识别数据集进行多分类 目录 设计思路 实现代码 设计思路 更新…… 实现代码 # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np...
  • The MNIST data-set MNIST data-set由一些黑白照片集合组成,每张照片包含手写...MNIST data-set可通过网络在MNIST数据库中获得。 为方便下载数据,你可以使用input_data.py脚本,该文件也已放在github上。当在Tenso...
  • LSTM的总结

    千次阅读 2020-08-18 15:41:02
    LSTM是NLP中比较经典的算法,在百科里的介绍是:长短期记忆网络LSTM,Long Short-Term Memory)是一种时间循环神经网络,是为了解决一般的RNN(循环神经网络)存在的长期依赖问题而专门设计出来的,所有的RNN都...
  • 其他内容 ...   输入格式:batch_size*784改成batch_size*28*28,28个序列,内容是一行的28个灰度数值。 让神经网络逐行扫描一个手写字体图案,总结各行特征,...网络定义:单独定义一个获取单元的函数,便于在Mult...
  • 多层LSTM项目 2. 项目数据: 使用text8.zip Linux下下载指令 curl http://mattmahoney.net/dc/text8.zip &amp;amp;amp;amp;gt; text8.zip 3. 命令行运行指令 python3.5 ptb_word_lm.py --data_path=simple...
  • pytorch搭建LSTM神经网络预测电力负荷

    千次阅读 2022-05-02 19:54:28
    利用pytorch搭建了一个用于电力负荷预测的LSTM神经网络
  • 堆叠多层bi-lstm的方法

    千次阅读 2019-01-07 10:13:52
    自己在搭建多层双向lstm网络的时候,看了很多的资料,一开始的时候搭建都是不成功的,后来看了官方的资料还有一些博客,使用了2种方法搭建成功了! 方法1: n_hidden_units=50 # 隐藏层神经元数目 num_layers=3 #...
  • RNN和LSTM网络结构

    2021-05-12 15:27:32
    RNN 网络是一种基础的多层反馈神经网络,该神经网络的节点定向连接成环,其内部状态可以展示动态时序行为。相比于前馈神经网络,该网络内部具有很强的记忆性,它可以利用它内部的记忆来处理任意时序的输入序列。因为...
  • 长短期记忆网络——通常称为“LSTM”——是一种特殊的RNN递归神经网络,能够学习长期依赖关系。 视频:LSTM神经网络架构和工作原理及其在Python中的预测应用 LSTM神经网络架构和原理及其在Python中的预测应用 ...

空空如也

空空如也

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

多层lstm网络图