//  [python]
def forward_no_logits(self, voxel_features, coors, batch_size, PROCESS_BLOCK_3=False, PROCESS_BLOCK_4=False):
        # x = x.contiguous()
        coors = coors.int()
        # import pdb
        # pdb.set_trace()
        ret = spconv.SparseConvTensor(voxel_features, coors, self.sparse_shape,
                                      batch_size)
        ret = self.downCntx(ret)
        down1c, down1b = self.resBlock2(ret)
        down2c, down2b = self.resBlock3(down1c)
        down3c, down3b = self.resBlock4(down2c)


        # Perform Singular Value Decomposition on the output of Block 4
        PROCESS_BLOCK_3 = PROCESS_BLOCK_3
        PROCESS_BLOCK_4 = PROCESS_BLOCK_4

        if PROCESS_BLOCK_3 and PROCESS_BLOCK_4:

            # Remove from the outputs of Block 3
            feat1 = copy.deepcopy(down3b.features.permute(1, 0))
            u, s, v = torch.linalg.svd(feat1, full_matrices=False)
            u = u.unsqueeze(0)
            s = s.unsqueeze(0)
            v = v.unsqueeze(0)
            feat1 = feat1 - s[:, 0:1].unsqueeze(2) * u[:, :, 0:1].bmm(v[:, 0:1, :])
            feat1 = feat1.squeeze(0)
            feat1 = feat1.permute(1, 0)

            down3b_early_removal = copy.deepcopy(down3b).replace_feature(feat1)
            down3c_early_removal = self.resBlock4.pool(down3b_early_removal)
            down4c_early_removal, down4b_early_removal = self.resBlock5(down3c_early_removal)


            up4e_early_removal = self.upBlock0(down4c_early_removal, down4b_early_removal)
            up3e_early_removal = self.upBlock1(up4e_early_removal, down3b_early_removal)
            up2e_early_removal = self.upBlock2(up3e_early_removal, down2b)
            up1e_early_removal = self.upBlock3(up2e_early_removal, down1b)
            up0e_early_removal = self.ReconNet(up1e_early_removal)
            up0e_early_removal = up0e_early_removal.replace_feature(torch.cat((up0e_early_removal.features, up1e_early_removal.features), 1))

            ############################################################
            # Remove from the outputs of Block 4

            down4c, down4b = self.resBlock5(down3c)
            feat2 = copy.deepcopy(down4b.features.permute(1, 0))
            u, s, v = torch.linalg.svd(feat2, full_matrices=False)
            u = u.unsqueeze(0)
            s = s.unsqueeze(0)
            v = v.unsqueeze(0)
            feat2 = feat2 - s[:, 0:1].unsqueeze(2) * u[:, :, 0:1].bmm(v[:, 0:1, :])
            feat2 = feat2.squeeze(0)
            feat2 = feat2.permute(1, 0)

            down4b_late_removal = copy.deepcopy(down4b).replace_feature(feat2)
            down4c_late_removal = self.resBlock5.pool(down4b_late_removal)

            up4e_late_removal = self.upBlock0(down4c_late_removal, down4b_late_removal)
            up3e_late_removal = self.upBlock1(up4e_late_removal, down3b)
            up2e_late_removal = self.upBlock2(up3e_late_removal, down2b)
            up1e_late_removal = self.upBlock3(up2e_late_removal, down1b)
            up0e_late_removal = self.ReconNet(up1e_late_removal)
            up0e_late_removal = up0e_late_removal.replace_feature(torch.cat((up0e_late_removal.features, up1e_late_removal.features), 1))

            return [up0e_early_removal, up0e_late_removal]

        elif PROCESS_BLOCK_3:

            raise NotImplementedError('Not implemented yet.')

            feat1 = copy.deepcopy(down3c.features.permute(1, 0))
            u, s, v = torch.linalg.svd(feat1, full_matrices=False)
            u = u.unsqueeze(0)
            s = s.unsqueeze(0)
            v = v.unsqueeze(0)
            feat1 = feat1 - s[:, 0:1].unsqueeze(2) * u[:, :, 0:1].bmm(v[:, 0:1, :])
            feat1 = feat1.squeeze(0)
            feat1 = feat1.permute(1, 0)

            processed_down3c = copy.deepcopy(down3c).replace_feature(feat1)

            up4e = self.upBlock0(processed_down3c, down3b)
            up3e = self.upBlock1(up4e, down3b)
            up2e = self.upBlock2(up3e, down2b)
            up1e = self.upBlock3(up2e, down1b)
            up0e = self.ReconNet(up1e)
            up0e_from_block_3 = up0e.replace_feature(torch.cat((up0e.features, up1e.features), 1))

            return up0e_from_block_3

        elif PROCESS_BLOCK_4:

            raise NotImplementedError('Not implemented yet.')

            down4c, down4b = self.resBlock5(down3c)
            feat2 = copy.deepcopy(down4c.features.permute(1, 0))
            u, s, v = torch.linalg.svd(feat2, full_matrices=False)
            u = u.unsqueeze(0)
            s = s.unsqueeze(0)
            v = v.unsqueeze(0)
            feat2 = feat2 - s[:, 0:1].unsqueeze(2) * u[:, :, 0:1].bmm(v[:, 0:1, :])
            feat2 = feat2.squeeze(0)
            feat2 = feat2.permute(1, 0)

            processed_down4c = copy.deepcopy(down4c).replace_feature(feat2)

            up4e = self.upBlock0(processed_down4c, down4b)
            up3e = self.upBlock1(up4e, down3b)
            up2e = self.upBlock2(up3e, down2b)
            up1e = self.upBlock3(up2e, down1b)
            up0e = self.ReconNet(up1e)
            up0e_from_block_4 = up0e.replace_feature(torch.cat((up0e.features, up1e.features), 1))

            return up0e_from_block_4

        else:#* here ... 
            down4c, down4b = self.resBlock5(down3c)

            up4e = self.upBlock0(down4c, down4b)
            up3e = self.upBlock1(up4e, down3b)
            up2e = self.upBlock2(up3e, down2b)
            up1e = self.upBlock3(up2e, down1b)
            up0e = self.ReconNet(up1e)
            up0e = up0e.replace_feature(torch.cat((up0e.features, up1e.features), 1))

            return up0e