section 3: shape error

[ghost]

class FashionMNISTModelV2(nn.Module):
    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):
        super().__init__()
        self.block_1 = nn.Sequential(
            nn.Conv2d(in_channels=input_shape,
                      out_channels=hidden_units,
                      kernel_size=3, # how big is the square that's going over the image?
                      stride=1, # default
                      padding=1),# options = "valid" (no padding) or "same" (output has same shape as input) or int for specific number
            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,
                         stride=2) # default stride value is same as kernel_size
        )
        self.block_2 = nn.Sequential(
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            # Where did this in_features shape come from?
            # It's because each layer of our network compresses and changes the shape of our inputs data.
            nn.Linear(in_features=hidden_units * 7 * 7,
                      out_features=output_shape)
        )

    def forward(self, x: torch.Tensor):
        x = self.block_1(x)
        print(x.shape)
        x = self.block_2(x)
        print(x.shape)
        x = self.classifier(x)
        print(x.shape)
        return x

torch.manual_seed(42)
model_2 = FashionMNISTModelV2(input_shape=1,
    hidden_units=10,
    output_shape=len(class_names)).to(device)

random_image_tensor = torch.randn(size=(1,28,28)).to(device)

model_2(random_image_tensor)

Output/Error message:
torch.Size([10, 14, 14])
torch.Size([10, 7, 7])
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
[<ipython-input-41-f02d93b5efb3>](https://localhost:8080/#) in <cell line: 2>()
      1 #durch model durch
----> 2 model_2(random_image_tensor)

5 frames
[/usr/local/lib/python3.10/dist-packages/torch/nn/modules/linear.py](https://localhost:8080/#) in forward(self, input)
    112 
    113     def forward(self, input: Tensor) -> Tensor:
--> 114         return F.linear(input, self.weight, self.bias)
    115 
    116     def extra_repr(self) -> str:

RuntimeError: mat1 and mat2 shapes cannot be multiplied (10x49 and 490x10)

I try to pass a random tensor through FashionMNISTModelV2 but it always comes up with the same error. In the viedeo it also appears but is fixed by "hidden_unitits * 7 * 7" which is not the case for me.

Thanks in advance

[tomasbrogueira]

I'm not totally sure as I am also going through the course and got this error but I believe it has to do with squeezing the tensor. When looking at the documentation (https://pytorch.org/docs/stable/generated/torch.nn.Flatten.html) you can see that nn.Flatten does not flatten the first dimension to 1 by default so if you have not created the extra 1 dimension with the unsqueeze you`ll end up with a tensor of 10x49 instead of 1x490.

In other words when passing the image through the model do model_2(rand_image_tensor.unsqueeze(0)) instead of
model_2(random_image_tensor)

I hope this helps and please correct me if I`m wrong.

[mrdbourke]

This is correct! The model is expected a batch dimension at dim 0 and unsqueeze(0) can help.

See the example code:

import torch
from torch import nn

class FashionMNISTModelV2(nn.Module):
    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):
        super().__init__()
        self.block_1 = nn.Sequential(
            nn.Conv2d(in_channels=input_shape,
                      out_channels=hidden_units,
                      kernel_size=3, # how big is the square that's going over the image?
                      stride=1, # default
                      padding=1),# options = "valid" (no padding) or "same" (output has same shape as input) or int for specific number
            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,
                         stride=2) # default stride value is same as kernel_size
        )
        self.block_2 = nn.Sequential(
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            # Where did this in_features shape come from?
            # It's because each layer of our network compresses and changes the shape of our inputs data.
            nn.Linear(in_features=hidden_units * 7 * 7,
                      out_features=output_shape)
        )

    def forward(self, x: torch.Tensor):
        x = self.block_1(x)
        print(x.shape)
        x = self.block_2(x)
        print(x.shape)
        x = self.classifier(x)
        print(x.shape)
        return x

device = "cpu"
class_names = ['T-shirt/top',
 'Trouser',
 'Pullover',
 'Dress',
 'Coat',
 'Sandal',
 'Shirt',
 'Sneaker',
 'Bag',
 'Ankle boot']

torch.manual_seed(42)
model_2 = FashionMNISTModelV2(input_shape=1,
    hidden_units=10,
    output_shape=len(class_names)).to(device)

random_image_tensor = torch.randn(size=(1, 28, 28)).to(device)
print(f"Random image tensor shape: {random_image_tensor.shape}")
print(f"Random image tensor shape with unsqueeze: {random_image_tensor.unsqueeze(0).shape}")

# Make prediction on random_image_tensor with added batch dimension
model_2(random_image_tensor.unsqueeze(0))

I've also created a short notebook here: https://colab.research.google.com/drive/1WBVpmE7xSNv9QE9gFK2EUU-vts73-gtt?usp=sharing

PS for more on shape errors and other common errors in PyTorch, see here: https://www.learnpytorch.io/pytorch_most_common_errors/