Tensorflow中循环神经网络及其Wrappers

  • tf.nn.rnn_cell.LSTMCell

    • 又名:tf.nn.rnn_cell.BasicLSTMCelltf.contrib.rnn.LSTMCell
    • 参见: tf.nn.rnn_cell.LSTMCell
    • 输出:
      • output:LSTM单元输出,与LSTM cell state的区别在于该输出又经过激活以及和一个sigmoid函数输出相乘。shape: [batch_size,num_units]
      • new_state:当前时间步上的LSTM cell stateLSTM output。使用数据结构LSTMStateTuple描述,LSTMStateTuple:(c,h),其中,h与上述的output完全相同。shape: ([batch_size,num_units],[batch_size,num_units])
    • 示例:
      batch_size=10
      embedding_size=300
      inputs=tf.Variable(tf.random_normal([batch_size,embedding_size]))
      previous_state=(tf.Variable(tf.random_normal([batch_size,128])),tf.Variable(tf.random_normal([batch_size,128])))
      lstmcell=tf.nn.rnn_cell.LSTMCell(128)
      outputs,states=lstmcell(inputs,previous_state)

      输出:

      outputs:
      <tf.Tensor ‘lstm_cell/mul_2:0‘ shape=(10, 128) dtype=float32>
      
      states:
      LSTMStateTuple(c=<tf.Tensor ‘lstm_cell/add_1:0‘ shape=(10, 128) dtype=float32>, h=<tf.Tensor ‘lstm_cell/mul_2:0‘ shape=(10, 128) dtype=float32>)
  • tf.nn.rnn_cell.MultiRNNCell
    • 参见:tf.nn.rnn_cell.MultiRNNCell
    • 输出:
      • outputs: 最顶层cell的最后一个时间步的输出。shape:[batch_size,cell.output_size]
      • states:每一层的state,M层LSTM则输出M个LSTMStateTuple组成的Tuple。
    • 示例:
      batch_size=10
      inputs=tf.Variable(tf.random_normal([batch_size,128]))
      previous_state0=(tf.random_normal([batch_size,100]),tf.random_normal([batch_size,100]))
      previous_state1=(tf.random_normal([batch_size,200]),tf.random_normal([batch_size,200]))
      previous_state2=(tf.random_normal([batch_size,300]),tf.random_normal([batch_size,300]))
      num_units=[100,200,300]
      cells=[tf.nn.rnn_cell.LSTMCell(num_unit) for num_unit in num_units]
      mul_cells=tf.nn.rnn_cell.MultiRNNCell(cells)
      outputs,states=mul_cells(inputs,(previous_state0,previous_state1,previous_state2))

      输出:

      outputs:
      <tf.Tensor ‘multi_rnn_cell_1/cell_2/lstm_cell/mul_2:0‘ shape=(10, 300) dtype=float32>
      
      states:
      (LSTMStateTuple(c=<tf.Tensor ‘multi_rnn_cell_1/cell_0/lstm_cell/add_1:0‘ shape=(10, 100) dtype=float32>, h=<tf.Tensor ‘multi_rnn_cell_1/cell_0/lstm_cell/mul_2:0‘ shape=(10, 100) dtype=float32>),
       LSTMStateTuple(c=<tf.Tensor ‘multi_rnn_cell_1/cell_1/lstm_cell/add_1:0‘ shape=(10, 200) dtype=float32>, h=<tf.Tensor ‘multi_rnn_cell_1/cell_1/lstm_cell/mul_2:0‘ shape=(10, 200) dtype=float32>),
       LSTMStateTuple(c=<tf.Tensor ‘multi_rnn_cell_1/cell_2/lstm_cell/add_1:0‘ shape=(10, 300) dtype=float32>, h=<tf.Tensor ‘multi_rnn_cell_1/cell_2/lstm_cell/mul_2:0‘ shape=(10, 300) dtype=float32>))
  • tf.nn.dynamic_rnn
    • 参见:tf.nn.dynamic_rnn
    • 输出:
      • outputs: 每个时间步上的LSTM输出;若有多层LSTM,则为每一个时间步上最顶层的LSTM的输出。shape: [batch_size,max_time,cell.output_size]
      • state:最后一个时间步的状态,该状态使用LSTMStateTuple结构输出;若有M层LSTM,则输出M个LSTMStateTuple。shape:单层LSTM输出:[batch_size,cell.output_size];M层LSTM输出:M个LSTMStateTuple组成的Tuple,这也即是说:outputs[:,-1,:]==state[-1,:,:]。
    • 示例:
      batch_size=10
      max_time=20
      data=tf.Variable(tf.random_normal([batch_size,max_time,128]))
      # create a BasicRNNCell
      rnn_cell = tf.nn.rnn_cell.BasicRNNCell(num_units=128)
      
      # defining initial state
      initial_state = rnn_cell.zero_state(batch_size,dtype=tf.float32)
      
      # ‘outputs‘ is a tensor of shape [batch_size, max_time, cell_state_size]
      # ‘state‘ is a tensor of shape [batch_size, cell_state_size]
      outputs, state = tf.nn.dynamic_rnn(cell=rnn_cell, inputs=data,
                                         initial_state=initial_state,
                                         dtype=tf.float32)

      输出:

      outpus:
      <tf.Tensor ‘rnn_2/transpose_1:0‘ shape=(10, 20, 128) dtype=float32>
      
      state:
      <tf.Tensor ‘rnn_2/while/Exit_3:0‘ shape=(10, 128) dtype=float32>
      batch_size=10
      max_time=20
      data=tf.Variable(tf.random_normal([batch_size,max_time,128]))
      # create 2 LSTMCells
      rnn_layers = [tf.nn.rnn_cell.LSTMCell(size) for size in [128, 256]]
      
      # create a RNN cell composed sequentially of a number of RNNCells
      multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_layers)
      
      # ‘outputs‘ is a tensor of shape [batch_size, max_time, 256]
      # ‘state‘ is a N-tuple where N is the number of LSTMCells containing a
      # tf.contrib.rnn.LSTMStateTuple for each cell
      outputs, state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,
                                         inputs=data,
                                         dtype=tf.float32)
      outputs:
      <tf.Tensor ‘rnn_1/transpose_1:0‘ shape=(10, 20, 256) dtype=float32>
      
      state:
      (LSTMStateTuple(c=<tf.Tensor ‘rnn_1/while/Exit_3:0‘ shape=(10, 128) dtype=float32>, h=<tf.Tensor ‘rnn_1/while/Exit_4:0‘ shape=(10, 128) dtype=float32>),
       LSTMStateTuple(c=<tf.Tensor ‘rnn_1/while/Exit_5:0‘ shape=(10, 256) dtype=float32>, h=<tf.Tensor ‘rnn_1/while/Exit_6:0‘ shape=(10, 256) dtype=float32>))
  • tf.nn.bidirectional_dynamic_rnn
    • 参见:tf.nn.bidirectional_dynamic_rnn
    • 输出:
      • outputs:(output_fw,output_bw):前向cell+后向cell

        其中,output_fw、output_bw均为:[batch_size,max_time,cell.output_size]

      • state:(output_state_fw,output_state_bw):包含前向和后向隐状态组成的元组

        其中,output_state_fw、output_state_bw均为LSTMStateTuple。LSTMStateTuple:(c,h),分别为cell_state,hidden_output

  • tf.contrib.seq2seq.dynamic_decode
    • 输出:

      • final_outputs,包含rnn_output和sample_id,分别可用final_output.rnn_output和final_outputs.sample_id获取到。
      • final_state,可以从最后一个解码器状态获取alignments,alignments = tf.transpose(final_decoder_state.alignment_history.stack(), [1, 2, 0])
      • final_sequence_lengths

原文地址:https://www.cnblogs.com/mengnan/p/10384484.html

时间: 2024-10-09 01:12:50

Tensorflow中循环神经网络及其Wrappers的相关文章

TensorFlow框架(6)之RNN循环神经网络详解

1. RNN循环神经网络 1.1 结构 循环神经网络(recurrent neural network,RNN)源自于1982年由Saratha Sathasivam 提出的霍普菲尔德网络.RNN的主要用途是处理和预测序列数据.全连接的前馈神经网络和卷积神经网络模型中,网络结构都是从输入层到隐藏层再到输出层,层与层之间是全连接或部分连接的,但每层之间的节点是无连接的. 图 11 RNN-rolled 如图 11所示是一个典型的循环神经网络.对于循环神经网络,一个非常重要的概念就是时刻.循环神经网

学习笔记TF057:TensorFlow MNIST,卷积神经网络、循环神经网络、无监督学习

MNIST 卷积神经网络.https://github.com/nlintz/TensorFlow-Tutorials/blob/master/05_convolutional_net.py .TensorFlow搭建卷积神经网络(CNN)模型,训练MNIST数据集. 构建模型. 定义输入数据,预处理数据.读取数据MNIST,得到训练集图片.标记矩阵,测试集图片标记矩阵.trX.trY.teX.teY 数据矩阵表现.trX.teX形状变为[-1,28,28,1],-1 不考虑输入图片数量,28x

机器学习与Tensorflow(5)——循环神经网络、长短时记忆网络

1.循环神经网络的标准模型 前馈神经网络能够用来建立数据之间的映射关系,但是不能用来分析过去信号的时间依赖关系,而且要求输入样本的长度固定 循环神经网络是一种在前馈神经网络中增加了分亏链接的神经网络,能够产生对过去数据的记忆状态,所以可以用于对序列数据的处理,并建立不同时段数据之间的依赖关系 循环神经网络是一类允许节点连接成有向环的人工神经网络.如下图: 2.循环神经网络与递归神经网络 从广义上说,递归神经网络可以分为结构递归神经网络和时间递归神经网络 从狭义上说,递归神经网络可以通常就是指结构

84、循环神经网络实现语言模型

''' Created on 2017年5月13日 @author: weizhen ''' import numpy as np import tensorflow as tf import ptb_iterator as reader from tensorflow.contrib import rnn DATA_PATH = "/path/to/ptb/data" # 数据存放的路径 HIDDEN_SIZE = 200 # 隐藏层的规模 NUM_LAYERS = 2 # 深层循环

第十四章——循环神经网络(Recurrent Neural Networks)(第二部分)

本章共两部分,这是第二部分: 第十四章--循环神经网络(Recurrent Neural Networks)(第一部分) 第十四章--循环神经网络(Recurrent Neural Networks)(第二部分) 14.4 深度RNN 堆叠多层cell是很常见的,如图14-12所示,这就是一个深度RNN. 图14-12 深度RNN(左),随时间展开(右) 在TensorFlow中实现深度RNN,需要创建多个cell并将它们堆叠到一个MultiRNNCell中.下面的代码创建了三个完全相同的cel

基于tensorflow搭建一个神经网络

一,tensorflow的简介 Tensorflow是一个采用数据流图,用于数值计算的 开源软件库.节点在图中表示数字操作,图中的线 则表示在节点间相互联系的多维数据数组,即张量 它灵活的架构让你可以在多种平台上展开计算,例 如台式计算机中的一个或多个CPU(或GPU), 服务器,移动设备等等.Tensorflow最初由Google 大脑小组的研究员和工程师们开发出来,用于机器 学习和深度神经网络方面的研究,但这个系统的通 用性使其也可广泛用于其他计算领域. 二,tensorflow的架构 Te

Tensorflow中使用CNN实现Mnist手写体识别

本文参考Yann LeCun的LeNet5经典架构,稍加ps得到下面适用于本手写识别的cnn结构,构造一个两层卷积神经网络,神经网络的结构如下图所示: 输入-卷积-pooling-卷积-pooling-全连接层-Dropout-Softmax输出 第一层卷积利用5*5的patch,32个卷积核,可以计算出32个特征.然后进行maxpooling.第二层卷积利用5*5的patch,64个卷积核,可以计算出64个特征.然后进行max pooling.卷积核的个数是我们自己设定,可以增加卷积核数目提高

循环神经网络(RNN)模型与前向反向传播算法

在前面我们讲到了DNN,以及DNN的特例CNN的模型和前向反向传播算法,这些算法都是前向反馈的,模型的输出和模型本身没有关联关系.今天我们就讨论另一类输出和模型间有反馈的神经网络:循环神经网络(Recurrent Neural Networks ,以下简称RNN),它广泛的用于自然语言处理中的语音识别,手写书别以及机器翻译等领域. 1. RNN概述 在前面讲到的DNN和CNN中,训练样本的输入和输出是比较的确定的.但是有一类问题DNN和CNN不好解决,就是训练样本输入是连续的序列,且序列的长短不

循环神经网络RNN公式推导走读

0语言模型-N-Gram 语言模型就是给定句子前面部分,预测后面缺失部分 eg.我昨天上学迟到了,老师批评了____. N-Gram模型: ,对一句话切词 我 昨天 上学 迟到 了 ,老师 批评 了 ____. 2-N-Gram 会在语料库中找 了 后面最可能的词: 3-N-Gram 会在预料库中找 批评了 后面最可能的词: 4-N-Gram 的内存耗费就非常巨大了(语料库中保存所有的四个词的预料组合). 1.1单向循环神经网络 一个单隐层结构示意图: 参数:输入到隐层的权重U.隐层到输出的权重