I am trying to understand a code, I am confused about the test cells. When i am printing the shape of the output it is hidden$\_$output.shape $=($num$\_$test, $20,4,4),$ test$\_$hidden$\_$block$\_$stride$($hidden$\_$output$).$shape$)==($num$\_$test, $20,10,10)$ and Gen$\_$output.shape$=($num$\_$test, $1,28,28)$ for Mnist dataset. I am trying to understand how the sizes are being calculated here. Any help will be greatly appreciated! class Generator$($nn$.$Module$)$:

def $\_\_$init$\_\_($self$,$ z$\_$dim$=10,$ im$\_$chan$=1,$ hidden$\_$dim$=64)$:

super$($Generator$,$ self$).\_\_$init$\_\_()$

self.z$\_$dim $=$ z$\_$dim

# Build the neural network

self.gen $=$ nn$.$Sequential$($

self.make$\_$gen$\_$block$($z$\_$dim, hidden$\_$dim $*4),$

self.make$\_$gen$\_$block$($hidden$\_$dim $*4,$ hidden$\_$dim $*2,$ kernel$\_$size$=4,$ stride$=1),$

self.make$\_$gen$\_$block$($hidden$\_$dim $*2,$ hidden$\_$dim$),$

self.make$\_$gen$\_$block$($hidden$\_$dim, im$\_$chan, kernel$\_$size$=4,$ final$\_$layer$=$True$),$

$)$

def make$\_$gen$\_$block$($self$,$ input$\_$channels, output$\_$channels, kernel$\_$size$=3,$ stride$=2,$ padding$=0,$final$\_$layer$=$False$)$:

# Build the neural block

layers $=[]$

layers.append$($nn$.$ConvTranspose$2$d$($input$\_$channels, output$\_$channels, kernel$\_$size, stride, padding, output$\_$padding$=$padding$))$

if not final$\_$layer:

layers.append$($nn$.$BatchNorm$2$d$($output$\_$channels$))$

layers.append$($nn$.$ReLU$($True$))$

else:

layers.append$($nn$.$Tanh$())$

return nn$.$Sequential$(*$layers$)$

# Testing

gen $=$ Generator$()$

num$\_$test $=100$

# Test the hidden block

test$\_$hidden$\_$noise $=$ get$\_$noise$($num$\_$test, gen.z$\_$dim$)$

test$\_$hidden$\_$block $=$ gen.make$\_$gen$\_$block$(10,20,$ kernel$\_$size$=4,$ stride$=1)$

test$\_$uns$\_$noise $=$ gen.unsqueeze$\_$noise$($test$\_$hidden$\_$noise$)$

hidden$\_$output $=$ test$\_$hidden$\_$block$($test$\_$uns$\_$noise$)$

# Check that it works with other strides

test$\_$hidden$\_$block$\_$stride $=$ gen.make$\_$gen$\_$block$(20,20,$ kernel$\_$size$=4,$ stride$=2)$

test$\_$final$\_$noise $=$ get$\_$noise$($num$\_$test, gen.z$\_$dim$)*20$

test$\_$final$\_$block $=$ gen.make$\_$gen$\_$block$(10,20,$ final$\_$layer$=$True$)$

test$\_$final$\_$uns$\_$noise $=$ gen.unsqueeze$\_$noise$($test$\_$final$\_$noise$)$

final$\_$output $=$ test$\_$final$\_$block$($test$\_$final$\_$uns$\_$noise$)$

# Test the whole thing:

test$\_$gen$\_$noise $=$ get$\_$noise$($num$\_$test, gen.z$\_$dim$)$

test$\_$uns$\_$gen$\_$noise $=$ gen.unsqueeze$\_$noise$($test$\_$gen$\_$noise$)$

gen$\_$output $=$ gen$($test$\_$uns$\_$gen$\_$noise$)$