MATLAB递归神经网络（RNN）机器学习指南

bubiyoushang8882026-06-01 16:13

一、RNN基础理论与MATLAB实现

1.1 RNN核心概念

复制代码 
递归神经网络（Recurrent Neural Network）通过隐藏状态传递时间信息
h_t = tanh(W_xh * x_t + W_hh * h_{t-1} + b_h)
y_t = W_hy * h_t + b_y

1.2 MATLAB支持的RNN类型

RNN类型 MATLAB函数 特点
Simple RNN lstmLayer (基础) 简单循环，梯度消失问题
LSTM lstmLayer 长短期记忆，解决梯度消失
GRU gruLayer 门控循环单元，简化版LSTM
BiLSTM bilstmLayer 双向LSTM，同时利用过去和未来信息
Custom RNN dlnetwork 自定义RNN架构

二、RNN实现代码

2.1 基础RNN时间序列预测

matlab 复制代码 
%% 基础RNN时间序列预测
clear; clc; close all;

%% 1. 生成时间序列数据
fprintf('=== RNN时间序列预测 ===\n');

% 生成正弦波+噪声数据
N = 1000;
t = linspace(0, 10*pi, N)';
data = sin(t) + 0.1*randn(N, 1);

% 可视化数据
figure('Position', [100, 100, 800, 400]);
subplot(1,2,1);
plot(t, data, 'b-', 'LineWidth', 1.5);
xlabel('时间'); ylabel('幅值');
title('原始时间序列数据');
grid on;

%% 2. 准备训练数据
fprintf('准备训练数据...\n');

% 使用滑动窗口创建输入输出对
lookback = 20;      % 回顾20个时间点
horizon = 5;        % 预测未来5个点
[XTrain, YTrain] = create_sliding_windows(data, lookback, horizon);

% 划分训练测试集
train_ratio = 0.8;
N_train = round(size(XTrain, 1) * train_ratio);
X_train = XTrain(1:N_train, :, :);
Y_train = YTrain(1:N_train, :, :);
X_test = XTrain(N_train+1:end, :, :);
Y_test = YTrain(N_train+1:end, :, :);

fprintf('训练样本: %d, 测试样本: %d\n', size(X_train,1), size(X_test,1));

%% 3. 构建RNN模型
fprintf('构建RNN模型...\n');

layers = [
    sequenceInputLayer(1)          % 输入层，1个特征
    lstmLayer(50, 'OutputMode', 'sequence')  % LSTM层，50个隐藏单元
    fullyConnectedLayer(horizon)    % 全连接层，输出5个预测点
    regressionLayer];              % 回归层

% 训练选项
options = trainingOptions('adam', ...
    'MaxEpochs', 100, ...
    'MiniBatchSize', 32, ...
    'InitialLearnRate', 0.01, ...
    'LearnRateSchedule', 'piecewise', ...
    'LearnRateDropFactor', 0.5, ...
    'LearnRateDropPeriod', 50, ...
    'Shuffle', 'every-epoch', ...
    'ValidationData', {X_test, Y_test}, ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 4. 训练模型
fprintf('训练RNN模型...\n');
net = trainNetwork(X_train, Y_train, layers, options);

%% 5. 测试模型
fprintf('测试模型...\n');
YPred = predict(net, X_test);

% 计算性能指标
rmse = sqrt(mean((Y_test(:) - YPred(:)).^2));
mae = mean(abs(Y_test(:) - YPred(:)));
fprintf('RMSE: %.4f, MAE: %.4f\n', rmse, mae);

%% 6. 可视化预测结果
subplot(1,2,2);
plot_predictions(Y_test, YPred, horizon);
title('RNN预测结果');

2.2 滑动窗口数据生成函数

matlab 复制代码 
function [X, Y] = create_sliding_windows(data, lookback, horizon)
    % 创建滑动窗口数据
    % data: 时间序列数据 [N×1]
    % lookback: 回顾窗口长度
    % horizon: 预测窗口长度
    
    N = length(data);
    num_samples = N - lookback - horizon + 1;
    
    X = zeros(num_samples, lookback, 1);
    Y = zeros(num_samples, horizon, 1);
    
    for i = 1:num_samples
        % 输入序列
        X(i, :, 1) = data(i:i+lookback-1);
        
        % 输出序列
        Y(i, :, 1) = data(i+lookback:i+lookback+horizon-1);
    end
end

function plot_predictions(Y_true, Y_pred, horizon)
    % 可视化预测结果
    num_samples = size(Y_true, 1);
    sample_idx = 1:min(5, num_samples);  % 显示前5个样本
    
    colors = lines(length(sample_idx));
    
    for i = 1:length(sample_idx)
        idx = sample_idx(i);
        subplot(ceil(length(sample_idx)/2), 2, i);
        
        % 绘制真实值
        plot(1:horizon, Y_true(idx, :, 1), 'o-', ...
            'Color', colors(i,:), 'LineWidth', 1.5, 'MarkerSize', 6);
        hold on;
        
        % 绘制预测值
        plot(1:horizon, Y_pred(idx, :, 1), 's--', ...
            'Color', colors(i,:)*0.7, 'LineWidth', 1.5, 'MarkerSize', 6);
        
        xlabel('预测步长');
        ylabel('幅值');
        title(sprintf('样本 %d', idx));
        legend('真实值', '预测值', 'Location', 'northwest');
        grid on;
    end
end

2.3 多变量RNN预测

matlab 复制代码 
%% 多变量RNN预测（多个输入特征）
clear; clc; close all;

%% 1. 生成多变量时间序列
fprintf('=== 多变量RNN预测 ===\n');

N = 1000;
t = linspace(0, 10*pi, N)';

% 三个相关的时间序列
data1 = sin(t) + 0.1*randn(N, 1);      % 主序列
data2 = cos(t) + 0.1*randn(N, 1);      % 相关序列1
data3 = sin(t + pi/4) + 0.1*randn(N, 1); % 相关序列2

% 合并为多变量数据
multi_data = [data1, data2, data3];

%% 2. 准备数据
lookback = 30;
horizon = 10;
[XTrain, YTrain] = create_multivariate_windows(multi_data, lookback, horizon);

%% 3. 构建多变量RNN模型
layers = [
    sequenceInputLayer(3)          % 3个输入特征
    lstmLayer(100, 'OutputMode', 'sequence')
    dropoutLayer(0.2)              % Dropout防止过拟合
    lstmLayer(50, 'OutputMode', 'last')
    fullyConnectedLayer(horizon)
    regressionLayer];

options = trainingOptions('adam', ...
    'MaxEpochs', 200, ...
    'MiniBatchSize', 64, ...
    'InitialLearnRate', 0.005, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 4. 训练模型
net = trainNetwork(XTrain, YTrain, layers, options);

%% 5. 预测和评估
YPred = predict(net, XTrain);

% 计算相关系数
corr_coeff = corr(YTrain(:), YPred(:));
fprintf('预测相关系数: %.4f\n', corr_coeff);

%% 6. 可视化多变量预测
figure('Position', [100, 100, 1200, 400]);
for i = 1:3
    subplot(1,3,i);
    plot(YTrain(1:100, i), 'b-', 'LineWidth', 1.5); hold on;
    plot(YPred(1:100, i), 'r--', 'LineWidth', 1.5);
    xlabel('时间步'); ylabel(['特征 ' num2str(i)]);
    title(['特征 ' num2str(i) ' 预测']);
    legend('真实值', '预测值');
    grid on;
end

2.4 自定义RNN实现（不使用深度学习工具箱）

matlab 复制代码 
%% 自定义RNN实现（教育目的）
classdef CustomRNN < handle
    % 简单的RNN实现，用于理解RNN工作原理
    
    properties
        W_xh      % 输入到隐藏层权重
        W_hh      % 隐藏层到隐藏层权重
        W_hy      % 隐藏层到输出层权重
        b_h       % 隐藏层偏置
        b_y       % 输出层偏置
        hidden_size
        input_size
        output_size
    end
    
    methods
        function obj = CustomRNN(input_size, hidden_size, output_size)
            % 初始化RNN
            obj.input_size = input_size;
            obj.hidden_size = hidden_size;
            obj.output_size = output_size;
            
            % Xavier初始化
            limit = sqrt(6/(input_size + hidden_size));
            obj.W_xh = limit * (2*rand(hidden_size, input_size) - 1);
            obj.W_hh = limit * (2*rand(hidden_size, hidden_size) - 1);
            obj.W_hy = limit * (2*rand(output_size, hidden_size) - 1);
            
            obj.b_h = zeros(hidden_size, 1);
            obj.b_y = zeros(output_size, 1);
        end
        
        function [output, hidden] = forward(obj, input, hidden_prev)
            % 前向传播
            % input: [input_size × sequence_length]
            % hidden_prev: [hidden_size × 1]
            
            sequence_length = size(input, 2);
            hidden = hidden_prev;
            output = zeros(obj.output_size, sequence_length);
            
            for t = 1:sequence_length
                % RNN单元计算
                x_t = input(:, t);
                hidden = tanh(obj.W_xh * x_t + obj.W_hh * hidden + obj.b_h);
                output(:, t) = obj.W_hy * hidden + obj.b_y;
            end
        end
        
        function gradients = backward(obj, input, target, learning_rate)
            % 反向传播（简化版）
            % 这里实现简化的梯度计算
            
            % 前向传播获取中间值
            [~, hidden_states] = obj.forward(input, zeros(obj.hidden_size, 1));
            
            % 计算梯度（简化实现）
            error = hidden_states - target;
            
            % 更新权重（简化梯度下降）
            obj.W_hy = obj.W_hy - learning_rate * error * hidden_states';
            obj.b_y = obj.b_y - learning_rate * error;
        end
    end
end

%% 使用自定义RNN
function custom_rnn_demo()
    fprintf('=== 自定义RNN演示 ===\n');
    
    % 创建RNN
    rnn = CustomRNN(1, 10, 1);
    
    % 生成简单数据
    N = 100;
    x = linspace(0, 2*pi, N)';
    y = sin(x);
    
    % 训练循环
    learning_rate = 0.01;
    epochs = 1000;
    
    for epoch = 1:epochs
        % 前向传播
        [output, ~] = rnn.forward(y, zeros(10, 1));
        
        % 计算损失
        loss = mean((output - y).^2);
        
        % 反向传播（简化）
        rnn.backward(y, y, learning_rate);
        
        if mod(epoch, 100) == 0
            fprintf('Epoch %d: Loss = %.4f\n', epoch, loss);
        end
    end
end

三、高级RNN应用

3.1 LSTM股票价格预测

matlab 复制代码 
%% LSTM股票价格预测
clear; clc; close all;

%% 1. 加载股票数据
fprintf('=== LSTM股票价格预测 ===\n');

% 使用内置的股票数据
load stockprice.mat
data = stockprice.Close;
dates = stockprice.Date;

% 数据归一化
mu = mean(data);
sigma = std(data);
data_norm = (data - mu) / sigma;

%% 2. 准备训练数据
lookback = 60;      % 回顾60天
horizon = 1;        % 预测下一天
[XTrain, YTrain] = create_sliding_windows(data_norm, lookback, horizon);

% 转换为dlarray（用于自动微分）
XTrain_dl = dlarray(XTrain, 'BT');
YTrain_dl = dlarray(YTrain, 'BT');

%% 3. 构建LSTM网络
layers = [
    sequenceInputLayer(1)
    lstmLayer(128, 'OutputMode', 'sequence')
    dropoutLayer(0.3)
    lstmLayer(64, 'OutputMode', 'last')
    fullyConnectedLayer(1)
    regressionLayer];

options = trainingOptions('adam', ...
    'MaxEpochs', 50, ...
    'MiniBatchSize', 128, ...
    'InitialLearnRate', 0.001, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 4. 训练模型
net = trainNetwork(XTrain, YTrain, layers, options);

%% 5. 预测未来30天
future_days = 30;
last_sequence = data_norm(end-lookback+1:end);
predictions = zeros(future_days, 1);

for i = 1:future_days
    % 准备输入
    input_seq = reshape(last_sequence, 1, lookback, 1);
    
    % 预测
    pred = predict(net, input_seq);
    predictions(i) = pred;
    
    % 更新序列
    last_sequence = [last_sequence(2:end); pred];
end

% 反归一化
predictions = predictions * sigma + mu;
last_price = data(end);

%% 6. 可视化结果
figure('Position', [100, 100, 1200, 600]);

subplot(2,1,1);
plot(dates, data, 'b-', 'LineWidth', 1.5);
hold on;
plot(dates(end)+days(1:future_days), predictions, 'r--', 'LineWidth', 1.5);
xlabel('日期'); ylabel('股价');
title('股票价格预测');
legend('历史价格', '预测价格');
grid on;

subplot(2,1,2);
plot(1:future_days, predictions, 'ro-', 'LineWidth', 1.5, 'MarkerSize', 8);
xlabel('未来天数'); ylabel('预测股价');
title('未来30天股价预测');
grid on;

fprintf('当前股价: %.2f\n', last_price);
fprintf('30天后预测股价: %.2f\n', predictions(end));
fprintf('预期涨幅: %.2f%%\n', (predictions(end)-last_price)/last_price*100);

3.2 双向LSTM序列分类

matlab 复制代码 
%% 双向LSTM序列分类
clear; clc; close all;

%% 1. 生成序列分类数据
fprintf('=== 双向LSTM序列分类 ===\n');

% 生成三类序列数据
num_samples = 500;
seq_length = 50;
num_classes = 3;

X = zeros(num_samples, seq_length, 1);
Y = zeros(num_samples, 1);

for i = 1:num_samples
    class = randi(num_classes);
    Y(i) = class;
    
    switch class
        case 1
            % 正弦波
            t = linspace(0, 2*pi, seq_length)';
            X(i, :, 1) = sin(t) + 0.1*randn(seq_length, 1);
        case 2
            % 方波
            X(i, :, 1) = square(linspace(0, 2*pi, seq_length)') + 0.1*randn(seq_length, 1);
        case 3
            % 锯齿波
            X(i, :, 1) = sawtooth(linspace(0, 2*pi, seq_length)') + 0.1*randn(seq_length, 1);
    end
end

%% 2. 构建双向LSTM网络
layers = [
    sequenceInputLayer(1)
    bilstmLayer(64, 'OutputMode', 'last')
    dropoutLayer(0.2)
    fullyConnectedLayer(32)
    reluLayer
    fullyConnectedLayer(num_classes)
    softmaxLayer
    classificationLayer];

options = trainingOptions('adam', ...
    'MaxEpochs', 100, ...
    'MiniBatchSize', 32, ...
    'InitialLearnRate', 0.01, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 3. 训练模型
net = trainNetwork(X, categorical(Y), layers, options);

%% 4. 测试模型
YPred = classify(net, X);
accuracy = mean(YPred == categorical(Y)) * 100;
fprintf('分类准确率: %.2f%%\n', accuracy);

%% 5. 混淆矩阵
figure('Position', [100, 100, 600, 500]);
confusionchart(categorical(Y), YPred, ...
    'Title', '序列分类混淆矩阵', ...
    'RowSummary', 'row-normalized');

3.3 注意力机制RNN

matlab 复制代码 
%% 注意力机制RNN（自定义层）
classdef AttentionLayer < nnet.layer.Layer
    % 自定义注意力层
    
    properties
        Weights
        Bias
    end
    
    methods
        function layer = AttentionLayer(numHiddenUnits)
            layer.Weights = randn(numHiddenUnits, numHiddenUnits);
            layer.Bias = zeros(numHiddenUnits, 1);
        end
        
        function Z = predict(layer, X)
            % X: [numHiddenUnits × sequenceLength]
            [numHiddenUnits, seqLength] = size(X);
            
            % 计算注意力分数
            scores = layer.Weights' * X + layer.Bias;
            attentionWeights = softmax(scores, 'DataFormat', 'CB');
            
            % 加权求和
            Z = sum(X .* attentionWeights, 2);
        end
    end
end

%% 使用注意力机制的RNN
function attention_rnn_demo()
    fprintf('=== 注意力机制RNN ===\n');
    
    % 构建带注意力的RNN
    layers = [
        sequenceInputLayer(1)
        lstmLayer(50, 'OutputMode', 'sequence')
        AttentionLayer(50)
        fullyConnectedLayer(1)
        regressionLayer];
    
    % 训练数据
    N = 500;
    t = linspace(0, 10*pi, N)';
    X = sin(t) + 0.1*randn(N, 1);
    Y = cos(t) + 0.1*randn(N, 1);
    
    % 准备序列数据
    lookback = 20;
    XSeq = zeros(N-lookback, lookback, 1);
    YSeq = zeros(N-lookback, 1);
    
    for i = 1:N-lookback
        XSeq(i, :, 1) = X(i:i+lookback-1);
        YSeq(i) = Y(i+lookback);
    end
    
    % 训练
    options = trainingOptions('adam', ...
        'MaxEpochs', 100, ...
        'MiniBatchSize', 32, ...
        'InitialLearnRate', 0.01, ...
        'Plots', 'training-progress', ...
        'Verbose', false);
    
    net = trainNetwork(XSeq, YSeq, layers, options);
    fprintf('注意力RNN训练完成\n');
end

四、RNN优化与调参

4.1 超参数调优

matlab 复制代码 
%% RNN超参数调优
function tune_rnn_hyperparameters()
    fprintf('=== RNN超参数调优 ===\n');
    
    % 参数网格
    hidden_units = [32, 64, 128];
    learning_rates = [0.01, 0.005, 0.001];
    dropout_rates = [0.1, 0.2, 0.3];
    
    best_accuracy = 0;
    best_params = struct();
    
    for hu = hidden_units
        for lr = learning_rates
            for dr = dropout_rates
                fprintf('测试: HU=%d, LR=%.4f, DR=%.2f\n', hu, lr, dr);
                
                % 构建模型
                layers = [
                    sequenceInputLayer(1)
                    lstmLayer(hu, 'OutputMode', 'sequence')
                    dropoutLayer(dr)
                    lstmLayer(hu/2, 'OutputMode', 'last')
                    fullyConnectedLayer(1)
                    regressionLayer];
                
                options = trainingOptions('adam', ...
                    'MaxEpochs', 50, ...
                    'MiniBatchSize', 32, ...
                    'InitialLearnRate', lr, ...
                    'Shuffle', 'every-epoch', ...
                    'Verbose', false);
                
                % 训练和评估
                % ... 这里省略训练和评估代码 ...
                
                % 记录最佳参数
                if accuracy > best_accuracy
                    best_accuracy = accuracy;
                    best_params.hidden_units = hu;
                    best_params.learning_rate = lr;
                    best_params.dropout_rate = dr;
                end
            end
        end
    end
    
    fprintf('最佳参数: HU=%d, LR=%.4f, DR=%.2f, Acc=%.2f%%\n', ...
        best_params.hidden_units, best_params.learning_rate, ...
        best_params.dropout_rate, best_accuracy);
end

4.2 正则化与防止过拟合

matlab 复制代码 
%% RNN正则化技术
function regularized_rnn()
    % 1. Dropout正则化
    layers = [
        sequenceInputLayer(1)
        lstmLayer(100, 'OutputMode', 'sequence')
        dropoutLayer(0.3)           % Dropout层
        lstmLayer(50, 'OutputMode', 'last')
        dropoutLayer(0.2)           % 另一个Dropout层
        fullyConnectedLayer(1)
        regressionLayer];
    
    % 2. L2正则化
    options = trainingOptions('adam', ...
        'MaxEpochs', 100, ...
        'MiniBatchSize', 32, ...
        'InitialLearnRate', 0.01, ...
        'L2Regularization', 0.001, ...  % L2正则化
        'Shuffle', 'every-epoch', ...
        'Plots', 'training-progress', ...
        'Verbose', false);
    
    % 3. 早停法（Early Stopping）
    options = trainingOptions('adam', ...
        'MaxEpochs', 1000, ...
        'MiniBatchSize', 32, ...
        'InitialLearnRate', 0.01, ...
        'ValidationPatience', 10, ...   % 10个epoch无改善则停止
        'Shuffle', 'every-epoch', ...
        'Plots', 'training-progress', ...
        'Verbose', false);
end

4.3 梯度裁剪与优化

matlab 复制代码 
%% 梯度裁剪与高级优化
function gradient_clipping_demo()
    % 使用自定义训练循环实现梯度裁剪
    
    % 定义RNN模型
    layers = [
        sequenceInputLayer(1)
        lstmLayer(100, 'OutputMode', 'sequence')
        fullyConnectedLayer(1)
        regressionLayer];
    
    % 训练选项
    options = trainingOptions('adam', ...
        'MaxEpochs', 100, ...
        'MiniBatchSize', 32, ...
        'InitialLearnRate', 0.01, ...
        'GradientThreshold', 1.0, ...      % 梯度裁剪阈值
        'GradientThresholdMethod', 'l2norm', ...
        'Shuffle', 'every-epoch', ...
        'Plots', 'training-progress', ...
        'Verbose', false);
    
    % 训练模型
    net = trainNetwork(XTrain, YTrain, layers, options);
end

参考代码 matlab递归神经网络机器学习 www.youwenfan.com/contentcsv/79308.html

五、实际应用案例

5.1 电力负荷预测

matlab 复制代码 
%% 电力负荷预测RNN
clear; clc; close all;

%% 1. 加载电力负荷数据
fprintf('=== 电力负荷预测 ===\n');

% 生成模拟电力负荷数据（24小时周期）
hours = 0:23;
days = 1:365;
[HH, DD] = meshgrid(hours, days);

% 基础负荷 + 工作日/周末模式 + 随机噪声
base_load = 100 + 50*sin(2*pi*hours/24);  % 日周期
weekday_factor = 1 + 0.3*(DD(:) <= 260);  % 工作日负荷更高
random_noise = 5*randn(size(base_load));

load_data = base_load .* weekday_factor + random_noise;

% 展平为时间序列
load_series = load_data(:);
time_series = (1:length(load_series))';

%% 2. 准备训练数据
lookback = 168;  % 回顾一周（24*7=168小时）
horizon = 24;    % 预测明天24小时
[XTrain, YTrain] = create_sliding_windows(load_series, lookback, horizon);

%% 3. 构建电力负荷预测模型
layers = [
    sequenceInputLayer(1)
    lstmLayer(200, 'OutputMode', 'sequence')
    dropoutLayer(0.2)
    lstmLayer(100, 'OutputMode', 'last')
    fullyConnectedLayer(50)
    reluLayer
    fullyConnectedLayer(horizon)
    regressionLayer];

options = trainingOptions('adam', ...
    'MaxEpochs', 100, ...
    'MiniBatchSize', 64, ...
    'InitialLearnRate', 0.005, ...
    'LearnRateSchedule', 'piecewise', ...
    'LearnRateDropFactor', 0.5, ...
    'LearnRateDropPeriod', 50, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 4. 训练模型
net = trainNetwork(XTrain, YTrain, layers, options);

%% 5. 预测未来一周负荷
future_days = 7;
predictions = zeros(future_days*24, 1);
last_sequence = load_series(end-lookback+1:end);

for day = 1:future_days
    % 预测一天
    input_seq = reshape(last_sequence, 1, lookback, 1);
    daily_pred = predict(net, input_seq)';
    
    % 存储预测
    predictions((day-1)*24+1:day*24) = daily_pred;
    
    % 更新序列
    last_sequence = [last_sequence(25:end); daily_pred];
end

%% 6. 可视化结果
figure('Position', [100, 100, 1400, 600]);

subplot(2,1,1);
plot(time_series(end-500:end), load_series(end-500:end), 'b-', 'LineWidth', 1.5);
xlabel('时间（小时）'); ylabel('负荷（MW）');
title('历史电力负荷');
grid on;

subplot(2,1,2);
plot(1:length(predictions), predictions, 'r-', 'LineWidth', 1.5);
xlabel('未来时间（小时）'); ylabel('预测负荷（MW）');
title('未来一周电力负荷预测');
grid on;

fprintf('平均预测负荷: %.2f MW\n', mean(predictions));

5.2 自然语言处理（字符级RNN）

matlab 复制代码 
%% 字符级RNN文本生成
clear; clc; close all;

%% 1. 准备文本数据
fprintf('=== 字符级RNN文本生成 ===\n');

% 示例文本
text = fileread('shakespeare.txt');  % 莎士比亚作品
% 或者使用内置文本
text = "To be or not to be, that is the question. Whether 'tis nobler in the mind to suffer...";

% 创建字符映射
chars = unique(text);
char_to_idx = containers.Map(chars, 1:length(chars));
idx_to_char = containers.Map(1:length(chars), chars);

fprintf('字符集大小: %d\n', length(chars));

%% 2. 准备训练数据
seq_length = 25;  % 序列长度
num_sequences = length(text) - seq_length;

X = zeros(num_sequences, seq_length, 1);
Y = zeros(num_sequences, 1);

for i = 1:num_sequences
    sequence = text(i:i+seq_length-1);
    next_char = text(i+seq_length);
    
    % 转换为索引
    X(i, :, 1) = cell2mat(values(char_to_idx, sequence))';
    Y(i) = char_to_idx(next_char);
end

%% 3. 构建字符级RNN
layers = [
    sequenceInputLayer(1)
    embeddingLayer(50, length(chars))  % 嵌入层
    lstmLayer(128, 'OutputMode', 'last')
    fullyConnectedLayer(length(chars))
    softmaxLayer
    classificationLayer];

options = trainingOptions('adam', ...
    'MaxEpochs', 50, ...
    'MiniBatchSize', 128, ...
    'InitialLearnRate', 0.001, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

%% 4. 训练模型
net = trainNetwork(X, categorical(Y), layers, options);

%% 5. 生成文本
seed_text = "To be";
generated_text = seed_text;

for i = 1:100  % 生成100个字符
    % 准备输入序列
    input_seq = zeros(1, seq_length, 1);
    for j = 1:min(length(seed_text), seq_length)
        input_seq(1, end-j+1, 1) = char_to_idx(seed_text(end-j+1));
    end
    
    % 预测下一个字符
    probs = predict(net, input_seq);
    next_char_idx = randsample(length(chars), 1, true, probs);
    next_char = idx_to_char(next_char_idx);
    
    % 添加到生成文本
    generated_text = [generated_text, next_char];
    seed_text = [seed_text(2:end), next_char];
end

fprintf('生成的文本:\n%s\n', generated_text);

六、性能评估与调试

6.1 RNN性能评估指标

matlab 复制代码 
%% RNN性能评估
function evaluate_rnn_performance(Y_true, Y_pred, task_type)
    % 根据任务类型选择评估指标
    
    fprintf('=== RNN性能评估 ===\n');
    
    switch task_type
        case 'regression'
            % 回归任务指标
            rmse = sqrt(mean((Y_true(:) - Y_pred(:)).^2));
            mae = mean(abs(Y_true(:) - Y_pred(:)));
            r2 = 1 - sum((Y_true(:) - Y_pred(:)).^2) / sum((Y_true(:) - mean(Y_true(:))).^2);
            
            fprintf('RMSE: %.4f\n', rmse);
            fprintf('MAE: %.4f\n', mae);
            fprintf('R²: %.4f\n', r2);
            
        case 'classification'
            % 分类任务指标
            accuracy = mean(Y_true == Y_pred) * 100;
            confusion_mat = confusionmat(Y_true, Y_pred);
            
            fprintf('准确率: %.2f%%\n', accuracy);
            fprintf('混淆矩阵:\n');
            disp(confusion_mat);
    end
end

6.2 RNN调试技巧

matlab 复制代码 
%% RNN调试技巧
function debug_rnn()
    fprintf('=== RNN调试技巧 ===\n');
    
    % 1. 检查梯度消失/爆炸
    fprintf('1. 检查梯度范数\n');
    fprintf('   - 使用gradientThreshold参数\n');
    fprintf('   - 监控梯度范数是否在合理范围内\n');
    
    % 2. 检查数据归一化
    fprintf('2. 数据归一化\n');
    fprintf('   - 确保所有输入特征在相同尺度\n');
    fprintf('   - 使用z-score或min-max归一化\n');
    
    % 3. 检查序列长度
    fprintf('3. 序列长度选择\n');
    fprintf('   - 太短：无法捕捉长期依赖\n');
    fprintf('   - 太长：训练困难，梯度消失\n');
    
    % 4. 检查隐藏单元数量
    fprintf('4. 隐藏单元数量\n');
    fprintf('   - 太少：欠拟合\n');
    fprintf('   - 太多：过拟合\n');
    
    % 5. 学习率调试
    fprintf('5. 学习率调试\n');
    fprintf('   - 太大：训练不稳定\n');
    fprintf('   - 太小：训练缓慢\n');
    fprintf('   - 使用学习率调度\n');
end

七、总结

本指南提供了完整的MATLAB RNN机器学习实现：

  1. 基础RNN：时间序列预测、多变量预测
  2. 高级RNN：LSTM、GRU、双向LSTM、注意力机制
  3. 实际应用：股票价格预测、电力负荷预测、文本生成
  4. 优化技术：超参数调优、正则化、梯度裁剪
  5. 性能评估：回归和分类任务的评估指标

关键要点：

  • 使用lstmLayer构建RNN模型
  • 正确准备序列数据（滑动窗口）
  • 选择合适的RNN类型（LSTM优于简单RNN）
  • 注意梯度消失和过拟合问题
  • 使用早停法和正则化提高泛化能力

应用场景：

  • 金融时间序列预测
  • 工业设备故障预测
  • 自然语言处理
  • 语音识别和生成
  • 视频分析和预测
相关推荐
吃好睡好便好3 小时前
矩阵的转置运算
学习·线性代数·matlab·矩阵
是馒头阿4 小时前
95、仇恨与爱
深度学习·神经网络·脑机接口·神经同步采集与刺激平台·植入式脑机接口
rit84324997 小时前
基于POCS的超分辨率重建（Keren配准）MATLAB实现
人工智能·matlab·超分辨率重建
phoenix@Capricornus7 小时前
MNIST数据集上卷积神经网络微调（MATLAB例）
机器学习·matlab·cnn
2401_827499997 小时前
深度学习03(黑马)-神经网络基础
人工智能·深度学习·神经网络
zhangfeng11338 小时前
glibc = GNU C Library （GNU C 标准库）CentOS 7 (glibc 2.17) pip支持
c语言·人工智能·神经网络·机器学习·centos·gnu
吃好睡好便好9 小时前
矩阵的求逆运算
人工智能·学习·线性代数·matlab·矩阵
搞科研的小刘选手18 小时前
【中山大学主办】第六届计算机科学与区块链国际学术会议（CCSB 2026）
分布式·神经网络·计算机视觉·区块链·计算机科学·共识算法·自然语言
OpenApi.cc19 小时前
神经网络结构驱动+数据结构分析
数据结构·人工智能·神经网络
热门推荐
01GitHub 镜像站点02【AI】2026 年具身智能模型和世界模型总结03【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法042026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf05Codex 接入 DeepSeek API 完整配置文档06CC-Switch & Claude 基于 Linux 服务器安装使用指南07裂开！ChatGPT 居然开始要手机号验证，附详细解决方法08DeepSeek V4 + Claude Code thinking mode 400 错误修复方案09几个好用的ip纯净度检测网站10API Key 登录 Codex 也能用插件了，还支持会话删除和导出