博客

详解TensorFlow的 tf.nn.static_rnn 函数：静态 RNN

  • Post category:Python

TensorFlow是一个广泛使用的深度学习框架之一，可以用于构建各种类型的机器学习模型，其中包括循环神经网络(RNN)。TensorFlow提供了各种RNN函数的API，其中一个有用的函数是tf.nn.static_rnn。这个函数可以用于构建静态RNN，使得RNN在训练和推理过程中具有固定的大小。在本文中，我们将详细讲解tf.nn.static_rnn函数的作用和使用方法。

作用

tf.nn.static_rnn函数的作用是将输入序列转化为输出序列，并且可以同时更新RNN内部的状态。它接受三个参数：

  • cell: RNN单元，常用的有LSTM和GRU等。
  • inputs: 输入序列，一个形状为(batch_size, n_steps, n_inputs)的张量，这里n_steps表示序列长度，n_inputs表示每个时间步的输入维度。输入可以是实数、整数、独热编码等。
  • initial_state: RNN单元的初始状态，一般是全零张量。

tf.nn.static_rnn函数返回两个值：

  • outputs: 输出序列，一个形状为(batch_size, n_steps, n_neurons)的张量，这里n_neurons表示RNN每个时间步的输出维度。
  • final_state: RNN的最终状态，一般用于下一个循环次数的初始化。

使用方法

在使用tf.nn.static_rnn函数时，首先需要定义RNN单元。以下代码展示了如何使用LSTM单元定义RNN模型：

import tensorflow as tf

n_inputs = 1
n_neurons = 100
n_steps = 20

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
basic_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=n_neurons)
outputs, states = tf.nn.static_rnn(basic_cell, tf.unstack(X, axis=1), dtype=tf.float32)

这里X是输入占位符，我们将输入张量在时间轴上展开，然后用tf.unstack函数将它们拆分成一个列表。然后我们使用tf.nn.rnn_cell.BasicLSTMCell函数创建了一个LSTM单元，并传递给tf.nn.static_rnn函数。最后，该函数返回输出序列和最终状态。

为了使用tf.nn.static_rnn函数处理实际数据，我们需要准备好可以喂给模型的数据。以下代码展示了如何生成一个随机输入序列：

import numpy as np

X_batch = np.random.rand(2, n_steps, n_inputs)

然后我们可以将生成的随机输入序列喂给模型，并计算输出序列和最终状态：

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    outputs_val, states_val = sess.run([outputs, states], feed_dict={X: X_batch})

print("outputs_val.shape:", outputs_val.shape)
print("states_val.shape:", states_val.shape)

输出结果如下：

outputs_val.shape: (2, 20, 100)
states_val.shape: LSTMStateTuple(c=array([[ 0.05803978, -0.03035307, ...,  0.00206365, -0.00317105]], dtype=float32), h=array([[ 0.02362434, -0.01312414, ...,  0.00083555, -0.0008729 ]], dtype=float32))

这里我们通过sess.run计算了输出序列和最终状态，并且使用feed_dict将随机序列X_batch喂给模型。输出结果中，outputs_val是形状为(2, 20, 100)的3维张量，表示2个样本的输出序列。states_val是一个tuple，其中h和c分别表示LSTM单元的状态，每个状态是一个形状为(2, 100)的2维张量。

示例1：使用LSTM单元实现情感分类

以下是使用LSTM单元实现情感分类的简单示例。该模型可以根据所提供的文本数据将其标记为正面或负面情感：

import tensorflow as tf
from tensorflow.contrib import learn
from tensorflow.python.platform import gfile
import numpy as np

is_training=True
n_steps = 200
n_inputs = 300
n_hidden = 100
n_classes = 2
learning_rate = 0.01

def read_raw_data(data_path):
    x_text = []
    y = []
    with gfile.FastGFile(data_path, "r") as f:
        for line in f:
            split_line = line.strip().split("\t")
            y.append(int(split_line[0]))
            x_text.append([float(v) for v in split_line[1].split()])
    return x_text, y

def get_data(data_path):
    x_raw, y_raw = read_raw_data(data_path)
    vocab_processor = learn.preprocessing.VocabularyProcessor(n_steps)
    x = np.array(list(vocab_processor.fit_transform(x_raw)))
    y = np.array(y_raw)
    n_words = len(vocab_processor.vocabulary_)
    print("Vocabulary Size: {:d}".format(n_words))
    return x, y, n_words, vocab_processor

def build_rnn_model(X, n_words, n_hidden, n_steps, n_inputs, n_classes):
    # Embedding layer
    embed_matrix = tf.Variable(tf.random_uniform([n_words, n_inputs], -1.0, 1.0))
    embed = tf.nn.embedding_lookup(embed_matrix, X)

    # LSTM layer
    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden)
    outputs, states = tf.nn.static_rnn(lstm_cell, tf.unstack(embed, axis=1),
                                       dtype=tf.float32)

    # Fully connected layer
    logits = tf.layers.dense(states.h, n_classes, name="output_layer")
    return logits

data_path = "data/sentiment.txt"
x, y, n_words, vocab_processor = get_data(data_path)

X = tf.placeholder(tf.int32, [None, n_steps])
y = tf.placeholder(tf.int32, [None])
logits = build_rnn_model(X, n_words, n_hidden, n_steps, n_inputs, n_classes)

loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss)

correct = tf.nn.in_top_k(logits, y, 1)
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(10):
        for iteration in range(len(x) // 32 // n_steps):
            start = iteration * n_steps
            end = (iteration + 1) * n_steps
            X_batch = x[start:end]
            y_batch = y[start:end]
            sess.run(train_op, feed_dict={X: X_batch, y: y_batch})

        acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
        print(epoch, "Train accuracy:", acc_train)

这里我们使用了基本的LSTM单元，并根据提供的数据训练了一个情感分类模型。我们先通过read_raw_data函数读取数据，然后通过VocabularyProcessor将文本转换成ID，构造LSTM模型，并计算损失和优化器。然后我们迭代地训练模型，并计算训练准确率。

示例2：使用GRU单元实现语音识别

以下是使用GRU单元实现语音识别的简单示例。该模型可以根据所提供的语音文件来预测说话人的语言：

import tensorflow as tf
import numpy as np
import librosa
import os

n_steps = 50
n_inputs = 20
n_neurons = 50
n_classes = 10
learning_rate = 0.01
batch_size = 32
n_epochs = 10

def load_files(data_path):
    X = []
    y = []
    for lang_index, lang in enumerate(os.listdir(data_path)):
        lang_dir = os.path.join(data_path, lang)
        for file in os.listdir(lang_dir):
            file_path = os.path.join(lang_dir, file)
            signal, sr = librosa.load(file_path, res_type='kaiser_fast')
            mfcc = librosa.feature.mfcc(signal, sr, n_mfcc=n_inputs)
            X.append(mfcc.T)
            y.append(lang_index)
    return X, y

def get_batches(X, y):
    num_samples = len(X)
    indices = np.arange(num_samples)
    np.random.shuffle(indices)
    for start_idx in range(0, num_samples - batch_size + 1, batch_size):
        excerpt = indices[start_idx:start_idx + batch_size]
        yield np.array([X[i] for i in excerpt]), np.array([y[i] for i in excerpt])

data_path = "data/langs"
X, y = load_files(data_path)
train_size = int(0.8 * len(X))
X_train, X_test = np.array(X[:train_size]), np.array(X[train_size:])
y_train, y_test = np.array(y[:train_size]), np.array(y[train_size:])

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.int32, [None])

gru_cell = tf.nn.rnn_cell.GRUCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(gru_cell, X, dtype=tf.float32)

logits = tf.layers.dense(states, n_classes, name="output_layer")
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)
loss = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss)

correct = tf.nn.in_top_k(logits, y, 1)
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(n_epochs):
        for X_batch, y_batch in get_batches(X_train, y_train):
            X_batch = np.array([x[:n_steps, :] for x in X_batch])
            sess.run(train_op, feed_dict={X: X_batch, y: y_batch})

        acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
        print(epoch, "Train accuracy:", acc_train)

    X_test = np.array([x[:n_steps, :] for x in X_test])
    acc_test = accuracy.eval(feed_dict={X: X_test, y: y_test})
    print("Test accuracy:", acc_test)

这里我们使用GRU单元作为RNN模型，并使用librosa库将语音文件转换为MFCC特征。然后我们将模型训练了多个迭代，并计算了训练和测试准确率。我们还编写了一个get_batches函数，以便将训练数据划分为小的batch，并将其喂给模型。

总结一下，tf.nn.static_rnn函数是TensorFlow用于构建循环神经网络的有用功能之一，它有助于生成静态RNN，使其在训练和推理期间具有固定的大小。在本文中，我们通过两个实际例子介绍了tf.nn.static_rnn的用法，分别用于情感分类和语音识别。

Tags: