May I ask how to use MATLAB code to build an ECA module?

May I ask how to use MATLAB code to build an ECA module? The ECA module can refer to this paper: ECA Net: Efficient Channel Attention for Deep Convolutional Neural Networks.

Paper address: https://arxiv.org/abs/1910.03151

[shen hedong]

I found the following Python code about ECA: but I don't know how to implement "squeeze" and "transpose" in MATLAB.Please help me!

class ECA(nn.Module):
    """Constructs a ECA module.
    Args:
        channel: Number of channels of the input feature map
        k_size: Adaptive selection of kernel size
    """

    def __init__(self, c1,c2, k_size=3):
        super(ECA, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # feature descriptor on the global spatial information
        y = self.avg_pool(x)
        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
        # Multi-scale information fusion
        y = self.sigmoid(y)

        return x * y.expand_as(x)

Answer 1

[Ronit]

Hello Shen,

I understand you are trying to implement an ECA module using MATLAB. I can help you translate the provided Python code for the ECA module into MATLAB code. However, you can use the following functions in MATLAB:

1. Squeeze: The ‘squeeze’ function in MATLAB removes singleton dimensions.
2. Transpose: The ‘permute’ function in MATLAB can be used to transpose dimensions.

Here's how you can achieve the equivalent functionality:

classdef ECA < handle
    properties
        avg_pool
        conv
        sigmoid
    end
    
    methods
        function obj = ECA(c1, c2, k_size)
            if nargin < 3
                k_size = 3;
            end
            obj.avg_pool = @(x) mean(x, [1, 2]);
            obj.conv = convolution1dLayer(k_size, 1, 'Padding', floor((k_size - 1) / 2), 'BiasLearnRateFactor', 0);
            obj.sigmoid = @(x) 1 ./ (1 + exp(-x));
        end
        
        function y = forward(obj, x)
            % Global Average Pooling
            y = obj.avg_pool(x);
            y = squeeze(y); % Equivalent to squeeze(-1)
            y = permute(y, [3, 1, 2]); % Equivalent to transpose(-1, -2)
            
            % 1D Convolution
            y = obj.conv.predict(y);
            y = permute(y, [2, 3, 1]); % Equivalent to transpose(-1, -2)
            y = reshape(y, [1, 1, size(y, 1), size(y, 2)]);
            
            % Sigmoid Activation
            y = obj.sigmoid(y);
            % Element-wise multiplication and expansion
            y = repmat(y, size(x, 1), size(x, 2), 1, 1);
            y = x .* y;
        end
    end
end

Please refer to the following documentations for more information regarding implementation:

• Convolution1dLayer Function: https://www.mathworks.com/help/deeplearning/ref/nnet.cnn.layer.convolution1dlayer.html
• Sigmoid Function: https://www.mathworks.com/help/deeplearning/ref/dlarray.sigmoid.html

Hope it helps!

[shen hedong]

First of all, thank you very much for your answer. Because I need to integrate the ECA module into the deep model, I have rewritten the above code as follows:

classdef ECABlock < nnet.layer.Layer
    properties
        avg_pool
        conv
        sigmoid
    end
    
    methods
        function layer = ECABlock(name,k_size)

             % create an attention layerr
            layer.Name = ['eca_block_',name];
            layer.Description = "ECA Block";

            if nargin < 2
                k_size = 3;
            end
            layer.avg_pool = @(x) mean(x, [1, 2]);
            layer.conv = convolution1dLayer(k_size, 1, 'Padding', floor((k_size - 1) / 2), 'BiasLearnRateFactor', 0);
            layer.sigmoid = @(x) 1 ./ (1 + exp(-x));
        end
            
        function y = predict(layer, x)
            % Global Average Pooling
            y = layer.avg_pool(x);
            y = squeeze(y); % Equivalent to squeeze(-1)
            y = permute(y, [3, 1, 2]); % Equivalent to transpose(-1, -2)
            
            % 1D Convolution
            y = layer.conv.predict(y);
            y = permute(y, [2, 3, 1]); % Equivalent to transpose(-1, -2)
            y = reshape(y, [1, 1, size(y, 1), size(y, 2)]);
            
            % Sigmoid Activation
            y = layer.sigmoid(y);
            % Element-wise multiplication and expansion
            y = repmat(y, size(x, 1), size(x, 2), 1, 1);
            y = x .* y;
        end
    end
end

but encountered the following error:

Unrecognized class' nnet.cnn.layer. ' The method, property, or field 'predict' of Convolution1DLayer.

Error ECABlock/correct (line 30)

y=layer.conv.predict(y);

[Ronit]

Try to use 'forward' rather than 'predict':

y = layer.conv.forward(y);

[shen hedong]

I have also tried forward and reported the same error.

And the usage of squeeze in MATLAB is also different from that in Python