Thanks for your reply! Here’s the code for DilatedCNN. This code works independently of SplitDilatedCNN, so there shouldn’t be any errors there. Could the nested ModuleList's be a problem?
class DilatedCNN(nn.Module):
    def __init__(self,channelsIn,channelsOut,channelsAux=0,depth=5,baseFilters=16,kernel=5):
        super(DilatedCNN, self).__init__()

        self.channelsIn = channelsIn+channelsAux
        self.channelsOut = channelsOut
        self.channelsAux = channelsAux

        self.baseFilters = baseFilters
        self.depth = depth
        self.kernel = kernel

        self.convolutions = nn.ModuleList()
        for i in range(self.depth):
            if i==0:
                self.convolutions.append(ConvSame(self.channelsIn,self.baseFilters,self.kernel,i+1,False))
            else:
                self.convolutions.append(ConvSame(int((2**(i-1))*self.baseFilters),int((2**i)*self.baseFilters),self.kernel,i+1,False))
        for i in reversed(range(self.depth)):
            if i==0:
                self.convolutions.append(ConvSame(self.baseFilters,self.channelsOut,self.kernel,i+1,False))
            else:
                self.convolutions.append(ConvSame(int((2**i)*self.baseFilters),int((2**(i-1))*self.baseFilters),self.kernel,i+1,False))

    def forward(self, x):
        for i, module in enumerate(self.convolutions):
            if i<len(self.convolutions)-1:
                x = module(x,True)
            else:
                x = module(x,False)
        return x

And since DilatedCNN references ConvSame:
class ConvSame(nn.Module):
    def __init__(self, in_channels, out_channels, kernel, dilation, grouped):
        super(ConvSame, self).__init__()

        self.in_channels = in_channels
        self.out_channels = out_channels
        self.multiplier = self.out_channels/self.in_channels
        if grouped: self.groups = self.in_channels if self.multiplier>1 else self.out_channels
        else:       self.groups = 1
        self.conv = nn.Conv2d(in_channels,out_channels,kernel_size=kernel,stride=1,padding=dilation*(kernel-1)//2,dilation=dilation,groups=self.groups)

    def forward(self, x, addRelu=True):
        if addRelu: return F.relu(self.conv(x))
        else:       return self.conv(x)