How the number of parameters is calculated if multihead self attention layer is used in a CNN model?

I have run the example in the following link in two cases:

https://www.mathworks.com/matlabcentral/answers/1932550-example-of-using-self-attention-layer-in-matlab-r2023a

Case 1: NumHeads = 4, NumKeyChannels = 784 Case 2: NumHeads = 8, NumKeyChannels = 392 Note that:

4x784 = 8x392 = 3136 (size of input feature vector to the attention layer). I have calculated the number of model parameters in the two cases and I got the following: 9.8 M for the first case, and 4.9 M for the second case.

I expected the number of learnable parameters to be the same. However, MATLAB reports different parameter counts.

My understanding from research papers is that the total parameters should not scale with how input is split across heads. The number of parameters should be the same as long as the input feature vector is the same, and the product of the number of heads by the size of each head (number of channels) is equal to the input size.

Why does MATLAB’s selfAttentionLayer produce different parameter counts for these two configurations? Am I misinterpreting how the layer is implemented in this toolbox?

[Umar]

Dear @Hana Ahmed,

Thank you for sharing your detailed analysis. Your theoretical understanding is absolutely correct, and my testing confirms your observations. After replicating your experiment, I obtained identical results:

% Create complete networks to avoid initialization error
layers1 = [
  featureInputLayer(3136, 'Name', 'input')
  selfAttentionLayer(4, 784, 'Name', 'selfattention')
];

layers2 = [
  featureInputLayer(3136, 'Name', 'input')
  selfAttentionLayer(8, 392, 'Name', 'selfattention')
];

net1 = dlnetwork(layers1);
net2 = dlnetwork(layers2);

% Check parameter structure
 fprintf('Case 1 parameters: %.1fM\n', sum(cellfun(@numel,   
 net1.Learnables.Value))/1e6);
 fprintf('Case 2 parameters: %.1fM\n', sum(cellfun(@numel,      
 net2.Learnables.Value))/1e6);

Results:

Analysis: * Case 1: 4 heads × 784 channels = 9.8M parameters * Case 2: 8 heads × 392 channels = 4.9M parameters * Ratio: Exactly 2:1

Root Cause Analysis: MATLAB's selfAttentionLayer implementation uses parameter scaling proportional to NumKeyChannels^2 rather than maintaining constant parameters when NumHeads × NumKeyChannels = constant. This deviates from standard transformer architecture where parameter count should remain identical for equivalent total dimensionality ( 3136 in both your cases).

So, you are not misinterpreting the research literature. Your understanding of multi-head attention theory is correct - parameters should remain constant regardless of head configuration when total feature dimensionality is preserved. MATLAB's Deep Learning Toolbox has implemented a non-standard version that prioritizes a different computational structure over parameter efficiency.

My recommendation would be if you require true multi-head attention behavior (constant parameters), consider implementing a custom layer following standard transformer equations, as MATLAB's current implementation doesn't align with conventional practice.

[Hana Ahmed]

I would be very grateful if you could suggest or provide a correct MATLAB implementation — ideally as a custom layer — that follows the standard multi-head attention equations.

[Umar]

Hi @Hana Ahmed,

Thanks for your follow-up! I think writing the multi-head attention mechanism from scratch would be a great way to get the transparency and control you're looking for. It will also help you understand the underlying principles better.

Here’s a quick skeleton of the pseudo code to guide your implementation:

Skeleton of Pseudo Code:

function Y = multiHeadAttention(X, numHeads, keyChannels)
  % X: Input matrix [batchSize, inputDim]
  % numHeads: Number of attention heads
  % keyChannels: Dimensionality per head

    [batchSize, inputDim] = size(X);
    d_k = keyChannels; % Dimension per head

    % Define weights for Q, K, V, and output projection
    W_Q = randn(inputDim, numHeads * d_k);
    W_K = randn(inputDim, numHeads * d_k);
    W_V = randn(inputDim, numHeads * d_k);
    W_O = randn(numHeads * d_k, inputDim);

    % Compute Q, K, V
    Q = X * W_Q;
    K = X * W_K;
    V = X * W_V;

    % Reshape for multiple heads
    Q = reshape(Q, batchSize, numHeads, d_k);
    K = reshape(K, batchSize, numHeads, d_k);
    V = reshape(V, batchSize, numHeads, d_k);

    % Compute attention for each head
    attentionOutput = zeros(batchSize, numHeads, d_k);
    for i = 1:numHeads
        % Compute scaled dot-product attention for each head
        attentionScores = Q(:, i, :) * K(:, i, :)' / sqrt(d_k);
        attentionWeights = softmax(attentionScores, 2);
        attentionOutput(:, i, :) = attentionWeights * V(:, i, :);
    end

    % Concatenate heads and project to output
    attentionOutput = reshape(attentionOutput, batchSize, numHeads * d_k);
    Y = attentionOutput * W_O;
  end

I suggest you try implementing this yourself in MATLAB, following the structure above. This will give you a hands-on understanding of how the attention mechanism works.

If you run into any issues or get stuck, feel free to reach out, and I’d be happy to help debug.

Good luck with the implementation!