tash:

I thought I had to use nn.Sequential() to add the previous model with the new layers to create a new network.


You can use nn.Sequential to easily create new models, which use the layers in a sequential way.
Wrapping child modules from other models into an nn.Sequential container might work, but can also easily break, since e.g. all functional calls from the original forward would be missing and the order of the modules returned by model.children() defines the new nn.Sequential model.
Here is a small code example to show the shortcomings of this approach:
# default setup
class MyModelA(nn.Module):
    def __init__(self):
        super(MyModelA, self).__init__()
        self.conv = nn.Conv2d(3, 6, 3, 1, 1)
        self.fc = nn.Linear(6*24*24, 10)
        
    def forward(self, x):
        x = self.conv(x)
        x = F.relu(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

model = MyModelA()
x = torch.randn(2, 3, 24, 24)
out = model(x)

modelA_seq = nn.Sequential(*list(model.children()))
out_seq = modelA_seq(x) # F.relu and view is missing

# define all operations as modules
class MyModelB(nn.Module):
    def __init__(self):
        super(MyModelB, self).__init__()
        self.conv = nn.Conv2d(3, 6, 3, 1, 1)
        self.relu = nn.ReLU()
        self.flatten = nn.Flatten()
        self.fc = nn.Linear(6*24*24, 10)
        
    def forward(self, x):
        x = self.conv(x)
        x = self.relu(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

model = MyModelB()
x = torch.randn(2, 3, 24, 24)
out = model(x)

modelB_seq = nn.Sequential(*list(model.children()))
out_seq = modelB_seq(x) # works
print(torch.allclose(out, out_seq))

# change order
class MyModelC(nn.Module):
    def __init__(self):
        super(MyModelC, self).__init__()
        self.fc = nn.Linear(6*24*24, 10)
        self.flatten = nn.Flatten()
        self.relu = nn.ReLU()
        self.conv = nn.Conv2d(3, 6, 3, 1, 1)        
        
    def forward(self, x):
        x = self.conv(x)
        x = self.relu(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

model = MyModelC()
x = torch.randn(2, 3, 24, 24)
out = model(x)

modelC_seq = nn.Sequential(*list(model.children()))
print(modelC_seq) # wrong order!
out_seq = modelC_seq(x) # doesn't work, since model.children() returns the wrong order

I would thus create a new custom model, pass the pretrained one into it, add the new layers, and call them appropriately in the forward. Alternatively you can derive from the pretrained model as the base class and override the forward method.