code: def kaiming_normal_(
      tensor: Tensor,
      a: float = 0,
      mode: str = "fan_in",
      nonlinearity: str = "leaky_relu",
      generator: _Optional[torch.Generator] = None,
  ):
      r"""Fill the input `Tensor` with values using a Kaiming normal distribution.
  
      The method is described in `Delving deep into rectifiers: Surpassing
      human-level performance on ImageNet classification` - He, K. et al. (2015).
      The resulting tensor will have values sampled from
      :math:`\mathcal{N}(0, \text{std}^2)` where
  
      .. math::
          \text{std} = \frac{\text{gain}}{\sqrt{\text{fan\_mode}}}
  
      Also known as He initialization.
  
      Args:
          tensor: an n-dimensional `torch.Tensor`
          a: the negative slope of the rectifier used after this layer (only
              used with ``'leaky_relu'``)
          mode: either ``'fan_in'`` (default) or ``'fan_out'``. Choosing ``'fan_in'``
              preserves the magnitude of the variance of the weights in the
              forward pass. Choosing ``'fan_out'`` preserves the magnitudes in the
              backwards pass.
          nonlinearity: the non-linear function (`nn.functional` name),
              recommended to use only with ``'relu'`` or ``'leaky_relu'`` (default).
          generator: the torch Generator to sample from (default: None)
  
      Examples:
          >>> w = torch.empty(3, 5)
          >>> nn.init.kaiming_normal_(w, mode='fan_out', nonlinearity='relu')
      """
      if 0 in tensor.shape:
          warnings.warn("Initializing zero-element tensors is a no-op")
          return tensor
      fan = _calculate_correct_fan(tensor, mode)
      gain = calculate_gain(nonlinearity, a)
      std = gain / math.sqrt(fan)
      with torch.no_grad():
          return tensor.normal_(0, std, generator=generator)
  
imports: import math
  import warnings
  from torch import Tensor
  import torch
  from typing import Optional
label_desc: Use image node_id 20 for calling a global function with example usage: kaiming_normal_(tensor, a, mode, nonlinearity, generator) and returns: tensor, tensor