Multiplying the hidden features by 49

[dehlong]

Around 18:25 Daniel multiplies hidden_features77. But why? Shouldn't nn.Flatten() take care of that? Otherwise I get RuntimeError: mat1 and mat2 shapes cannot be multiplied (1x490 and 10x10). But why? I have never set my image to be 10x10? Where does that 10x10 even come from? Where does that 1x490 come from? Why are we even doing that? Can anyone, please, explain me what is happening behind the scenes of this step? To me it does nor make a lot of sense. I am asking about moving from 2nd conv layer to classifier step.

Here is the code

class FashionMNISTModelV2(nn.Module):
    """
    Model architecture that replicates the TinyVGG architecture from the CNN explainer website.
    """
    def __init__(self, input_shape:int, hidden_units:int, output_shape:int):
        super().__init__()
        self.conv_block = nn.Sequential(
            nn.Conv2d(in_channels=input_shape,  # input shape is the number of color channels
                      out_channels=hidden_units,
                      kernel_size=3,
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=hidden_units,
                      out_channels=hidden_units,
                      kernel_size=3,
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.conv_block_2 = nn.Sequential(
            nn.Conv2d(in_channels=hidden_units,
                      out_channels = hidden_units,
                      kernel_size=3,
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=hidden_units,
                      out_channels=hidden_units,
                      kernel_size=3,
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(in_features=hidden_units*7*7, # But why???
                      out_features=output_shape)    
        )
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.conv_block(x)
        print(f"Output shape of conv_block: {x.shape}")
        x = self.conv_block_2(x)
        print(f"Output shape of conv_block_2: {x.shape}")
        x = self.classifier(x)
        print(f"Output shape of classifier: {x.shape}")
        return x
    

Thank you.

[dehlong]

Also, daniel talks that from pytorch 1.11+ it is not required to do the unsqueeze. However, I have found that when I remove the extra dimension (by not running unsqueeze), the image gets flattened to 10x49. Then I have to multiply 10x49 and 10x10 - this does not seem possible because multiplying the input_features by 4.9 errors out...

[LuluW8071]

@dehlong The flatten converts a 2D spatial image into a 1D vector of pixels (flattening the image). Unsqueeze adds the dimension.
Regarding your confusion about "multiplying the hidden features by 49":

1. The image you fed into the dataloader is likely to be 28x28 in size.
2. When you pass a 28x28 2D image through the first pooling layer (maxpool) after convolution, the output size of that image becomes 14x14 by the following formula:

$$ \text{Output size} = \left\lfloor \frac{\text{Input size} - \text{Kernel size} + 2 \times \text{Padding}}{\text{Stride}} \right\rfloor + 1 $$

Where,

• Input size = 28
• Kernel size = 2
• Padding = 0 (default)
• Stride = 2

3. Similarly, after passing it through the second pooling layer, the output size of the image becomes 7x7.
4. Then, when you flatten the layer, it becomes 1D. Since there are hidden layers, we multiply it by the previous output size of the pooling layer, which is 7x7.