精华内容
下载资源
问答
  • 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的实现

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

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

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

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

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


    图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-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.]
    
    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


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

    转自 永永夜 链接: https://blog.csdn.net/jerr__y/article/details/61195257
    展开全文
  • 其他内容 ...   输入格式:batch_size*784改成batch_size*28*28,28个序列,内容是一行的28个灰度数值。 让神经网络逐行扫描一个手写字体图案,总结各行特征,...网络定义:单独定义一个获取单元的函数,便于在Mult...

    其他内容

    https://blog.csdn.net/huqinweI987/article/details/83155110

     

    输入格式:batch_size*784改成batch_size*28*28,28个序列,内容是一行的28个灰度数值。

    让神经网络逐行扫描一个手写字体图案,总结各行特征,通过时间序列串联起来,最终得出结论。

    网络定义:单独定义一个获取单元的函数,便于在MultiRNNCell中调用,创建多层LSTM网络

    def get_a_cell(i):
        lstm_cell =rnn.BasicLSTMCell(num_units=HIDDEN_CELL, forget_bias = 1.0, state_is_tuple = True, name = 'layer_%s'%i)
        print(type(lstm_cell))
        dropout_wrapped = rnn.DropoutWrapper(cell = lstm_cell, input_keep_prob = 1.0, output_keep_prob = keep_prob)
        return dropout_wrapped
    
    multi_lstm = rnn.MultiRNNCell(cells = [get_a_cell(i) for i in range(LSTM_LAYER)],
                                  state_is_tuple=True)#tf.nn.rnn_cell.MultiRNNCell

    多层RNN下state和单层RNN有所不同,多了些细节,每一层都是一个cell,每一个cell都有自己的state,每一层都对应一个LSTMStateTuple(本例是分类预测,所以只用到最后一层的输出,但是不代表其他情况不需要使用中间层的状态)。

    cell之间是串联的,-1是最后一层的state,等价于单层下的output,我这里建了三层,所以-1和2相等:

    
    outputs, state = tf.nn.dynamic_rnn(multi_lstm, inputs = tf_x_reshaped, initial_state = init_state, time_major = False)
    print('state:',state)
    print('state[0]:',state[0])#layer 0's LSTMStateTuple
    print('state[1]:',state[1])#layer 1's LSTMStateTuple
    print('state[2]:',state[2])#layer 2's LSTMStateTuple
    print('state[-1]:',state[-1])#layer 2's LSTMStateTuple
    
    state: (LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_3:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_4:0' shape=(32, 256) dtype=float32>), LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_5:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_6:0' shape=(32, 256) dtype=float32>), LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_7:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_8:0' shape=(32, 256) dtype=float32>))
    state[0]: LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_3:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_4:0' shape=(32, 256) dtype=float32>)
    state[1]: LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_5:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_6:0' shape=(32, 256) dtype=float32>)
    state[2]: LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_7:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_8:0' shape=(32, 256) dtype=float32>)
    state[-1]: LSTMStateTuple(c=<tf.Tensor 'rnn/while/Exit_7:0' shape=(32, 256) dtype=float32>, h=<tf.Tensor 'rnn/while/Exit_8:0' shape=(32, 256) dtype=float32>)
    

    下边是outputs和states的对比:outputs对应state_2,又因为这里做的是类型预测,是Nvs1模型,且time_major是False,第0维是batch,要取时间序列的最后一个输出,用[:,-1,:],可以看到,是全相等的。

    
    outputs, state = tf.nn.dynamic_rnn(multi_lstm, inputs = tf_x_reshaped, initial_state = init_state, time_major = False)
    h_state_0 = state[0][1]
    h_state_1 = state[1][1]
    h_state = state[-1][1]
    h_state_2 = h_state
    
    
    
            _, loss_,outputs_, state_, h_state_0_, h_state_1_, h_state_2_ = \
                sess.run([train_op, cross_entropy,outputs, state, h_state_0, h_state_1, h_state_2], {tf_x:x, tf_y:y, keep_prob:1.0})
    
    
            print('h_state_2_ == outputs_[:,-1,:]:', h_state_2_ == outputs_[:,-1,:])
    
    
    h_state_2_ == outputs_[:,-1,:]: [[ True  True  True ...  True  True  True]
     [ True  True  True ...  True  True  True]
     [ True  True  True ...  True  True  True]
     ...
     [ True  True  True ...  True  True  True]
     [ True  True  True ...  True  True  True]
     [ True  True  True ...  True  True  True]]

     

    最后处理一下输出:LSTM的接口为了使用方便,输入输出是等维度的,不可设置,隐藏单元这里设置的256,需要做一个转换,转换为10维输出,最终对手写数字进行分类预测。

    #prediction and loss
    W = tf.Variable(initial_value = tf.truncated_normal([HIDDEN_CELL, CLASS_NUM], stddev = 0.1 ), dtype = tf.float32)
    print(W)
    b = tf.Variable(initial_value = tf.constant(0.1, shape = [CLASS_NUM]), dtype = tf.float32)
    predictions = tf.nn.softmax(tf.matmul(h_state, W) + b)
    #sum   -ylogy^
    cross_entropy = -tf.reduce_sum(tf_y * tf.log(predictions))

     

    完整代码:

    https://github.com/huqinwei/tensorflow_demo/blob/master/lstm_mnist/multi_lstm_state_and_output.py

     

     

    展开全文
  • 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

    展开全文
  • 多层LSTM结构的深入解读

    万次阅读 多人点赞 2018-06-15 01:37:52
    读这篇文章的时候,默认你已经对LSTM神经网络有了一个初步的认识,当你深入理解时,可能会对多层LSTM内部的隐藏节点数,有关cell的定义或者每一层的输入输出是什么样子的特别好奇,虽然神经网络就像是一个黑箱子一样...
  • 利用PTB数据实现多层LSTM网络

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

    千次阅读 多人点赞 2020-06-10 11:44:09
    是单层LSTM的输入输出结构。其实它是由一个LSTM单元的一个展开,如下所示: 所以从左到右的每个LSTM Block只是对应一个时序中的不同的步。 在第一个中,输入的时序特征有S个,长度记作:seq_len,每个...
  • 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),后面层的输入不再...
  • Matlab多层lstm代码使用具有CNN功能的深度双向LSTM在视频序列中进行动作识别 我们已经使用caffe模式使用matlab脚本“ oneFileFeatures ...”从视频中提取了深层功能。 每个CSV文件代表一个视频的功能。 使用“ ...
  • 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) ...
  • LSTM网络

    2019-02-28 12:44:39
    多层LSTM LSTM实现手写数字 设置LSTM参数 初始化权值参数 训练 参考资料 前面我们介绍了RNN,现在我们来介绍一种特殊的RNN结构,LSTM网络。我们将逐步介绍LSTM的结构,原理,以及利用LSTM识别手写数字的demo跟深刻的...
  • TF之LSTM:利用多层LSTM算法对MNIST手写数字识别数据集进行多分类 目录 设计思路 实现代码 设计思路 更新…… 实现代码 # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np...
  • 多层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...
  • import tensorflow as tf import numpy as np import matplotlib as mpl from matplotlib import ...hidden_size = 30 # LSTM 中隐藏节点的个数 //TODO 这个size是是什么意思 num_layers = 2 # LSTM 的层数 timest...
  • 前言: 根据我本人学习...tensorflow笔记:多层LSTM代码分析  但是感觉这些例子还是太复杂了,所以这里写了个比较简单的版本,虽然不优雅,但是还是比较容易理解。 如果你想了解 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 # 期望输入数据尺寸: ...
  • 前言循环神经网络(recurrent neural networks, RNNs)及其改进算法长短期记忆网络(Long Short-Term Memory, LSTM)能够很好地对时序数据进行建模,本文实现了两层 LSTM 对 MNIST 数据集进行分类预测以及结果可视化...
  • The MNIST data-set MNIST data-set由一些黑白照片集合组成,每张照片包含手写...MNIST data-set可通过网络在MNIST数据库中获得。 为方便下载数据,你可以使用input_data.py脚本,该文件也已放在github上。当在Tenso...
  • plt.title("amount of precipitation") #标题 plt.legend() plt.show() #plt.savefig(filename+'.png') def predict_next(model,scaler,dataset_pre,look_back,next_num): dataset_pre = scaler.transform(dataset...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,382
精华内容 3,752
关键字:

多层lstm网络图