code: def compute_forward(self, batch, stage):
      batch = batch.to(self.device)
  
      wavs, wav_lens = batch.sig
  
      tokens_bos, _ = batch.tokens_bos  # for translation task
      transcription_bos, _ = batch.transcription_bos  # for asr task
      (
          transcription_tokens,
          _,
      ) = batch.transcription_tokens  # for mt task
  
      # compute features
      feats = self.hparams.compute_features(wavs)
      current_epoch = self.hparams.epoch_counter.current
      feats = self.hparams.normalize(
          feats, wav_lens, epoch=current_epoch
      )
  
      # forward modules
      src = self.modules.CNN(feats)
      enc_out, pred = self.modules.Transformer(
          src, tokens_bos, wav_lens, pad_idx=self.hparams.pad_index
      )
  
      asr_p_seq = None
      # asr output layer for seq2seq log-probabilities
      if self.hparams.asr_weight > 0 and self.hparams.ctc_weight < 1:
          asr_pred = self.modules.Transformer.forward_asr(
              enc_out,
              src,
              transcription_bos,
              wav_lens,
              pad_idx=self.hparams.pad_index,
          )
          asr_pred = self.modules.asr_seq_lin(asr_pred)
          asr_p_seq = self.hparams.log_softmax(asr_pred)
  
      # st output layer for seq2seq log-probabilities
      pred = self.modules.seq_lin(pred)
      p_seq = self.hparams.log_softmax(pred)
  
      # asr ctc
      p_ctc = None
      if self.hparams.ctc_weight > 0:
          logits = self.modules.ctc_lin(enc_out)
          p_ctc = self.hparams.log_softmax(logits)
  
      # mt task
      mt_p_seq = None
      if self.hparams.mt_weight > 0:
          _, mt_pred = self.modules.Transformer.forward_mt(
              transcription_tokens,
              tokens_bos,
              pad_idx=self.hparams.pad_index,
          )
  
          # mt output layer for seq2seq log-probabilities
          mt_pred = self.modules.seq_lin(mt_pred)
          mt_p_seq = self.hparams.log_softmax(mt_pred)
  
      # Compute outputs
      hyps = None
      current_epoch = self.hparams.epoch_counter.current
      is_valid_search = (
          stage == sb.Stage.VALID
          and current_epoch % self.hparams.valid_search_interval == 0
      )
      is_test_search = stage == sb.Stage.TEST
      if is_valid_search:
          hyps, _, _, _ = self.hparams.valid_search(
              enc_out.detach(), wav_lens
          )
      elif is_test_search:
          hyps, _, _, _ = self.hparams.test_search(
              enc_out.detach(), wav_lens
          )
  
      return p_ctc, p_seq, asr_p_seq, mt_p_seq, wav_lens, hyps
  
file_path: speechbrain/recipes/Fisher-Callhome-Spanish/ST/transformer/train.py
imports: import sys
  import torch
  import logging
  import speechbrain
  from sacremoses import MosesDetokenizer
  from hyperpyyaml import load_hyperpyyaml
  from speechbrain.utils.distributed import run_on_main
label_desc: Use image node_id 1 for calling the ST obj's underlying member method code with example usage: obj.compute_forward(batch, stage) and returns: p_ctc,  p_seq,  asr_p_seq,  mt_p_seq,  wav_lens,  hyps