Maybe you can use the ModuleDict for naming the layers. I have a simple example:
import torch.nn as nn

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model = nn.ModuleDict({
                'conv1': nn.Conv2d(1, 8, 3, padding=1),
                'conv2': nn.Conv2d(8, 16, 3, padding=1),
                'conv3': nn.Conv2d(16, 32, 3, padding=1),

                'pool1': nn.MaxPool2d(2),
                'pool2': nn.MaxPool2d(2),

                'activ1': nn.ReLU(),
                'activ2' : nn.ReLU(),

                'fc': nn.Linear(512, 100),
                'sigmoid': nn.Sigmoid(),
        })

    def forward(self, x):
        for name in ['conv1', 'pool1', 'activ1',
                     'conv2', 'pool2', 'activ2',
                     'conv3']:
            x = self.model[name](x)
        x = x.view(-1, 512)
        x = self.model['fc'](x)
        x = self.model['sigmoid'](x)
        return x

Now, you can create a model and print it to see the names of different layers:
>>> m = MyModule()
>>> print(m)

MyModule(
  (model): ModuleDict(
    (activ1): ReLU()
    (activ2): ReLU()
    (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fc): Linear(in_features=512, out_features=100, bias=True)
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (sigmoid): Sigmoid()
  )
)

Alternative Solution based on @Shisho_Sama’s suggestion:
Since the ModuleDict does not preserve the order of elements, we can add layers to an OrderedDictand then pass them to  Sequential:
from collections import OrderedDict

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model = nn.Sequential(OrderedDict([
                ('conv1', nn.Conv2d(1, 8, 3, padding=1)),
                ('pool1', nn.MaxPool2d(2)),
                ('activ1', nn.ReLU()),
                ('conv2', nn.Conv2d(8, 16, 3, padding=1)),
                ('pool2', nn.MaxPool2d(2)),
                ('conv3', nn.Conv2d(16, 32, 3, padding=1)),
                ('activ2', nn.ReLU())]))

        self.fc = nn.Linear(512, 100)

    def forward(self, x):
        x = self.model(x)
        x = x.reshape(-1, 512)
        return torch.sigmoid(x)

printing an instance:
>>> m = MyModule()
>>> print(m)

MyModule(
  (model): Sequential(
    (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (activ1): ReLU()
    (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (conv3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (activ2): ReLU()
  )
  (fc): Linear(in_features=512, out_features=100, bias=True)
)