给我CBAM注意力机制的matlab代码

下面是CBAM注意力机制的Matlab代码：

function [out, A] = cbam_attention(x, channels, reduction_ratio, pool_kernel_size)
    % x: input feature map (H x W x C)
    % channels: number of output channels
    % reduction_ratio: reduction ratio of fully connected layers
    % pool_kernel_size: kernel size for max pooling layers

    % channel-wise average pooling
    avg_pool = squeeze(mean(mean(x, 1), 2)); % (C x 1)

    % fully connected layers for channel-wise attention
    fc1 = fc_layer(avg_pool, channels / reduction_ratio, 'relu'); % (C / r x 1)
    fc2 = fc_layer(fc1, channels, 'sigmoid'); % (C x 1)

    % reshape to (1 x 1 x C)
    channel_attention = reshape(fc2, [1, 1, channels]);

    % spatial-wise attention
    max_pool = max_pool_layer(x, pool_kernel_size); % (H x W x C)
    avg_pool = avg_pool_layer(x, pool_kernel_size); % (H x W x C)
    concat = cat(3, max_pool, avg_pool); % (H x W x 2C)

    conv1 = conv_layer(concat, channels / reduction_ratio, [1, 1], 'relu'); % (H x W x C / r)
    conv2 = conv_layer(conv1, channels, [1, 1], 'sigmoid'); % (H x W x C)

    % element-wise multiplication
    spatial_attention = conv2; % (H x W x C)
    out = x .* (channel_attention .* spatial_attention); % (H x W x C)

    % attention map visualization
    A = channel_attention .* spatial_attention; % (H x W x C)
end

function y = fc_layer(x, out_dim, activation)
    % fully connected layer
    % x: input tensor (in_dim x batch_size)
    % out_dim: output dimension
    % activation: activation function ('relu' or 'sigmoid')

    [in_dim, batch_size] = size(x);

    W = normrnd(0, 0.01, [out_dim, in_dim]);
    b = zeros(out_dim, 1);

    y = W * x + b;
    if strcmp(activation, 'relu')
        y = relu(y);
    elseif strcmp(activation, 'sigmoid')
        y = sigmoid(y);
    end
end

function y = conv_layer(x, out_channels, kernel_size, activation)
    % convolutional layer
    % x: input tensor (H x W x in_channels)
    % out_channels: number of output channels
    % kernel_size: kernel size (height x width)
    % activation: activation function ('relu' or 'sigmoid')

    [H, W, in_channels] = size(x);

    W = normrnd(0, 0.01, [kernel_size, kernel_size, in_channels, out_channels]);
    b = zeros(out_channels, 1);

    y = convn(x, W, 'valid');
    y = y + b';

    if strcmp(activation, 'relu')
        y = relu(y);
    elseif strcmp(activation, 'sigmoid')
        y = sigmoid(y);
    end
end

function y = max_pool_layer(x, kernel_size)
    % max pooling layer
    % x: input tensor (H x W x C)
    % kernel_size: kernel size (height x width)

    y = nlfilter(x, [kernel_size, kernel_size], @(x)max(x(:)));
end

function y = avg_pool_layer(x, kernel_size)
    % average pooling layer
    % x: input tensor (H x W x C)
    % kernel_size: kernel size (height x width)

    y = nlfilter(x, [kernel_size, kernel_size], @(x)mean(x(:)));
end

function y = relu(x)
    % ReLU activation function

    y = max(x, 0);
end

function y = sigmoid(x)
    % sigmoid activation function

    y = 1 ./ (1 + exp(-x));
end