精华内容
下载资源
问答
  • 多层LSTM

    2019-11-24 07:32:58
    多层LSTM

    多层LSTM

    链接: 数据集 提取码: 6cgu

    《Sequence to Sequence Learning with Neural Networks》
    使用多层LSTM的Seq2Seq模型
    作者:llya Sutskever ,Oriol Vinyals,Quoc V.Le
    单位:Google
    发表会议及时间:NIPS 2014

    一 论文导读

    1.机器翻译简介
    2.机器翻译相关方法
    3.前期知识

    1.机器翻译简介

    2.机器翻译相关方法

    3.前期知识

    二 论文精读

    三 代码实现

    四 问题思索

    展开全文
  • 多层LSTM的坑:如何定义多层LSTM

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

     

    多层LSTM定义的两种方式,其中方式2是正确的,方式1会出现错误:

    多层LSTM需要每次都定义一个新的BasicCell,    而不是定义一个BasicCell之后多次调用。

    def lstm_model(X,Y,is_training):
        ###方式1:错误!!
        #cell_unit = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
        #cell = tf.nn.rnn_cell.MultiRNNCell([
        #    cell_unit for _ in range(NUM_LAYERS)])
        ###方式2:正确
        cell = tf.nn.rnn_cell.MultiRNNCell([
            tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
               for _ in range(NUM_LAYERS)])
    
    
    
    
        outputs, _ = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)
    
        output = outputs[:,-1,:]
    
        predictions = tf.contrib.layers.fully_connected(
            output,1,activation_fn=None )
        if not is_training:
            return predictions,None,None
    
        loss = tf.losses.mean_squared_error(labels=Y,predictions=predictions)
    
        train_op = tf.contrib.layers.optimize_loss(
            loss,tf.train.get_global_step(),
            optimizer = 'Adagrad',learning_rate = 0.1)
    
        return predictions,loss,train_op

    完整示例程序的代码:

    #-*-coding:utf-8-*-
    import numpy as np
    import tensorflow as tf
    
    import matplotlib as mpl
    mpl.use('Agg')
    from matplotlib import pyplot as plt
    
    HIDDEN_SIZE = 30
    NUM_LAYERS = 2
    
    TIME_STEPS = 10
    TRAINING_STEPS = 10000
    BATCH_SIZE = 32
    
    TRAINING_EXAMPLES=10000
    TESTING_EXAMPLES = 1000
    SAMPLE_GAP = 0.01
    
    def generate_data(seq):
        X=[]#ninihaoniaho zh
        Y=[]
    
        for i in range(len(seq)-TIME_STEPS):
            X.append([seq[i:i+TIME_STEPS]])
            Y.append([seq[i+TIME_STEPS]])
    
        return np.array(X,dtype=np.float32),np.array(Y,dtype=np.float32)
    
    def lstm_model(X,Y,is_training):
        # cell_unit = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
        cell = tf.nn.rnn_cell.MultiRNNCell([
            tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
               for _ in range(NUM_LAYERS)])
        outputs, _ = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)
    
        output = outputs[:,-1,:]
    
        predictions = tf.contrib.layers.fully_connected(
            output,1,activation_fn=None )
        if not is_training:
            return predictions,None,None
    
        loss = tf.losses.mean_squared_error(labels=Y,predictions=predictions)
    
        train_op = tf.contrib.layers.optimize_loss(
            loss,tf.train.get_global_step(),
            optimizer = 'Adagrad',learning_rate = 0.1)
    
        return predictions,loss,train_op
    
    
    
    def train(sess,train_X,train_Y):
        ds=tf.data.Dataset.from_tensor_slices((train_X,train_Y))
        ds = ds.repeat().shuffle(1000).batch(BATCH_SIZE)
        X,Y = ds.make_one_shot_iterator().get_next()
    
        ### use model get result
        with tf.variable_scope('model'):
            predictions,loss,train_op = lstm_model(X,Y,True)
    
        sess.run(tf.global_variables_initializer())
        for i in range(TRAINING_STEPS):
            _,l = sess.run([train_op,loss])
            if i%100 ==0:
                print('train step:'+str(i) + ',loss:'+str(l))
    
    def run_eval(sess, test_X, test_y):
        # print('------------runned')
        # 将测试数据以数据集的方式提供给计算图。
        ds = tf.data.Dataset.from_tensor_slices((test_X, test_y))
        ds = ds.batch(1)
        X, y = ds.make_one_shot_iterator().get_next()
    
        # 调用模型得到计算结果。这里不需要输入真实的y值。
        with tf.variable_scope("model", reuse=True):
            prediction, _, _ = lstm_model(X, [0.0], False)
    
        # 将预测结果存入一个数组。
        predictions = []
        labels = []
        for i in range(TESTING_EXAMPLES):
            p, l = sess.run([prediction, y])
            predictions.append(p)
            labels.append(l)
    
        # 计算rmse作为评价指标。
        predictions = np.array(predictions).squeeze()
        labels = np.array(labels).squeeze()
        rmse = np.sqrt(((predictions - labels) ** 2).mean(axis=0))
        print("Root Mean Square Error is: %f" % rmse)
    
    
        # 对预测的sin函数曲线进行绘图。
        plt.figure()
        plt.plot(predictions, label='predictions')
        plt.plot(labels, label='real_sin')
        plt.legend()
        plt.show()
    
    
    test_start = (TRAINING_EXAMPLES+TIME_STEPS)*SAMPLE_GAP
    test_end = test_start + (TESTING_EXAMPLES+TIME_STEPS)*SAMPLE_GAP
    
    train_X,train_Y = generate_data(np.sin(np.linspace(
        test_start,test_end,TRAINING_EXAMPLES+TIME_STEPS,dtype=np.float32)))
    test_X,test_Y = generate_data(np.sin(np.linspace(
        test_start,test_end,TESTING_EXAMPLES+TIME_STEPS,dtype=np.float32)))
    
    with tf.Session() as sess:
        train(sess,train_X,train_Y)
        run_eval(sess,test_X,test_Y)
    
    
    
    
    

     

     

    展开全文
  • TensorFlow入门(五)多层 LSTM 通俗易懂版

    万次阅读 多人点赞 2017-03-10 12:28:59
    欢迎转载,但请务必注明原文出处及作者信息。@author: huangyongye @creat_date: 2017-03-09 前言: 根据我本人学习 TensorFlow 实现 LSTM 的经历,发现网上... tensorflow笔记:多层LSTM代码分析 但是感觉这些例子还

    欢迎转载,但请务必注明原文出处及作者信息。

    @author: huangyongye
    @creat_date: 2017-03-09

    前言: 根据我本人学习 TensorFlow 实现 LSTM 的经历,发现网上虽然也有不少教程,其中很多都是根据官方给出的例子,用多层 LSTM 来实现 PTBModel 语言模型,比如:
    tensorflow笔记:多层LSTM代码分析
    但是感觉这些例子还是太复杂了,所以这里写了个比较简单的版本,虽然不优雅,但是还是比较容易理解。

    如果你想了解 LSTM 的原理的话(前提是你已经理解了普通 RNN 的原理),可以参考我前面翻译的博客:
    (译)理解 LSTM 网络 (Understanding LSTM Networks by colah)

    如果你想了解 RNN 原理的话,可以参考 AK 的博客:
    The Unreasonable Effectiveness of Recurrent Neural Networks

    很多朋友提到多层怎么理解,所以自己做了一个示意图,希望帮助初学者更好地理解 多层RNN.

    SouthEast
    图1 3层RNN按时间步展开

    本例不讲原理。通过本例,你可以了解到单层 LSTM 的实现,多层 LSTM 的实现。输入输出数据的格式。 RNN 的 dropout layer 的实现。

    # -*- coding:utf-8 -*-
    import tensorflow as tf
    import numpy as np
    from tensorflow.contrib import rnn
    from tensorflow.examples.tutorials.mnist import input_data
    
    # 设置 GPU 按需增长
    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    sess = tf.Session(config=config)
    
    # 首先导入数据,看一下数据的形式
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
    print mnist.train.images.shape
    Extracting MNIST_data/train-images-idx3-ubyte.gz
    Extracting MNIST_data/train-labels-idx1-ubyte.gz
    Extracting MNIST_data/t10k-images-idx3-ubyte.gz
    Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
    (55000, 784)
    

    1. 首先设置好模型用到的各个超参数

    lr = 1e-3
    # 在训练和测试的时候,我们想用不同的 batch_size.所以采用占位符的方式
    batch_size = tf.placeholder(tf.int32)  # 注意类型必须为 tf.int32
    # 在 1.0 版本以后请使用 :
    # keep_prob = tf.placeholder(tf.float32, [])
    # batch_size = tf.placeholder(tf.int32, [])
    
    # 每个时刻的输入特征是28维的,就是每个时刻输入一行,一行有 28 个像素
    input_size = 28
    # 时序持续长度为28,即每做一次预测,需要先输入28行
    timestep_size = 28
    # 每个隐含层的节点数
    hidden_size = 256
    # LSTM layer 的层数
    layer_num = 2
    # 最后输出分类类别数量,如果是回归预测的话应该是 1
    class_num = 10
    
    _X = tf.placeholder(tf.float32, [None, 784])
    y = tf.placeholder(tf.float32, [None, class_num])
    keep_prob = tf.placeholder(tf.float32)

    2. 开始搭建 LSTM 模型,其实普通 RNNs 模型也一样

    # 把784个点的字符信息还原成 28 * 28 的图片
    # 下面几个步骤是实现 RNN / LSTM 的关键
    ####################################################################
    # **步骤1:RNN 的输入shape = (batch_size, timestep_size, input_size) 
    X = tf.reshape(_X, [-1, 28, 28])
    
    # **步骤2:定义一层 LSTM_cell,只需要说明 hidden_size, 它会自动匹配输入的 X 的维度
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
    
    # **步骤3:添加 dropout layer, 一般只设置 output_keep_prob
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    
    # **步骤4:调用 MultiRNNCell 来实现多层 LSTM
    mlstm_cell = rnn.MultiRNNCell([lstm_cell] * layer_num, state_is_tuple=True)
    
    # **步骤5:用全零来初始化state
    init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)
    
    # **步骤6:方法一,调用 dynamic_rnn() 来让我们构建好的网络运行起来
    # ** 当 time_major==False 时, outputs.shape = [batch_size, timestep_size, hidden_size] 
    # ** 所以,可以取 h_state = outputs[:, -1, :] 作为最后输出
    # ** state.shape = [layer_num, 2, batch_size, hidden_size], 
    # ** 或者,可以取 h_state = state[-1][1] 作为最后输出
    # ** 最后输出维度是 [batch_size, hidden_size]
    # outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
    # h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]
    
    # *************** 为了更好的理解 LSTM 工作原理,我们把上面 步骤6 中的函数自己来实现 ***************
    # 通过查看文档你会发现, RNNCell 都提供了一个 __call__()函数(见最后附),我们可以用它来展开实现LSTM按时间步迭代。
    # **步骤6:方法二,按时间步展开计算
    outputs = list()
    state = init_state
    with tf.variable_scope('RNN'):
        for timestep in range(timestep_size):
            if timestep > 0:
                tf.get_variable_scope().reuse_variables()
            # 这里的state保存了每一层 LSTM 的状态
            (cell_output, state) = mlstm_cell(X[:, timestep, :], state)
            outputs.append(cell_output)
    h_state = outputs[-1]

    3. 设置 loss function 和 优化器,展开训练并完成测试

    # 上面 LSTM 部分的输出会是一个 [hidden_size] 的tensor,我们要分类的话,还需要接一个 softmax 层
    # 首先定义 softmax 的连接权重矩阵和偏置
    # out_W = tf.placeholder(tf.float32, [hidden_size, class_num], name='out_Weights')
    # out_bias = tf.placeholder(tf.float32, [class_num], name='out_bias')
    # 开始训练和测试
    W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
    bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
    y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)
    
    
    # 损失和评估函数
    cross_entropy = -tf.reduce_mean(y * tf.log(y_pre))
    train_op = tf.train.AdamOptimizer(lr).minimize(cross_entropy)
    
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    
    sess.run(tf.global_variables_initializer())
    for i in range(2000):
        _batch_size = 128
        batch = mnist.train.next_batch(_batch_size)
        if (i+1)%200 == 0:
            train_accuracy = sess.run(accuracy, feed_dict={
                _X:batch[0], y: batch[1], keep_prob: 1.0, batch_size: _batch_size})
            # 已经迭代完成的 epoch 数: mnist.train.epochs_completed
            print "Iter%d, step %d, training accuracy %g" % ( mnist.train.epochs_completed, (i+1), train_accuracy)
        sess.run(train_op, feed_dict={_X: batch[0], y: batch[1], keep_prob: 0.5, batch_size: _batch_size})
    
    # 计算测试数据的准确率
    print "test accuracy %g"% sess.run(accuracy, feed_dict={
        _X: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0, batch_size:mnist.test.images.shape[0]})
    
    Iter0, step 200, training accuracy 0.851562
    Iter0, step 400, training accuracy 0.960938
    Iter1, step 600, training accuracy 0.984375
    Iter1, step 800, training accuracy 0.960938
    Iter2, step 1000, training accuracy 0.984375
    Iter2, step 1200, training accuracy 0.9375
    Iter3, step 1400, training accuracy 0.96875
    Iter3, step 1600, training accuracy 0.984375
    Iter4, step 1800, training accuracy 0.992188
    Iter4, step 2000, training accuracy 0.984375
    test accuracy 0.9858
    

    我们一共只迭代不到5个epoch,在测试集上就已经达到了0.9825的准确率,可以看出来 LSTM 在做这个字符分类的任务上还是比较有效的,而且我们最后一次性对 10000 张测试图片进行预测,才占了 725 MiB 的显存。而我们在之前的两层 CNNs 网络中,预测 10000 张图片一共用了 8721 MiB 的显存,差了整整 12 倍呀!! 这主要是因为 RNN/LSTM 网络中,每个时间步所用的权值矩阵都是共享的,可以通过前面介绍的 LSTM 的网络结构分析一下,整个网络的参数非常少。

    4. 可视化看看 LSTM 的是怎么做分类的

    毕竟 LSTM 更多的是用来做时序相关的问题,要么是文本,要么是序列预测之类的,所以很难像 CNNs 一样非常直观地看到每一层中特征的变化。在这里,我想通过可视化的方式来帮助大家理解 LSTM 是怎么样一步一步地把图片正确的给分类。

    import matplotlib.pyplot as plt

    看下面我找了一个字符 3

    print mnist.train.labels[4]
    [ 0.  0.  0.  1.  0.  0.  0.  0.  0.  0.]
    

    我们先来看看这个字符样子,上半部分还挺像 2 来的

    X3 = mnist.train.images[4]
    img3 = X3.reshape([28, 28])
    plt.imshow(img3, cmap='gray')
    plt.show()

    这里写图片描述

    我们看看在分类的时候,一行一行地输入,分为各个类别的概率会是什么样子的。

    X3.shape = [-1, 784]
    y_batch = mnist.train.labels[0]
    y_batch.shape = [-1, class_num]
    
    X3_outputs = np.array(sess.run(outputs, feed_dict={
                _X: X3, y: y_batch, keep_prob: 1.0, batch_size: 1}))
    print X3_outputs.shape
    X3_outputs.shape = [28, hidden_size]
    print X3_outputs.shape
    (28, 1, 256)
    (28, 256)
    
    h_W = sess.run(W, feed_dict={
                _X:X3, y: y_batch, keep_prob: 1.0, batch_size: 1})
    h_bias = sess.run(bias, feed_dict={
                _X:X3, y: y_batch, keep_prob: 1.0, batch_size: 1})
    h_bias.shape = [-1, 10]
    
    bar_index = range(class_num)
    for i in xrange(X3_outputs.shape[0]):
        plt.subplot(7, 4, i+1)
        X3_h_shate = X3_outputs[i, :].reshape([-1, hidden_size])
        pro = sess.run(tf.nn.softmax(tf.matmul(X3_h_shate, h_W) + h_bias))
        plt.bar(bar_index, pro[0], width=0.2 , align='center')
        plt.axis('off')
    plt.show()

    这里写图片描述

    在上面的图中,为了更清楚地看到线条的变化,我把坐标都去了,每一行显示了 4 个图,共有 7 行,表示了一行一行读取过程中,模型对字符的识别。可以看到,在只看到前面的几行像素时,模型根本认不出来是什么字符,随着看到的像素越来越多,最后就基本确定了它是字符 3.

    好了,本次就到这里。有机会再写个优雅一点的例子,哈哈。其实学这个 LSTM 还是比较困难的,当时写 多层 CNNs 也就半天到一天的时间基本上就没啥问题了,但是这个花了我大概整整三四天,而且是在我对原理已经很了解(我自己觉得而已。。。)的情况下,所以学会了感觉还是有点小高兴的~

    17-04-19补充几个资料:
    - recurrent_network.py 一个简单的 tensorflow LSTM 例子。
    - Tensorflow下构建LSTM模型进行序列化标注 介绍非常好的一个 NLP 开源项目。(例子中有些函数可能在新版的 tensorflow 中已经更新了,但并不影响理解)

    5. 附:BASICLSTM.__call__()

    '''code: https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py'''
    
      def __call__(self, inputs, state, scope=None):
          """Long short-term memory cell (LSTM)."""
          with vs.variable_scope(scope or "basic_lstm_cell"):
              # Parameters of gates are concatenated into one multiply for efficiency.
              if self._state_is_tuple:
                  c, h = state
              else:
                  c, h = array_ops.split(value=state, num_or_size_splits=2, axis=1)
              concat = _linear([inputs, h], 4 * self._num_units, True, scope=scope)
    
              # ** 下面四个 tensor,分别是四个 gate 对应的权重矩阵
              # i = input_gate, j = new_input, f = forget_gate, o = output_gate
              i, j, f, o = array_ops.split(value=concat, num_or_size_splits=4, axis=1)
    
              # ** 更新 cell 的状态: 
              # ** c * sigmoid(f + self._forget_bias) 是保留上一个 timestep 的部分旧信息
              # ** sigmoid(i) * self._activation(j)  是有当前 timestep 带来的新信息
              new_c = (c * sigmoid(f + self._forget_bias) + sigmoid(i) *
                   self._activation(j))
    
              # ** 新的输出
              new_h = self._activation(new_c) * sigmoid(o)
    
              if self._state_is_tuple:
                  new_state = LSTMStateTuple(new_c, new_h)
              else:
                  new_state = array_ops.concat([new_c, new_h], 1)
              # ** 在(一般都是) state_is_tuple=True 情况下, new_h=new_state[1]
              # ** 在上面博文中,就有 cell_output = state[1]
              return new_h, new_state

    本文代码:https://github.com/yongyehuang/Tensorflow-Tutorial

    展开全文
  • Pytorch实现多层lstm

    千次阅读 2020-07-26 18:23:09
    Pytorch实现多层lstmPytorch实现多层lstmPytorch实现多层lstm

    PytorchlstmPytorch实现多层lstm

    # 10:输入数据维度大小  20 :隐状态的特征维度  2:层数,表示用来两层lstm
    lstm = nn.LSTM(10, 20, 2)
    # 5:序列长度 3:单个训练数据长度  10:单个序列维度  举个例子:每次运行时取3个含有5个字的句子(且句子中每个字的维度为10)
    input = Variable(torch.randn(5, 3, 10))
    # 2个LSTM层,batch_size=3, 隐藏层的特征维度20
    h0 = Variable(torch.randn(2, 3, 20))
    # 2个LSTM层,batch_size=3, 隐藏层的特征维度20
    # 这里有2层lstm,output是最后一层lstm的每个词向量对应隐藏层的输出,其与层数无关,只与序列长度相关
    
    c0 = Variable(torch.randn(2, 3, 20))
    # 
    output, hn = lstm(input, (h0, c0))
    
    class RNN(nn.Module):
        def __init__(self, input_size, hidden_size, num_layers, num_classes):
            super(RNN, self).__init__()
            self.hidden_size = hidden_size
            self.num_layers = num_layers
            self.lstm = nn.LSTM(input_size, hidden_size, num_layers, 
                                batch_first=True)
            self.fc = nn.Linear(hidden_size, num_classes)  # 2 for bidirection 
    
        def forward(self, x):
    
            # Forward propagate RNN
            out, _ = self.lstm(x)
    
            # Decode hidden state of last time step
            out = self.fc(out[:, -1, :])
            return out
    
    rnn = RNN(input_size, hidden_size, num_layers, num_classes)
    rnn.cuda()
    

    class torch.nn.LSTM( args, * kwargs)[source]
    将一个多层的 (LSTM) 应用到输入序列。

    参数说明:

    • input_size – 输入的特征维度
    • hidden_size – 隐状态的特征维度
    • num_layers – 层数(和时序展开要区分开)
    • bias – 如果为False,那么LSTM将不会使用bih,bhhb_{ih},b_{hh},默认为True。
    • batch_first – 如果为True,那么输入和输出Tensor的形状为(batch, seq, feature)
    • dropout – 如果非零的话,将会在RNN的输出上加个dropout,最后一层除外。
    • bidirectional – 如果为True,将会变成一个双向RNN,默认为False。

    LSTM输入: input, (h_0, c_0)

    • input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed
      variable ,详见
      [pack_padded_sequence](#torch.nn.utils.rnn.pack_padded_sequence(input,
      lengths, batch_first=False[source])
    • h_0 (num_layers * num_directions, batch,
      hidden_size):保存着batch中每个元素的初始化隐状态的Tensor
    • c_0 (num_layers * num_directions, batch, hidden_size):
      保存着batch中每个元素的初始化细胞状态的Tensor

    LSTM输出 output, (h_n, c_n)

    • output (seq_len, batch, hidden_size * num_directions):
      保存RNN最后一层的输出的Tensor。
      如果输入是torch.nn.utils.rnn.PackedSequence,那么输出也是torch.nn.utils.rnn.PackedSequence。
    • h_n (num_layers * num_directions, batch, hidden_size):
      Tensor,保存着RNN最后一个时间步的隐状态。
    • c_n (num_layers * num_directions, batch, hidden_size):
      Tensor,保存着RNN最后一个时间步的细胞状态。

    LSTM模型参数:

    • weight_ih_l[k] – 第k层可学习的input-hidden权重(WiiWifWigWioW_{ii}|W_{if}|W_{ig}|W_{io}),形状为(input_size x4*hidden_size)
    • weight_hh_l[k] –第k层可学习的hidden-hidden权重(WhiWhfWhgWhoW_{hi}|W_{hf}|W_{hg}|W_{ho}),形状为(hidden_size x 4*hidden_size)。
    • bias_ih_l[k] – 第k层可学习的input-hidden偏置(biibifbigbiob_{ii}|b_{if}|b_{ig}|b_{io}),形状为(4*hidden_size)
    • bias_hh_l[k] –第k层可学习的hidden-hidden偏置(bhibhfbhgbhob_{hi}|b_{hf}|b_{hg}|b_{ho}),形状为( 4*hidden_size)。 示例:
    展开全文
  • 多层 LSTM的实现

    千次阅读 2019-02-13 20:10:51
    tensorflow笔记:多层LSTM代码分析 但是感觉这些例子还是太复杂了,所以这里写了个比较简单的版本,虽然不优雅,但是还是比较容易理解。 如果你想了解 LSTM 的原理的话(前提是你已经理解了普...
  • 基于keras多层LSTM实现数据集,代码链接:https://blog.csdn.net/chaochaopang0/article/details/80266155
  • 多层LSTM结构的深入解读

    万次阅读 多人点赞 2018-06-15 01:37:52
    读这篇文章的时候,默认你已经对LSTM神经网络有了一个初步的认识,当你深入理解时,可能会对多层LSTM内部的隐藏节点数,有关cell的定义或者每一层的输入输出是什么样子的特别好奇,虽然神经网络就像是一个黑箱子一样...
  • Matlab多层lstm代码使用具有CNN功能的深度双向LSTM在视频序列中进行动作识别 我们已经使用caffe模式使用matlab脚本“ oneFileFeatures ...”从视频中提取了深层功能。 每个CSV文件代表一个视频的功能。 使用“ ...
  • 单独定义一个获取单元的函数,便于在MultiRNNCell中调用,创建多层LSTM网络 def get_a_cell(i): lstm_cell =rnn.BasicLSTMCell(num_units=HIDDEN_CELL, forget_bias = 1.0, state_is_tuple = True, name = '...
  • tensorflow笔记:多层LSTM代码分析 标签(空格分隔): tensorflow笔记 tensorflow笔记系列: (一) tensorflow笔记:流程,概念和简单代码注释 (二) tensorflow笔记:多层CNN代码分析 (三) ...
  • 在TensorFlow中用BasicLSTMCell和MultiRNNCell实现多层LSTM循环神经网络时,关于MultiRNNCell的用法网络上很多例程中是错误的,误人子弟 下面这样直接用一个BasicLSTMCell复制是错误的,会导致各层共享权重basic_...
  • TF之LSTM:利用多层LSTM算法对MNIST手写数字识别数据集进行多分类 目录 设计思路 实现代码 设计思路 更新…… 实现代码 # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np...
  • 单层LSTM和多层LSTM的输入与输出

    千次阅读 多人点赞 2020-06-10 11:44:09
    单层LSTM的输入与输出 上图是单层LSTM的输入输出结构图。其实它是由一个LSTM单元的一个展开,如下图所示: 所以从左到右的每个LSTM Block只是对应一个时序中的不同的步。 在第一个图中,输入的时序特征有S个,长度...
  • 前言: 根据我本人学习...tensorflow笔记:多层LSTM代码分析  但是感觉这些例子还是太复杂了,所以这里写了个比较简单的版本,虽然不优雅,但是还是比较容易理解。 如果你想了解 LSTM 的原理的话(前提是你已经理解
  • keras实现多层LSTM

    2021-07-02 15:49:01
    model.add(LSTM(units=hidden, input_shape=(time_steps, input_size),return_sequences=True))#返回所有节点的输出 model.add(LSTM(units=hidden,return_sequences=False))#返回最后一个节点的输出 ## # model.add...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,001
精华内容 4,400
关键字:

多层lstm