写一个双向GRU回归预测的matlab代码

以下是一个使用双向 GRU 进行回归预测的 MATLAB 代码，使用的是一个简单的时间序列数据集：

% 生成时间序列数据
n = 100; % 数据点数目
x = linspace(0, 10*pi, n)';
y = sin(x) + randn(n, 1)*0.1;

% 将数据集分为训练集和测试集
frac_train = 0.8; % 训练集占总数据的比例
n_train = round(n * frac_train);
x_train = x(1:n_train);
y_train = y(1:n_train);
x_test = x(n_train+1:end);
y_test = y(n_train+1:end);

% 定义模型参数
input_size = 1; % 输入特征维度
hidden_size = 16; % 隐藏状态维度
output_size = 1; % 输出维度
learning_rate = 0.01; % 学习率
num_epochs = 100; % 迭代次数

% 初始化模型参数
params.Wir = randn(hidden_size, input_size);
params.Whr = randn(hidden_size, hidden_size);
params.bir = zeros(hidden_size, 1);
params.bhr = zeros(hidden_size, 1);
params.Wiz = randn(hidden_size, input_size);
params.Whz = randn(hidden_size, hidden_size);
params.biz = zeros(hidden_size, 1);
params.bhz = zeros(hidden_size, 1);
params.Wi = randn(hidden_size, input_size);
params.Wh = randn(hidden_size, hidden_size);
params.bi = zeros(hidden_size, 1);
params.bh = zeros(hidden_size, 1);
params.Wo = randn(output_size, hidden_size*2);
params.bo = zeros(output_size, 1);

% 训练模型
for epoch = 1:num_epochs
    % 初始化梯度
    dWir = zeros(size(params.Wir));
    dWhr = zeros(size(params.Whr));
    dbir = zeros(size(params.bir));
    dbhr = zeros(size(params.bhr));
    dWiz = zeros(size(params.Wiz));
    dWhz = zeros(size(params.Whz));
    dbiz = zeros(size(params.biz));
    dbhz = zeros(size(params.bhz));
    dWi = zeros(size(params.Wi));
    dWh = zeros(size(params.Wh));
    dbi = zeros(size(params.bi));
    dbh = zeros(size(params.bh));
    dWo = zeros(size(params.Wo));
    dbo = zeros(size(params.bo));
    loss = 0;
    
    % 随机打乱训练集顺序
    idxs = randperm(n_train);
    x_train = x_train(idxs);
    y_train = y_train(idxs);
    
    % 遍历训练集
    for t = 2:n_train
        % 前向传播
        x_t = x_train(t);
        h_prev = zeros(hidden_size, 1);
        h_rev_prev = zeros(hidden_size, 1);
        for i = 1:t-1
            x_i = x_train(i);
            % 正向 GRU
            [h, z, r] = forward_gru(x_i, h_prev, params, 'f');
            % 反向 GRU
            [h_rev, z_rev, r_rev] = forward_gru(x_train(t-i), h_rev_prev, params, 'b');
            h_prev = h;
            h_rev_prev = h_rev;
        end
        % 拼接正向和反向 GRU 的输出
        h_concat = [h; h_rev];
        % 输出层
        y_pred = params.Wo * h_concat + params.bo;
        % 计算损失和梯度
        loss = loss + (y_pred - y_train(t))^2;
        dY = 2 * (y_pred - y_train(t));
        [dWo_t, dbo_t, dh_concat] = backward_output(dY, h_concat, params);
        [dH, dH_rev] = deal(zeros(hidden_size, 1));
        for i = t-1:-1:1
            x_i = x_train(i);
            % 正向 GRU
            [dH_t, dh_prev, dparams_t] = backward_gru(dh_concat, x_i, h_prev, z, r, params, 'f');
            % 反向 GRU
            [dH_rev_t, dh_rev_prev, dparams_rev_t] = backward_gru(dH_rev, x_train(t-i), h_rev_prev, z_rev, r_rev, params, 'b');
            dH = dH + dH_t;
            dH_rev = dH_rev + dH_rev_t;
            dh_prev = dh_prev + dH_t;
            dh_rev_prev = dh_rev_prev + dH_rev_t;
            % 累计梯度
            dWir = dparams_t.Wir + dparams_rev_t.Wir;
            dWhr = dparams_t.Whr + dparams_rev_t.Whr;
            dbir = dbir + dparams_t.bir + dparams_rev_t.bir;
            dbhr = dbhr + dparams_t.bhr + dparams_rev_t.bhr;
            dWiz = dparams_t.Wiz + dparams_rev_t.Wiz;
            dWhz = dparams_t.Whz + dparams_rev_t.Whz;
            dbiz = dbiz + dparams_t.biz + dparams_rev_t.biz;
            dbhz = dbhz + dparams_t.bhz + dparams_rev_t.bhz;
            dWi = dparams_t.Wi + dparams_rev_t.Wi;
            dWh = dparams_t.Wh + dparams_rev_t.Wh;
            dbi = dbi + dparams_t.bi + dparams_rev_t.bi;
            dbh = dbh + dparams_t.bh + dparams_rev_t.bh;
        end
        dH = dH + dh_prev;
        dH_rev = dH_rev + dh_rev_prev;
        % 反向传播更新参数
        params.Wir = params.Wir - learning_rate * dWir;
        params.Whr = params.Whr - learning_rate * dWhr;
        params.bir = params.bir - learning_rate * dbir;
        params.bhr = params.bhr - learning_rate * dbhr;
        params.Wiz = params.Wiz - learning_rate * dWiz;
        params.Whz = params.Whz - learning_rate * dWhz;
        params.biz = params.biz - learning_rate * dbiz;
        params.bhz = params.bhz - learning_rate * dbhz;
        params.Wi = params.Wi - learning_rate * dWi;
        params.Wh = params.Wh - learning_rate * dWh;
        params.bi = params.bi - learning_rate * dbi;
        params.bh = params.bh - learning_rate * dbh;
        params.Wo = params.Wo - learning_rate * dWo_t;
        params.bo = params.bo - learning_rate * dbo_t;
    end
    % 输出训练进度
    fprintf('Epoch %d, loss = %f\n', epoch, loss/n_train);
end

% 测试模型
y_pred = zeros(n - n_train, 1);
h_prev = zeros(hidden_size, 1);
h_rev_prev = zeros(hidden_size, 1);
for i = 1:n-n_train
    x_i = x_test(i);
    % 正向 GRU
    [h, z, r] = forward_gru(x_i, h_prev, params, 'f');
    % 反向 GRU
    [h_rev, z_rev, r_rev] = forward_gru(x_test(n-n_train-i), h_rev_prev, params, 'b');
    h_prev = h;
    h_rev_prev = h_rev;
    % 拼接正向和反向 GRU 的输出
    h_concat = [h; h_rev];
    % 输出层
    y_pred(i) = params.Wo * h_concat + params.bo;
end

% 绘制预测结果
figure;
plot(x, y, 'b', x_test, y_pred, 'r');
legend('Ground Truth', 'Predicted');
xlabel('x');
ylabel('y');

需要注意的是，这只是一个简单的实现，实际中可能需要进行更多的调试和优化。