class_docstr: A BatchNorm layer tracks multiple micro-batches to update running
  statistics per mini-batch.
code: def forward(self, input: Tensor) -> Tensor:  # type: ignore
      if not self.training:
          # Don't train parameters on the evaluation mode.
          return F.batch_norm(
              input,
              running_mean=self.running_mean,
              running_var=self.running_var,
              weight=self.weight,
              bias=self.bias,
              training=False,
              momentum=0.0,
              eps=self.eps,
          )
  
      if not is_recomputing():
          # Track a micro-batch on the training mode
          # but not under a recomputation.
          tracked_enough = self._track(input)
  
          # Update the running statistics for a mini-batch
          # if it has tracked enough micro-batches.
          if tracked_enough:
              self._commit()
  
      # Normalize a micro-batch and train the parameters.
      return F.batch_norm(
          input,
          running_mean=None,
          running_var=None,
          weight=self.weight,
          bias=self.bias,
          training=True,
          momentum=0.0,
          eps=self.eps,
      )
  
file_path: fairscale/fairscale/nn/pipe/batchnorm.py
imports: from typing import Optional, TypeVar, cast
  import torch
  from torch import Tensor, nn
  import torch.nn.functional
  from torch.nn.modules.batchnorm import _BatchNorm
  from .checkpoint import is_recomputing
label_desc: Use image node_id 5 for calling the DeferredBatchNorm obj's underlying member method code with example usage: obj.forward(input) and returns: F, F