虽然已经接触deep learning很长一段时间了，也看了很久rnn相关的代码，但是突然想用tensorflow实现一些功能的时候，突然发现丝毫没有头绪，找了一些资料，学习了一波，记录一下。
一、tensorflow实现RNN cell
tensorflow由于不同的版本改动较大，在1.0版本之后，可以使用如下语句来创建一个cell：
from tensorflow.contrib import rnn
cell_fun = rnn.GRUCell(rnn_hidden_size)
在tensorflow中，上述GRUCell的实现如下（可以在GitHub上看到源码）：
class GRUCell(RNNCell):
"""Gated Recurrent Unit cell (cf. http://arxiv.org/abs/1406.1078)."""
def __init__(self, num_units, input_size=None, activation=tanh):
if input_size is not None:
logging.warn("%s: The input_size parameter is deprecated.", self)
self._num_units = num_units
self._activation = activation
@property
def state_size(self):
return self._num_units
@property
def output_size(self):
return self._num_units
def __call__(self, inputs, state, scope=None):
"""Gated recurrent unit (GRU) with nunits cells."""
with vs.variable_scope(scope or "gru_cell"):
with vs.variable_scope("gates"): # Reset gate and update gate.
# We start with bias of 1.0 to not reset and not update.
r, u = array_ops.split(
value=_linear(
[inputs, state], 2 * self._num_units, True, 1.0, scope=scope),
num_or_size_splits=2,
axis=1)
r, u = sigmoid(r), sigmoid(u)
with vs.variable_scope("candidate"):
c = self._activation(_linear([inputs, r * state],
self._num_units, True,
scope=scope))
new_h = u * state + (1 - u) * c
return new_h, new_h注意到这里面有一个call函数，这个函数表示的意思就是，把类的对象可以当做函数来使用，比如上面的GRUCell这个类有个对象gru，那么我们可以直接使用 ’ gru(input, last_state) ‘；
其实一开始并不知道tensorflow中有这个，所以还自己写了一个GRU的cell，仅供参考:
# -*- coding: utf-8 -*-
# @Last Modified : 5/23/2017 1:56 PM
# @Author : SummmerSnow
# @Description:
import tensorflow as tf
class GRU(object):
def __init__(self, name, input_len, hidden_len):
self.name = name
self.input_len = input_len
self.hidden_len = hidden_len
def define_param(self):
self.W = tf.Variable("_W", self.input_len, 3*self.hidden_len)
self.U = tf.Variable("_U", self.hidden_len, 3*self.hidden_len)
self.B = tf.Variable("_B", 3*self.hidden_len)
def build_net(self, input_data, last_hidden):
xW = tf.add(tf.matmul(input_data, self.W), self.B)
hU = tf.matmul(last_hidden, self.U)
xw1, xw2, xw3 = tf.split(xW, 3, 1)
hu1, hu2, hu3 = tf.split(hU, 3, 1)
r = tf.sigmoid(xw1 + hu1)
z = tf.sigmoid(xw2 + hu2)
h1 = tf.tanh(xw3, r*hu3)
h = (h1 - last_hidden) * z + last_hidden
return h二、tensorflow创建RNN
上一章其实只是创建了一个rnncell， 那么问题就在于如何写出一个循环的神经网络，loss如何计算。【注意，这里这是在讲述如何实现RNN，假设的是已经了解RNN的原理，如果对原理还是很懂，可以看相关资料】
几种实现的方法：
[转载自： http://www.what21.com/article/b_android_1491375010268.html]
在 tensorflow 中实现 LSTM 结构的循环神经网络的前向传播过程，即使用 BasicLSTMCell：
# 定义一个 LSTM 结构，LSTM 中使用的变量会在该函数中自动被声明
lstm = tf.contrib.rnn.BasicLSTMCell(lstm_hidden_size)
# 将 LSTM 中的状态初始化为全 0 数组，batch_size 给出一个 batch 的大小
state = lstm.zero_state(batch_size, tf.float32)
# 定义损失函数
loss = 0.0
# num_steps 表示最大的序列长度
for i in range(num_steps):
# 在第一个时刻声明 LSTM 结构中使用的变量，在之后的时刻都需要服用之前定义好的变量
if i>0:
tf.get_variable_scope().reuse_variables()
# 每一步处理时间序列中的一个时刻。将当前输入（current_input）和前一时刻状态（state）传入定义的 LSTM 结构就可以得到当前 LSTM 结构的输出 lstm_output 和更新后的状态 state
lstm_output, state = lstm(current_input, state)
# 将当前时刻 LSTM 结构的输出传入一个全连接层得到最后的输出
final_output = fully_connected(lstm_output)
# 计算当前时刻输出的损失
loss += calc_loss(final_output, expected_output)
在 tensorflow中实现双向RNN（BiRNN），使用 MultiRNNCell：
lstm = tf.contrib.rnn.BasicLSTMCell(lstm_hidden_size)
# 使用 MultiRNNCell 类实现深层循环网络中每一个时刻的前向传播过程，number_of_layers 表示有多少层
stacked_lstm = tf.contrib.rnn.MultiRNNCell([lstm] * number_of_layers)
state = stacked_lstm.zero_state(batch_size, tf.float32)
for i in range(len(num_steps)):
if i>0:
tf.get_variable_scope().reuse_variables()
stacked_lstm_output, state = stacked_lstm(current_input, state)
final_output = fully_connected(stacked_lstm_output)
loss += calc_loss(final_output, expected_output)
循环神经网络 RNN 中的 dropout， 使用 DropoutWrapper：
# 定义 LSTM 结构
lstm = tf.contrib.rnn.BasicLSTMCell(lstm_hidden_size)
# 使用 DropoutWrapper 类来实现 dropout 功能，input_keep_prob 控制输出的 dropout 概率
dropout_lstm = tf.contrib.rnn.DropoutWrapper(lstm, input_keep_prob=0.5)
stacked_lstm = tf.contrib.rnn.MultiRNNCell([dropout_lstm] * number_of_layers)
- 上面是自定义实现的方法，其实还可以使用tf.nn自定义的实现方法：
tf.nn.dynamic(), 具体使用方法：