class_docstr: Class performing adversarial training following the DP-InstaHide protocol.
  
  Uses data augmentation methods in conjunction with some type of additive noise.
  
  | Paper link: https://arxiv.org/abs/2103.02079
class_docstr_tok: ["Class","performing","adversarial","training","following","the","DP-InstaHide","protocol",".","Uses","data","augmentation","methods","in","conjunction","with","some","type","of","additive","noise",".","|","Paper","link",":","https",":","\/\/arxiv.org\/abs\/2103.02079"]
docstr: Train a model adversarially with the DP-InstaHide protocol.
  See class documentation for more information on the exact procedure.
  
  :param x: Training set.
  :param y: Labels for the training set.
  :param validation_data: Tuple consisting of validation data, (x_val, y_val)
  :param batch_size: Size of batches.
  :param nb_epochs: Number of epochs to use for trainings.
  :param kwargs: Dictionary of framework-specific arguments. These will be passed as such to the `fit` function
         of the target classifier.
docstr_tok: ["Train","a","model","adversarially","with","the","DP-InstaHide","protocol",".","See","class","documentation","for","more","information","on","the","exact","procedure",".",":","param","x",":","Training","set",".",":","param","y",":","Labels","for","the","training","set",".",":","param","validation_data",":","Tuple","consisting","of","validation","data",",","(","x_val",",","y_val",")",":","param","batch_size",":","Size","of","batches",".",":","param","nb_epochs",":","Number","of","epochs","to","use","for","trainings",".",":","param","kwargs",":","Dictionary","of","framework-specific","arguments",".","These","will","be","passed","as","such","to","the","`","fit","`","function","of","the","target","classifier","."]
code: def fit(  # pylint: disable=W0221
      self,
      x: np.ndarray,
      y: np.ndarray,
      validation_data: Optional[Tuple[np.ndarray, np.ndarray]] = None,
      batch_size: int = 128,
      nb_epochs: int = 20,
      **kwargs,
  ):
      """
      Train a model adversarially with the DP-InstaHide protocol.
      See class documentation for more information on the exact procedure.
  
      :param x: Training set.
      :param y: Labels for the training set.
      :param validation_data: Tuple consisting of validation data, (x_val, y_val)
      :param batch_size: Size of batches.
      :param nb_epochs: Number of epochs to use for trainings.
      :param kwargs: Dictionary of framework-specific arguments. These will be passed as such to the `fit` function
             of the target classifier.
      """
      logger.info(
          "Performing adversarial training with DP-InstaHide protocol"
      )
  
      nb_batches = int(np.ceil(len(x) / batch_size))
      ind = np.arange(len(x))
  
      logger.info("Adversarial Training DP-InstaHide")
  
      for i_epoch in trange(
          nb_epochs, desc="DP-InstaHide training epochs"
      ):
          # shuffle the examples
          np.random.shuffle(ind)
          start_time = time.time()
          train_loss = 0.0
          train_acc = 0.0
          train_n = 0.0
  
          for batch_id in range(nb_batches):
              # create batch data
              x_batch = x[
                  ind[
                      batch_id
                      * batch_size : min(
                          (batch_id + 1) * batch_size, x.shape[0]
                      )
                  ]
              ]
              y_batch = y[
                  ind[
                      batch_id
                      * batch_size : min(
                          (batch_id + 1) * batch_size, x.shape[0]
                      )
                  ]
              ]
  
              # augment the data
              x_aug = x_batch.copy()
              y_aug = y_batch.copy()
              for augmentation in self.augmentations:
                  x_aug, y_aug = augmentation(x_aug, y_aug)
  
              # apply additive noise
              x_aug = self._generate_noise(x_aug)
  
              # fit batch
              self._classifier.fit(
                  x_aug,
                  y_aug,
                  nb_epochs=1,
                  batch_size=x_aug.shape[0],
                  verbose=False,
                  **kwargs,
              )
  
              # get metrics
              loss = self._classifier.compute_loss(
                  x_aug, y_aug, reduction="mean"
              )
              output = np.argmax(self.predict(x_batch), axis=1)
              acc = np.sum(output == np.argmax(y_batch, axis=1))
              n = len(x_aug)
  
              # update metrics
              train_loss += np.sum(loss)
              train_acc += acc
              train_n += n
  
          train_time = time.time()
  
          # compute accuracy
          if validation_data is not None:
              (x_test, y_test) = validation_data
              output = np.argmax(self.predict(x_test), axis=1)
              test_loss = self._classifier.compute_loss(
                  x_test, y_test, reduction="mean"
              )
              test_acc = np.mean(output == np.argmax(y_test, axis=1))
              logger.info(
                  "epoch: %s time(s): %.1f, loss(tr): %.4f, acc(tr): %.4f, loss(val): %.4f, acc(val): %.4f",
                  i_epoch,
                  train_time - start_time,
                  train_loss / train_n,
                  train_acc / train_n,
                  test_loss,
                  test_acc,
              )
          else:
              logger.info(
                  "epoch: %s time(s): %.1f, loss: %.4f, acc: %.4f",
                  i_epoch,
                  train_time - start_time,
                  train_loss / train_n,
                  train_acc / train_n,
              )
  
file_path: adversarial-robustness-toolbox/art/defences/trainer/dp_instahide_trainer.py
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import logging
  import sys
  import time
  from typing import List, Optional, Union, Tuple, TYPE_CHECKING
  import numpy
  from tqdm.auto import trange
  from art.defences.trainer.trainer import Trainer
label_desc: Use image node_id 3 for calling the DPInstaHideTrainer obj's underlying member method code with example usage: obj.fit(x, y, validation_data, batch_size, nb_epochs) without return types