当前位置：首页 > news >正文

循环神经网络（Recurrent Neural Network, RNN）与 Transformer

news 来源：原创 2025/6/13 16:18:11

循环神经网络（RNN）与 Transformer

1. 循环神经网络（RNN）简介

1.1 RNN 结构

循环神经网络（Recurrent Neural Network, RNN）是一种适用于处理序列数据的神经网络。其核心特点是通过隐藏状态（Hidden State）存储过去的信息，并将其传递到当前时间步，以捕捉时间上的依赖关系。

常见的 RNN 变体包括：

基本 RNN：直接连接隐藏状态，容易出现梯度消失或梯度爆炸问题。
长短时记忆网络（LSTM）：通过引入输入门、遗忘门、输出门解决梯度消失问题。
门控循环单元（GRU）：结构比 LSTM 更简单，计算效率更高。

1.2 RNN 应用场景

语音识别（如 Google 语音助手）
机器翻译（如 Google 翻译）
文本生成（如 GPT 系列模型的早期版本）
股票预测
时间序列分析

1.3 RNN 优缺点

✅ 优点：

能处理变长序列输入
能够捕捉时间序列数据中的依赖关系

❌ 缺点：

梯度消失或梯度爆炸（主要问题）
训练较慢，难以并行计算
远程依赖问题（即长期依赖难以保留）

2. Transformer 简介

2.1 Transformer 结构

Transformer 由 Vaswani 等人在 2017 年提出，彻底改变了 NLP 领域。其核心思想是完全依赖 自注意力机制（Self-Attention） 进行序列建模，而不使用循环网络。

Transformer 由 编码器（Encoder） 和 解码器（Decoder） 组成，每个模块包含：

多头自注意力机制（Multi-Head Self Attention）
前馈神经网络（Feedforward Neural Network）
跳跃连接（Residual Connection）和 Layer Normalization

2.2 Transformer 应用场景

机器翻译（如 Google 翻译）
文本摘要（如 ChatGPT）
代码补全（如 GitHub Copilot）
图像识别（如 Vision Transformer）

2.3 Transformer 优缺点

✅ 优点：

并行计算能力强（相较于 RNN）
处理长距离依赖能力强
训练收敛快

❌ 缺点：

计算复杂度高，消耗大量内存
对长序列的推理成本较高

3. Java 实现 RNN 和 Transformer

在 Java 中，我们可以使用 DeepLearning4J（DL4J） 库来实现 RNN 和 Transformer。

3.1 RNN 例子（时间序列预测）

import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.GravesLSTM;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.weights.WeightInit;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.lossfunctions.LossFunctions;

public class RNNExample {
    public static void main(String[] args) {
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
            .weightInit(WeightInit.XAVIER)
            .list()
            .layer(0, new GravesLSTM.Builder().nIn(10).nOut(50)
                .activation(Activation.TANH).build())
            .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.MSE)
                .activation(Activation.IDENTITY).nIn(50).nOut(1).build())
            .build();

        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        model.setListeners(new ScoreIterationListener(10));

        System.out.println("RNN 模型创建完成！");
    }
}

该示例使用 GravesLSTM（LSTM 变体）来创建一个简单的时间序列预测模型。

3.2 Transformer 例子（文本分类）

import ai.djl.Model;
import ai.djl.ModelException;
import ai.djl.basicmodelzoo.basic.TransformerBlock;
import ai.djl.inference.Predictor;
import ai.djl.modality.Classifications;
import ai.djl.modality.nlp.DefaultVocabulary;
import ai.djl.modality.nlp.embedding.WordEmbedding;
import ai.djl.modality.nlp.preprocess.SimpleTokenizer;
import ai.djl.translate.TranslateException;
import ai.djl.translate.Translator;
import ai.djl.translate.TranslatorContext;
import ai.djl.translate.TranslatorFactory;
import ai.djl.util.Utils;

import java.io.IOException;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;

public class TransformerExample {
    public static void main(String[] args) throws IOException, ModelException, TranslateException {
        Model model = Model.newInstance("Transformer");
        model.setBlock(new TransformerBlock(256, 8, 512, 6));

        Translator<String, Classifications> translator = new Translator<String, Classifications>() {
            @Override
            public Classifications processOutput(TranslatorContext ctx, ai.djl.ndarray.NDList list) {
                return new Classifications(Arrays.asList("Positive", "Negative"), list.singletonOrThrow());
            }

            @Override
            public ai.djl.ndarray.NDList processInput(TranslatorContext ctx, String input) {
                WordEmbedding embedding = WordEmbedding.builder().optModelPath(Paths.get("glove.6B.50d.txt")).build();
                List<String> tokens = new SimpleTokenizer().tokenize(input);
                return new ai.djl.ndarray.NDList(embedding.getEmbedding(tokens));
            }
        };

        Predictor<String, Classifications> predictor = model.newPredictor(translator);
        System.out.println(predictor.predict("This is a great product!"));
    }
}

该示例使用 DJL（Deep Java Library） 实现了一个 Transformer 进行文本分类任务。

4. 结论

RNN 适用于时间序列数据，但存在梯度消失问题。
Transformer 依靠自注意力机制解决了长距离依赖问题，并且计算效率更高。
在 Java 中，可以使用 DeepLearning4J（DL4J） 训练 RNN，使用 DJL（Deep Java Library） 实现 Transformer。