docstr: Forward computations from the noisy to the separated signals.
          
docstr_tok: ["Forward","computations","from","the","noisy","to","the","separated","signals","."]
code: def compute_forward_enhance(self, batch, stage):
      """Forward computations from the noisy to the separated signals."""
      noisy = batch.noisy_sig
      clean = batch.clean_sig
      noise = batch.noise_sig[0]
  
      # Unpack lists and put tensors in the right device
      noisy, noisy_lens = noisy
      noisy, noisy_lens = noisy.to(self.device), noisy_lens.to(
          self.device
      )
      # Convert clean to tensor
      clean = clean[0].unsqueeze(-1).to(self.device)
  
      # Add speech distortions
      if stage == sb.Stage.TRAIN:
          with torch.no_grad():
              if (
                  self.hparams.use_speedperturb
                  or self.hparams.use_rand_shift
              ):
                  noisy, clean = self.add_speed_perturb(
                      clean, noisy_lens
                  )
  
                  # Reverb already added, not adding any reverb
                  clean_rev = clean
                  noisy = clean.sum(-1)
                  # if we reverberate, we set the clean to be reverberant
                  if not self.hparams.dereverberate:
                      clean = clean_rev
  
                  noise = noise.to(self.device)
                  len_noise = noise.shape[1]
                  len_noisy = noisy.shape[1]
                  min_len = min(len_noise, len_noisy)
  
                  # add the noise
                  noisy = noisy[:, :min_len] + noise[:, :min_len]
  
                  # fix the length of clean also
                  clean = clean[:, :min_len, :]
  
              if self.hparams.limit_training_signal_len:
                  noisy, clean = self.cut_signals(noisy, clean)
  
      # Separation
      if self.use_freq_domain:
          noisy_w = self.compute_feats(noisy)
          est_mask = self.modules.masknet(noisy_w)
  
          sep_h = noisy_w * est_mask
          est_source = self.hparams.resynth(torch.expm1(sep_h), noisy)
      else:
          noisy_w = self.hparams.enhance_model["Encoder"](noisy)
          est_mask = self.modules.masknet(noisy_w)
  
          sep_h = noisy_w * est_mask
          est_source = self.hparams.enhance_model["Decoder"](sep_h[0])
  
      # T changed after conv1d in encoder, fix it here
      T_origin = noisy.size(1)
      T_est = est_source.size(1)
      est_source = est_source.squeeze(-1)
      if T_origin > T_est:
          est_source = F.pad(est_source, (0, T_origin - T_est))
      else:
          est_source = est_source[:, :T_origin]
  
      return [est_source, sep_h], clean.squeeze(-1)
  
imports: import os
  import sys
  import csv
  import logging
  import numpy
  from tqdm import tqdm
  from pesq import pesq
  from pystoi import stoi
  import torch
  import torchaudio
  import torch.nn.functional
  import speechbrain
  from hyperpyyaml import load_hyperpyyaml
  from speechbrain.utils.metric_stats import MetricStats
  from speechbrain.utils.distributed import run_on_main
  from speechbrain.utils.data_utils import undo_padding
label_desc: Use image node_id 2 for calling the ASR obj's underlying member method code with example usage: obj.compute_forward_enhance(batch, stage) and returns: list,  clean