Error using trainNetwork (line 184) Invalid network. Caused by: Layer 4: The size of the pooling dimension of the padded input data must be larger than or equal to the pool si

Hi everyone,

I want to study the performance of a given network varying the size and number of filters in convolution1dLayer and the number of windows provided as input to the trainNetwork function itself.

As you can see from the picture, I already defined (in a way that is suitable for Matlab) x_train and y_train, respectively the input and the output to my network. It should indeed receive a sequence of data from 3 sensors (in the Workspace, variable defined by n_window) and 5783 time points (in the variable length). Also, if I wish to, I could give to the network an input sequence (x_train) as a 1x1 cell (as it already is in the picture) with even greater number of windows (repeated sequences of 3*5723 matrices in x_train). This obviously implies to change the y_train as well, and the code does it well enough. For completeness, I sat the following options: solver to 'adam', maxEpochs equal to 100, SequencePaddingDirection to left and Verbose to 0.

Nevertheless, I was about to run the algorithm (just once, and that explains the break in the inner loop), to check whether it was about to work or not, but I get the following error. I don't know what is wrong, because the inputSize, parameter of the sequenceInputLayer layer, is [3 5723]. Therefore, since I sat the pooling to 2 and a stride of 2, there should be no errors, at least theoretically. I also tried to change the stride to 1, but no change in the error occurred. What am I doing wrong? Thanks in advance for your help! :)

Also, I just tried to add a MinLength parameter in sequenceInputLayer, as suggested by the error message: setting it to either 1, n_features (equal to 3) or length (equal to 5723) doesn't change the final result.

Answer 1

[Ben]

The issue is that the 2nd layer convolution1dLayer(3,10) has no padding. Currently its input size is [3, 5723, ?] where 3 is n_features, 5723 is length and ? represents the sequence dimension that is variable.

For a sequenceInputLayer where the input size is a two dimensional vector like [n_features, length] we interpret the first dimension as space and the 2nd dimension as features/channels.

The convolution1dLayer(3,10) operates on just the space dimension here and it will "squash" that size to [1, 10, ?] which is too small for pooling window of size 2.

You can see this by calling analyzeNetwork(layers) and checking the Activations column.

You can set the "Padding" to make things run - for example convolution1dLayer(3,10,"Padding","same") - however I think you probably want to adjust some things as the 5723 appears to be sequence length, which you shouldn't need to specify in sequenceInputLayer's input size - you might use it in the "MinLength" name-value pair though.

[SALVATORE RUSSO]

Thank you, Ben!

I don't understand where I should set the MinLength that you mentioned in the last part of your message. Could you please be more clear on that?

However, I also thought things aren't working yet because of the input. That's why I just tried to fix the issue by setting the inputSize to n_features (that is the number of channels, 3). Nevertheless, now the same error output is on layer 2 (the convolution1dLayer). Any advice on how to fix it?

[Ben]

The "MinLength" is a name-value pair of sequenceInputLayer - currently we mostly use it to validate that things like convolution and pooling are well defined on the sequence length, e.g. if your sequences have "MinLength" equal to 3, then you can do a convolution with filter size 3 without padding along that sequence.

Your example might look like the following:

% fake sequence data

inputSize = 3;

x = {randn(inputSize,10),randn(inputSize,11),randn(inputSize,12)};

sequenceLengths = cellfun(@(sequence) size(sequence,2),x);

minLength = min(sequenceLengths);

layers = [sequenceInputLayer(3,MinLength=minLength)

convolution1dLayer(3,10)

reluLayer

maxPooling1dLayer(2,"Stride",2)

convolution1dLayer(3,10)

reluLayer

maxPooling1dLayer(2,"Stride",2)

globalMaxPooling1dLayer

fullyConnectedLayer(1)

reluLayer

regressionLayer];

analyzeNetwork(layers)

Note that for the layers in your picture I think you need a sequence length of at least 10.

Also note that you have to add the globalMaxPooling1dLayer to squeeze out the time dimension completely - e.g. see this example https://www.mathworks.com/help/deeplearning/ug/sequence-classification-using-1-d-convolutions.html

[SALVATORE RUSSO]

It works, thank you so much!!

I have only one curiosity: as you can see from the picture I sent here, I'm varying the size and number of filters by means of for loops. I'd like to vary them in such a way that i=3:2:11 (counter for the size of each filter) and j=10:5:50 (counter for number of filters). Will it have a sense in the subsequent steps to have a filter of size (for instance) 5, when my input stays constant as a cell made of 3*5723 matrices? Maybe it does, if the filter moves along the single row of this matrix, right?

Again thank you for your precious help!

[Ben]

No problem.

Sure, I think it should work if all your sequences are at least 5723 steps, so long as you set that as the MinLength on the sequenceInputLayer.

You could also work out what the smallest MinLength that is allowed for the network by analysing the convolution filter sizes, the pooling window sizes, and the pooling strides. For the case this works as follows:

• Suppose your input has sequence length T
• The first convolution has filter size 3 with no padding, that reduces sequence length to .
• The first pooling layer has stride 2 and no padding, that will reduce sequence length by half to
• The second convolution also has filter size 3 and no padding, so again sequence length drops by 2 to give
• Finally the 2nd pooling layer has window size 2, so it requires the current sequence length to be at least 2, giving the inequality
• Rearranging gives which is the smallest valid sequence length, i.e. MinLength should be 10.

You can do the above with any filter sizes - but of course it gets a little complex, so usually it's easier to just use the minimum sequence length of your training data and if that's too small you'll have to modify the network anyway.

[Kwasi]

Dear Ben,

From the date I see that it has been over a year since you provided this valuable information. If ever my message reaches you, kindly provide the references to these calculations or information since it will help me to clear some bottlenecks in my network. Thank you.

[Ben]

Hi Kwasi,

Do you mean the computations in my last comment to find the minimum sequence length?

Unfortuantely I don't have a specific reference. The computations follow from the definition of the convolution and pooling operations with padding and strides.

There are some diagrams for 2d convolution on our documentation page, the general idea for padding and stride is the same in 1d and for pooling.

I can try explain the logic behind my argument above:

• I used T as just an arbitrary sequence length variable for computations. Lets call the sequence
• A convolution with filter size 3 and no padding reduces T to because without padding you can't compute convolutions at the end points of the sequence and . You could write this as where for some size 3 convolution kernel - you can see this general formula can't make sense for and because and aren't defined (without padding). This logic extends to arbitrary convolution sizes k to give .
• Strides of k roughly divide the size of the input by k. Technically it's a little more complex. Given an input of length τ, a pool with stride k is computed starting at , or for up to some maximum N. If th pool has size p then to compute the pool at requires we have values of the sequence up to - i.e. . The is because the pool includes the current element it's starting at, and the proceding elements. Rearranging the above gives . So for the explicit example of a pool of size with stride on a sequence (outputted from the first convolution) of length you get . Since N has to be an integer you technically want as to get the sequence length of the output of the strided pool.
• The argument for the 2nd convolution is the same as the first, so the sequence length drops to .
• The final argument is that a pool of size p requires the input sequence to have at least length p, so with you get .

Hope that helps.

[Kwasi]

Hi Ben,

This has helped a lot, thanks.