JCR一区级 | Matlab实现PSO-Transformer-LSTM多变量回归预测

% LoadPrediction.m

% 加载负荷数据
load(‘load_data.mat’); % 假设负荷数据保存在 load_data.mat 文件中

% 数据预处理
load_data = normalize(load_data); % 归一化负荷数据

% 设置循环神经网络参数
inputSize = 1; % 输入维度（单变量负荷数据）
outputSize = 1; % 输出维度（负荷预测值）
hiddenSize = 10; % 隐层神经元数量
sequenceLength = 24; % 序列长度（每个输入序列包含的时间步数）
numEpochs = 100; % 迭代次数
learningRate = 0.01; % 学习率

% 初始化循环神经网络权重和偏置
Wxh = randn(hiddenSize, inputSize) * 0.01; % 输入到隐层的权重矩阵
Whh = randn(hiddenSize, hiddenSize) * 0.01; % 隐层到隐层的权重矩阵
Why = randn(outputSize, hiddenSize) * 0.01; % 隐层到输出的权重矩阵
bh = zeros(hiddenSize, 1); % 隐层的偏置向量
by = zeros(outputSize, 1); % 输出层的偏置向量

% 定义IWOA算法参数
populationSize = 20; % 种群数量
maxIterations = 100; % 最大迭代次数

% 初始化IWOA算法
positions = rand(populationSize, numel([Wxh(😃; Whh(😃; Why(😃; bh(😃; by(😃])); % 随机初始化种群位置
velocities = zeros(populationSize, numel([Wxh(😃; Whh(😃; Why(😃; bh(😃; by(😃])); % 初始化种群速度
pbestPositions = positions; % 个体最佳位置
gbestPosition = zeros(1, numel([Wxh(😃; Whh(😃; Why(😃; bh(😃; by(😃])); % 全局最佳位置
pbestFitness = inf(1, populationSize); % 个体最佳适应度
gbestFitness = inf; % 全局最佳适应度

for iteration = 1:maxIterations
% 更新种群位置和速度
c1 = 2; % 加速度系数
c2 = 2; % 加速度系数
w = 0.9 - iteration * ((0.9 - 0.4) / maxIterations); % 惯性权重更新
velocities = w * velocities + c1 * rand(populationSize, numel([Wxh(😃; Whh(😃; Why(😃; bh(😃; by(😃])) .* (pbestPositions - positions) + c2 * rand(populationSize, numel([Wxh(😃; Whh(😃; Why(😃; bh(😃; by(😃])) .* (repmat(gbestPosition, populationSize, 1) - positions);
positions = positions + velocities;

% 限制位置范围
positions(positions < 0) = 0;
positions(positions > 1) = 1;

% 计算适应度
fitness = zeros(1, populationSize);
for i = 1:populationSize
    % 从位置中提取权重和偏置
    Wxh = reshape(positions(i, 1:hiddenSize*inputSize), hiddenSize, inputSize);
    Whh = reshape(positions(i, hiddenSize*inputSize+1:hiddenSize*(inputSize+hiddenSize)), hiddenSize, hiddenSize);
    Why = reshape(positions(i, hiddenSize*(inputSize+hiddenSize)+1:hiddenSize*(inputSize+hiddenSize)+outputSize*hiddenSize), outputSize, hiddenSize);
    bh = reshape(positions(i, hiddenSize*(inputSize+hiddenSize)+outputSize*hiddenSize+1:hiddenSize*(inputSize+hiddenSize)+(outputSize+1)*hiddenSize), hiddenSize, 1);
    by = reshape(positions对不起，由于回答的代码较长，超出了单个响应的字符限制。以下是代码的续部：

(i, hiddenSize*(inputSize+hiddenSize)+(outputSize+1)*hiddenSize+1:end), outputSize, 1);
        
        % 训练循环神经网络
        [Wxh, Whh, Why, bh, by] = trainRNN(load_data, Wxh, Whh, Why, bh, by, sequenceLength, numEpochs, learningRate);
        
        % 计算适应度（均方误差）
        predicted_values = predictRNN(load_data, Wxh, Whh, Why, bh, by, sequenceLength);
        fitness(i) = mean((predicted_values - load_data(sequenceLength+1:end)).^2);
        
        % 更新个体最佳位置和全局最佳位置
        if fitness(i) < pbestFitness(i)
            pbestFitness(i) = fitness(i);
            pbestPositions(i, :) = positions(i, :);
        end
        
        if fitness(i) < gbestFitness
            gbestFitness = fitness(i);
            gbestPosition = positions(i, :);
        end
    end
    
    % 显示当前迭代结果
    disp(['Iteration: ' num2str(iteration) ', Best Fitness: ' num2str(gbestFitness)]);
end

% 从最佳位置提取权重和偏置
Wxh = reshape(gbestPosition(1:hiddenSize*inputSize), hiddenSize, inputSize);
Whh = reshape(gbestPosition(hiddenSize*inputSize+1:hiddenSize*(inputSize+hiddenSize)), hiddenSize, hiddenSize);
Why = reshape(gbestPosition(hiddenSize*(inputSize+hiddenSize)+1:hiddenSize*(inputSize+hiddenSize)+outputSize*hiddenSize), outputSize, hiddenSize);
bh = reshape(gbestPosition(hiddenSize*(inputSize+hiddenSize)+outputSize*hiddenSize+1:hiddenSize*(inputSize+hiddenSize)+(outputSize+1)*hiddenSize), hiddenSize, 1);
by = reshape(gbestPosition(hiddenSize*(inputSize+hiddenSize)+(outputSize+1)*hiddenSize+1:end), outputSize, 1);

% 进行最终预测
predicted_values = predictRNN(load_data, Wxh, Whh, Why, bh, by, sequenceLength);

% 显示预测结果
plot(load_data(sequenceLength+1:end), 'b', 'LineWidth', 2);
hold on;
plot(predicted_values, 'r--', 'LineWidth', 2);
legend('Actual', 'Predicted');
xlabel('Time');
ylabel('Load');
title('Load Prediction');
hold off;

% 循环神经网络训练函数
function [Wxh, Whh, Why, bh, by] = trainRNN(data, Wxh, Whh, Why, bh, by, sequenceLength, numEpochs, learningRate)
    inputSize = size(Wxh, 2);
    hiddenSize = size(Wxh, 1);
    outputSize = size(Why, 1);
    
    for epoch = 1:numEpochs
        % 初始化隐藏状态
        hprev = zeros(hiddenSize, 1);
        
        % 对每个序列进行训练
        for t = 1:sequenceLength:length(data)-sequenceLength-1
            % 准备输入和目标数据
            inputs = data(t:t+sequenceLength-1);
            targets = data(t+sequenceLength);
            
            % 前向传播
            xs = zeros(inputSize, sequenceLength);
            hs = zeros(hiddenSize, sequenceLength);
            ys = zeros(outputSize, sequenceLength);
            hs(:, 1) = hprev;
            
            for i = 1:sequenceLength
                xs(:, i) = inputs(i);
                hs(:, i+1) = tanh(Wxh * xs(:, i) + Whh * hs(:, i) + bh);
                ys(:, i) = Why * hs(:, i+1) + by;
            end
            
            % 计算损失和梯度
            loss = 0.5 * sum((ys(:, end) - targets).^2);
            dy = ys(:, end) - targets;
            
            dWxh = zeros(size(Wxh));
            dWhh = zeros(size(Whh));
            dWhy = zeros(size(Why));
            dbh = zeros(size(bh));
            dby = zeros(size(by));
            dhnext = zeros(size(hprev));
            
            for i = sequenceLength:-1:1
                % 反