垦荒学园 - 以垦荒之心，赴成长之约

切换主题

循环神经网络 (RNN) ​

循环神经网络（Recurrent Neural Networks, RNN）是一类专门用于处理序列数据的神经网络。与传统的前馈神经网络不同，RNN具有记忆能力，能够处理变长的序列输入。

RNN基础概念 ​

什么是RNN？ ​

RNN是一种具有循环连接的神经网络，它可以处理序列数据，如文本、时间序列、语音等。RNN的核心思想是在网络中引入循环连接，使得网络能够保持对之前信息的记忆。

RNN的结构 ​

python
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

# RNN的基本结构示例
def simple_rnn_example():
    # 创建一个简单的RNN模型
    model = keras.Sequential([
        keras.layers.SimpleRNN(32, return_sequences=True, input_shape=(None, 1)),
        keras.layers.SimpleRNN(32),
        keras.layers.Dense(1)
    ])
    
    return model

# 查看模型结构
model = simple_rnn_example()
model.summary()

RNN的类型 ​

1. 简单RNN (Simple RNN) ​

python
# 简单RNN示例
def create_simple_rnn(units=50, input_shape=(None, 1)):
    model = keras.Sequential([
        keras.layers.SimpleRNN(units, input_shape=input_shape),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    return model

# 创建模型
simple_model = create_simple_rnn()
simple_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

2. LSTM (长短期记忆网络) ​

python
# LSTM示例
def create_lstm_model(units=50, input_shape=(None, 1)):
    model = keras.Sequential([
        keras.layers.LSTM(units, return_sequences=True, input_shape=input_shape),
        keras.layers.Dropout(0.2),
        keras.layers.LSTM(units),
        keras.layers.Dropout(0.2),
        keras.layers.Dense(1)
    ])
    return model

# 创建LSTM模型
lstm_model = create_lstm_model()
lstm_model.compile(optimizer='adam', loss='mse', metrics=['mae'])

3. GRU (门控循环单元) ​

python
# GRU示例
def create_gru_model(units=50, input_shape=(None, 1)):
    model = keras.Sequential([
        keras.layers.GRU(units, return_sequences=True, input_shape=input_shape),
        keras.layers.Dropout(0.2),
        keras.layers.GRU(units),
        keras.layers.Dropout(0.2),
        keras.layers.Dense(1)
    ])
    return model

# 创建GRU模型
gru_model = create_gru_model()
gru_model.compile(optimizer='adam', loss='mse', metrics=['mae'])

序列数据处理 ​

数据预处理 ​

python
def prepare_sequence_data(data, sequence_length):
    """
    准备序列数据
    """
    X, y = [], []
    for i in range(len(data) - sequence_length):
        X.append(data[i:(i + sequence_length)])
        y.append(data[i + sequence_length])
    return np.array(X), np.array(y)

# 示例：时间序列数据
# 生成示例数据
time_steps = np.arange(0, 100, 0.1)
data = np.sin(time_steps) + np.random.normal(0, 0.1, len(time_steps))

# 准备训练数据
sequence_length = 10
X, y = prepare_sequence_data(data, sequence_length)
X = X.reshape((X.shape[0], X.shape[1], 1))

print(f"输入形状: {X.shape}")
print(f"输出形状: {y.shape}")

文本序列处理 ​

文本预处理和词嵌入 ​

python
# 文本序列处理示例
def create_text_rnn_model(vocab_size, embedding_dim=100, max_length=100):
    model = keras.Sequential([
        keras.layers.Embedding(vocab_size, embedding_dim, input_length=max_length),
        keras.layers.LSTM(64, dropout=0.5, recurrent_dropout=0.5),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    return model

# 文本预处理
def preprocess_text_data(texts, max_words=10000, max_length=100):
    # 创建分词器
    tokenizer = keras.preprocessing.text.Tokenizer(num_words=max_words)
    tokenizer.fit_on_texts(texts)
    
    # 转换为序列
    sequences = tokenizer.texts_to_sequences(texts)
    
    # 填充序列
    padded_sequences = keras.preprocessing.sequence.pad_sequences(
        sequences, maxlen=max_length
    )
    
    return padded_sequences, tokenizer

# 示例文本数据
sample_texts = [
    "这是一个正面的评论",
    "这个产品很糟糕",
    "我很喜欢这个服务",
    "完全不推荐"
]

# 预处理文本
sequences, tokenizer = preprocess_text_data(sample_texts)
print(f"序列形状: {sequences.shape}")

双向RNN ​

python
def create_bidirectional_rnn(units=50, input_shape=(None, 1)):
    """
    创建双向RNN模型
    """
    model = keras.Sequential([
        keras.layers.Bidirectional(
            keras.layers.LSTM(units, return_sequences=True),
            input_shape=input_shape
        ),
        keras.layers.Bidirectional(keras.layers.LSTM(units)),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    return model

# 创建双向模型
bidirectional_model = create_bidirectional_rnn()
bidirectional_model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

序列到序列模型 ​

python
def create_seq2seq_model(input_vocab_size, output_vocab_size, 
                        embedding_dim=256, units=512):
    """
    创建序列到序列模型（编码器-解码器架构）
    """
    # 编码器
    encoder_inputs = keras.layers.Input(shape=(None,))
    encoder_embedding = keras.layers.Embedding(input_vocab_size, embedding_dim)(encoder_inputs)
    encoder_lstm = keras.layers.LSTM(units, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    encoder_states = [state_h, state_c]
    
    # 解码器
    decoder_inputs = keras.layers.Input(shape=(None,))
    decoder_embedding = keras.layers.Embedding(output_vocab_size, embedding_dim)
    decoder_lstm = keras.layers.LSTM(units, return_sequences=True, return_state=True)
    decoder_dense = keras.layers.Dense(output_vocab_size, activation='softmax')
    
    decoder_embedding_output = decoder_embedding(decoder_inputs)
    decoder_outputs, _, _ = decoder_lstm(decoder_embedding_output, initial_state=encoder_states)
    decoder_outputs = decoder_dense(decoder_outputs)
    
    # 创建模型
    model = keras.Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    return model

注意力机制 ​

python
class AttentionLayer(keras.layers.Layer):
    """
    简单的注意力机制层
    """
    def __init__(self, units):
        super(AttentionLayer, self).__init__()
        self.units = units
        self.W1 = keras.layers.Dense(units)
        self.W2 = keras.layers.Dense(units)
        self.V = keras.layers.Dense(1)
        
    def call(self, query, values):
        # 计算注意力分数
        score = self.V(tf.nn.tanh(self.W1(query) + self.W2(values)))
        
        # 计算注意力权重
        attention_weights = tf.nn.softmax(score, axis=1)
        
        # 计算上下文向量
        context_vector = attention_weights * values
        context_vector = tf.reduce_sum(context_vector, axis=1)
        
        return context_vector, attention_weights

def create_attention_model(vocab_size, embedding_dim=100, units=128, max_length=100):
    """
    创建带注意力机制的RNN模型
    """
    inputs = keras.layers.Input(shape=(max_length,))
    embedding = keras.layers.Embedding(vocab_size, embedding_dim)(inputs)
    
    # LSTM层
    lstm_output = keras.layers.LSTM(units, return_sequences=True)(embedding)
    
    # 注意力层
    attention = AttentionLayer(units)
    context_vector, attention_weights = attention(lstm_output, lstm_output)
    
    # 输出层
    output = keras.layers.Dense(1, activation='sigmoid')(context_vector)
    
    model = keras.Model(inputs=inputs, outputs=output)
    return model

实际应用示例 ​

股票价格预测 ​

python
def stock_price_prediction_example():
    """
    股票价格预测示例
    """
    # 生成模拟股票数据
    np.random.seed(42)
    days = 1000
    prices = 100 + np.cumsum(np.random.randn(days) * 0.5)
    
    # 数据标准化
    from sklearn.preprocessing import MinMaxScaler
    scaler = MinMaxScaler()
    scaled_prices = scaler.fit_transform(prices.reshape(-1, 1)).flatten()
    
    # 准备序列数据
    sequence_length = 60
    X, y = prepare_sequence_data(scaled_prices, sequence_length)
    X = X.reshape((X.shape[0], X.shape[1], 1))
    
    # 分割训练和测试数据
    split_idx = int(0.8 * len(X))
    X_train, X_test = X[:split_idx], X[split_idx:]
    y_train, y_test = y[:split_idx], y[split_idx:]
    
    # 创建模型
    model = keras.Sequential([
        keras.layers.LSTM(50, return_sequences=True, input_shape=(sequence_length, 1)),
        keras.layers.Dropout(0.2),
        keras.layers.LSTM(50, return_sequences=True),
        keras.layers.Dropout(0.2),
        keras.layers.LSTM(50),
        keras.layers.Dropout(0.2),
        keras.layers.Dense(1)
    ])
    
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    
    # 训练模型
    history = model.fit(
        X_train, y_train,
        epochs=50,
        batch_size=32,
        validation_data=(X_test, y_test),
        verbose=1
    )
    
    return model, history, scaler

# 运行示例
# model, history, scaler = stock_price_prediction_example()

情感分析 ​

python
def sentiment_analysis_example():
    """
    情感分析示例
    """
    # 示例数据（实际应用中应使用更大的数据集）
    texts = [
        "这个电影真的很棒！",
        "我不喜欢这个产品",
        "服务质量很好",
        "完全浪费时间",
        "强烈推荐给大家"
    ]
    labels = [1, 0, 1, 0, 1]  # 1: 正面, 0: 负面
    
    # 预处理
    max_words = 1000
    max_length = 50
    
    tokenizer = keras.preprocessing.text.Tokenizer(num_words=max_words)
    tokenizer.fit_on_texts(texts)
    sequences = tokenizer.texts_to_sequences(texts)
    X = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=max_length)
    y = np.array(labels)
    
    # 创建模型
    model = keras.Sequential([
        keras.layers.Embedding(max_words, 100, input_length=max_length),
        keras.layers.LSTM(64, dropout=0.5, recurrent_dropout=0.5),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    
    model.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    return model, X, y, tokenizer

# 运行示例
# model, X, y, tokenizer = sentiment_analysis_example()

RNN的优缺点 ​

优点 ​

  • 能够处理变长序列
  • 具有记忆能力
  • 参数共享，模型相对简单

缺点 ​

  • 梯度消失问题
  • 训练速度较慢
  • 难以并行化

解决方案 ​

  • 使用LSTM或GRU解决梯度消失
  • 使用注意力机制提高性能
  • 考虑使用Transformer替代RNN

最佳实践 ​

  1. 选择合适的RNN类型：

    • 简单任务使用SimpleRNN
    • 长序列使用LSTM或GRU
    • 需要双向信息使用Bidirectional RNN

  2. 数据预处理：

    • 适当的序列长度
    • 数据标准化
    • 处理变长序列

  3. 模型优化：

    • 使用Dropout防止过拟合
    • 适当的学习率
    • 批量大小调优

  4. 监控训练：

    • 使用验证集监控性能
    • 早停机制
    • 学习率调度

总结 ​

RNN是处理序列数据的重要工具，虽然在某些任务上已被Transformer等新架构超越，但在许多应用中仍然非常有效。理解RNN的原理和实现对于深度学习从业者来说是必不可少的。

下一章我们将学习Transformer模型，它在许多NLP任务中已经成为主流选择。

本站内容仅供学习和研究使用。

Copyright 2025 垦荒教程 kenhuang.com All Rights Reserved. 备案号：粤ICP备17084064号-3 | 免责声明