Hello community.
I am working on a convolutional network based on “blocks” of convolutional and maxpooling.
This is the main class of the network
class Backbone(nn.Module):
    def __init__(self):
        super().__init__()

        self.block1_0 = nn.Sequential(
            Conv2dSamePadding(in_channels=3, out_channels=12, kernel_size=(3, 3), stride=(2, 2)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same'),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2)
        )

        self.block2_1 = nn.Sequential(
            Conv2dSamePadding(in_channels=3, out_channels=12, kernel_size=(3, 3), stride=(2, 2)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same'),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2)
        )

        self.block1_1 = basicBlock()
        self.block1_2 = basicBlock()
        self.block1_3 = basicBlock()
        self.block1_4 = basicBlock()
        self.avgpool1 = nn.AvgPool2d(kernel_size=2, stride=1)

        self.block2_1 = basicBlock()
        self.block2_2 = basicBlock()
        self.block2_3 = basicBlock()
        self.block2_4 = basicBlock()
        self.avgpool2 = nn.AvgPool2d(kernel_size=2, stride=1)

        self.conv = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), stride=1, padding='same')

IMPORTANT: you could see that the network is building with basically “basicBlock”
class basicBlock(nn.Module):
    def __init__(self):
        super().__init__()

        self.conv1 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv3 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv4 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv5 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')

        self.conv6 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv7 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv8 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv9 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')
        self.conv10 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')

        self.maxpool = nn.MaxPool2d(2, 1)
        self.conv11 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=(3, 3), padding='same')

So:
1.class basicBlock has self.conv1, self.conv2 and so on …
2. class Backbone has self.block1_1 = basicBlock(), self.block1_2 = basicBlock() and son on…
Theoretically, would be able the network to learn in a training?
Is this coding style correct?
Am I overwritting the convs each time that I build a BasicBlock?