code: def forward(
      self,
      *,
      enc_out=None,
      enc_mask=None,
      durs=None,
      pitch=None,
      pace=1.0,
  ):
      log_durs_predicted, durs_predicted = None, None
      if self.duration_predictor is not None:
          log_durs_predicted = self.duration_predictor(
              enc_out, enc_mask
          )
          durs_predicted = log_to_duration(
              log_dur=log_durs_predicted,
              min_dur=self.min_token_duration,
              max_dur=self.max_token_duration,
              mask=enc_mask,
          )
  
      # Predict pitch
      pitch_predicted = None
      if self.pitch_predictor is not None:
          pitch_predicted = self.pitch_predictor(enc_out, enc_mask)
          if pitch is not None:
              if pitch.shape[-1] != enc_out.shape[1]:
                  # during inference, we send the averaged pitch over each token so we don't need to average here
                  # TODO: have a flag to indicate whether the pitch is already averaged or not
                  pitch = average_features(
                      pitch.unsqueeze(1), durs
                  ).squeeze(1)
  
              pitch_emb = self.pitch_emb(pitch.unsqueeze(1))
          else:
              pitch_emb = self.pitch_emb(pitch_predicted.unsqueeze(1))
  
          enc_out = enc_out + pitch_emb.transpose(1, 2)
  
      if durs is not None:
          len_regulated, dec_lens = regulate_len(durs, enc_out, pace)
      else:
          # Use predictions during inference
          assert (
              self.duration_predictor is not None
          ), "Duration predictor cannot be none if durs is not provided"
          len_regulated, dec_lens = regulate_len(
              durs_predicted, enc_out, pace
          )
  
      # Output FFT
      dec_out, _ = self.decoder(input=len_regulated, seq_lens=dec_lens)
      spect = self.proj(dec_out).transpose(1, 2)
      return (
          spect,
          dec_lens,
          durs_predicted,
          log_durs_predicted,
          pitch_predicted,
          pitch,
      )
  
imports: import torch
  from nemo.collections.tts.modules.submodules import ConditionalInput, ConditionalLayerNorm
  from nemo.collections.tts.parts.utils.helpers import binarize_attention_parallel, regulate_len
  from nemo.core.classes import NeuralModule, adapter_mixins, typecheck
  from nemo.core.neural_types.elements import EncodedRepresentation, Index, LengthsType, LogprobsType, MelSpectrogramType, ProbsType, RegressionValuesType, TokenDurationType, TokenIndex, TokenLogDurationType
  from nemo.core.neural_types.neural_type import NeuralType
label_desc: Use image node_id 4 for calling the FastPitchSSLModule obj's underlying member method code with example usage: obj.forward() and returns: spect,  dec_lens,  durs_predicted,  log_durs_predicted,  pitch_predicted,  pitch