124. Model 2: Using a Trick to Find the Input and Output Shapes if Each if Out Layers

[Josephthomas17]

In our FashionMNISTModelV2 model to automatically find the size of the in_features in final Linear layer in self.classifier we could model the Class like this:

class FashionMNISTModelV2(nn.Module):
    """
    Model architecture copying TinyVGG from: 
    https://poloclub.github.io/cnn-explainer/
    
    Added additional constructor parameters: image height and width --##
    """
    def __init__(self, input_shape: int, hidden_units: int, output_shape: int, image_height: int, image_width: 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)
        )

        # Dynamically compute flattened size 
        with torch.no_grad():
            dummy_input = torch.randn(1, input_shape, image_height, image_width)
            x = self.block_1(dummy_input)
            x = self.block_2(x)
            self.flattened_size = x.view(1, -1).shape[1]

        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 input data.
            nn.Linear(in_features=self.flattened_size, 
                      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

And construct the model instance like this:

model_2 = FashionMNISTModelV3(  
    input_shape=1,
    hidden_units=10,
    output_shape=len(class_names),
    image_height=28,
    image_width=28
).to(target_device)