Hey Johnson, by split connections do you mean skip connections? I tried to add skip connections and test them.
My output looks like for the below architecture:

class T_LEAP_SKIP(torch.nn.Module):
    """T_LEAP ARCHITECTURE"""

    def __init__(self):
        super(T_LEAP_SKIP, self).__init__()
        
        self.upconv1 = torch.nn.Sequential(torch.nn.Conv3d(3, 64, kernel_size=(3,3,3), 
                                                stride=(1,1,1), padding=(1,1,1)),
                                                torch.nn.BatchNorm3d(num_features=64),
                                                torch.nn.ReLU(inplace=True),
                                                )
        self.pool1   = torch.nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2))

        self.upconv2 = torch.nn.Sequential(torch.nn.Conv3d(64, 128,kernel_size=(3,3,3), 
                                                    stride=(1,1,1), padding=(1,1,1)), 
                                                                            
                                      torch.nn.BatchNorm3d(num_features=128),
                                      torch.nn.ReLU(inplace=True),
                                      
                                    )
        self.pool2   = torch.nn.MaxPool3d(kernel_size=(2,2,2),stride=(2,2,2))

        self.upconv3 = torch.nn.Sequential(torch.nn.Conv3d(128, 256,
                                                           kernel_size=(3,3,3), 
                                                           stride=(1,1,1), 
                                                           padding=(1,1,1)), 
                                                                            
                                      torch.nn.BatchNorm3d(num_features=256),
                                      torch.nn.ReLU(inplace=True),
                                      
                                    )
        
        self.pool3   = torch.nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2))

        self.upconv4 = torch.nn.Sequential(torch.nn.Conv3d(256, 
                                                           512,
                                                           kernel_size=(1,3,3), 
                                                           stride=(1,1,1),
                                                           padding=(1,1,1)), 
                                                                            
                                      torch.nn.BatchNorm3d(num_features=512),
                                      torch.nn.ReLU(inplace=True),
                               
                                    )
        #-----------------------------------------------------------------------
        #1st conv-transpose layer 
        self.convt1 = torch.nn.Sequential(torch.nn.ConvTranspose3d(512, 
                                                                   256, 
                                                                   kernel_size=(1,3,3),
                                                                   stride = (1,2,2), 
                                                                   padding=(1,1,1),
                                                                   output_padding=(0,1,1)),
                                          torch.nn.BatchNorm3d(num_features=256), 
                                          torch.nn.ReLU(inplace=True)
                                          )
        self.down1  = torch.nn.Sequential(torch.nn.Conv3d(512, 256, kernel_size=(1,3,3), stride=(1,1,1), padding=(1,1,1)),
                                          torch.nn.BatchNorm3d(num_features=256),
                                          torch.nn.ReLU(inplace=True))
        
        
        #2nd conv-transpose layer 
        self.convt2 = torch.nn.Sequential(torch.nn.ConvTranspose3d(256, 
                                                                   128, 
                                                                   kernel_size=(1,3,3),
                                                                   stride = (1,2,2), 
                                                                   padding=(1,1,1),
                                                                   output_padding=(0,1,1)),
                                          torch.nn.BatchNorm3d(num_features=128), 
                                          torch.nn.ReLU(inplace=True)
                                          )
        
        self.down2  = torch.nn.Sequential(torch.nn.Conv3d(256,128, kernel_size=(1,3,3), stride=(1,1,1), padding=(1,1,1)),
                                          torch.nn.BatchNorm3d(num_features=128),
                                          torch.nn.ReLU(inplace=True)) 

        #Final conv-transpose layer                                   
        self.convt3 = torch.nn.Sequential(torch.nn.ConvTranspose3d(128, 
                                                                   17, 
                                                                   kernel_size=(1,3,3),
                                                                   stride = (1,2,2), 
                                                                   padding=(1,1,1),
                                                                   output_padding=(0,1,1)),
                                          torch.nn.BatchNorm3d(num_features=17), 
                                          torch.nn.ReLU(inplace=True)
                                          )

    def forward(self, image):
        """PUTTING THE MODEL TOGETHER"""
        
        # Encoder 
        block1 = self.upconv1(image)
        pool1  = self.pool1(block1)

        block2 = self.upconv2(pool1)
        pool2  = self.pool2(block2)

        block3 = self.upconv3(pool2)
        pool3  = self.pool3(block3)
      
        block4 = self.upconv4(pool3)


        #Decoder
        trans1 = self.convt1(block4)
        skip1   = torch.cat([trans1, block3], axis=1)
        up1     = self.down1(skip1)

        trans2 = self.convt2(up1)
        skip2  = torch.cat([trans2, block2[:,:,1:,:]], axis=1)   #trouble with matching depth
        up2    = self.down2(skip2)

        trans3 = self.convt3(up2)
        output = torch.nn.Softmax(dim=1)(trans3)
        return output

model = T_LEAP_SKIP()
input = torch.rand(1,3, 2, 200, 200)
model = model
print("Model output", model(input).shape)

# summary(model,
#         input_size=(3, 2, 200, 200),
#         batch_size=1
#         )