class_docstr: Differentially Private Split-MPC module that provides label-DP. Models will
  run in 6 steps:
      (1) Run forward pass in plaintext using PyTorch to get logits
      (2) Apply logistic function (sigmoid or softmax) to get predictions
      (2) Compute loss function in CrypTen
      (3) Compute dL/dZ (gradient w.r.t logits) in CrypTen
      (5) Compute aggregated parameter gradients with differential privacy
      (6) Decrypt noisy gradients
  
  Step (5) is computed using different methods depending on protocol configuration
      (See Config Options > protocol for descriptions)
  
  Args:
      pytorch_model (torch.nn.Module) : The input model to be trained
          using DP-Split-MPC algorithm. Remains in plaintext throughout.
      noise_magnitude (float) : The magnitude of DP noise to be applied to
          gradients prior to decryption for each batch of training.
      feature_src (int) : Source for input features to the model (also owns
          the plaintext model throughout training)
      label_src (int) : Source for training labels. Labels can either be input
          as plaintext values from the label_src party or as CrypTensors.
  
  Config Options:
      skip_loss_forward (bool) : Determines whether to compute the
          value of the loss during training (see crypten.nn._Loss definition
          of skip_forward). If True, this model will output zeros for the value
          of the loss function. However, correct gradients will still be computed
          when calling backward(). Default: True
      cache_pred_size (bool) :  Determines whether the size of the predictions should
          be cached. If True, DPSplitModel instances will remember the tensor and
          batch sizes input. This saves one communication round per batch, but
          the user will be responsible for using correct batch sizes to avoid
          crashing.
      protocol (string): Name of protocol to use to compute gradients:
              "full_jacobian": Computes the full jacobian to compute all parameter gradients from dL/dP.
                  This jacobian will be encrypted and gradients are computed by an encrypted matrix multiplication.
              "layer_estimation": Computes the jacobian only with respect to the last linear layer (dL/dW)
                  of the forward network. DP and aggregation are applied before decrypting dL/dW. This gradient
                  is then used to estimate dL/dZ (gradient w.r.t. logits). Backpropagation is
                  then computed normally in plaintext.
  
  Example:
      ```
      preds = dp_split_model(x)
      loss = dp_split_model.compute_loss(targets)
      dp_split_model.backward()
      ```
code: def training(self, mode):
      self.train(mode)
  
imports: import fate.arch.protocol.mpc.communicator
  import torch
  import torch.nn
  from fate.arch.protocol.mpc.config import cfg
label_desc: Use image node_id 4 for calling the DPSplitModel obj's underlying member method code with example usage: obj.training(mode) without return types