Hi,
I am struggling with a problem, can’t find a way to debug it, really hope i can find some direction here…
I built an AE where between encoder and decoder I am adding some operations ifft, adding noise and then fft, data is complex numbers, therefore I suppurated them to real and imaginary and built the functions myself. Loss function for backward is sum of  F.mse_loss and loss that I am adding with a function I built. Problem is that without padding and padding removal I get very different results compared to when I do use padding, I can’t understand why, I expect results to be similar because I am just adding zeros from the side and removing them later, I normalized the fft and ifft so that variance per sample is the same with and without padding… I validated all operations and functions I used in my forward, the problem is with the built in backward, no idea how to check if what I am doing causing a problem there.
Sample code:
def forward(self, x, noise, device, is_train=1):
        mean_x = x.mean()
        var_x = x.var()
        fft_size = int(x.shape[1] / 2)
        x = self.encode(x)
        x = self.layer_norm_2(x, mean_x, var_x, is_train)
        #############ZERO-PADDING#####################
        p1d = [fft_size * 2, fft_size * 2]  # pad last dim by fft_size on each side
        x = F.pad(input=x, pad=p1d, mode="constant", value=0)  # effectively zero padding
        fft_size_oversamp = int(x.shape[1] / 2)
        ##########################################
        x = ifft_calc(x, fft_size_oversamp, self.idft_block_torch)
        x_ifft = x.clone()
        x = x + noise
        x = fft_calc(x, fft_size_oversamp, self.dft_block_torch)
        x = x[:, fft_size * 2:fft_size * 4].clone()  # remove padding
        x = self.decode(x)
        return x, x_ifft

The loss part calculation in the training function:
            pred_log_probs, tx_ifft = estimator.forward(x_batch, noise_batch, device)
            sec_loss = sec_calc(tx_ifft, Nsc + Nsc * pad_cnt)
            sec_loss_max = torch.max(papr_loss, dim=0).values  
            model_optimizer.zero_grad()
            loss1 = F.mse_loss(pred_log_probs, x_batch) + lamda * sec_loss_max 
            loss1.backward()
            for p in estimator.parameters():
                if p.grad is None:
                    print(p.grad)
            model_optimizer.step()


def sec_calc(x, fft_size):
    even_number = torch.arange(0, 2 * fft_size, 2)
    odd_number = torch.arange(1, 2 * fft_size, 2)
    x_real = torch.transpose(torch.transpose(x, 0, 1)[even_number], 0, 1)  
    x_imag = torch.transpose(torch.transpose(x, 0, 1)[odd_number], 0, 1)
    abs = torch.sqrt(torch.pow(x_real, 2) + torch.pow(x_imag, 2))
    numi = torch.max(torch.pow(abs, 2), dim=1)
    numi_vals = numi.values
    denumi = torch.mean(torch.pow(abs, 2), dim=1)

    sec_res = numi_vals / denumi
    return sec_res 

Hope I was clear, and to finally find some direction to solve my problem…
Tnx guys!