class_docstr: A simple lookup table that stores embeddings of a fixed dictionary and size.
  
  This module is often used to store word embeddings and retrieve them using indices.
  The input to the module is a list of indices, and the output is the corresponding
  word embeddings.
  
  Args:
      num_embeddings (int): size of the dictionary of embeddings
      embedding_dim (int): the size of each embedding vector
      padding_idx (int, optional): If specified, the entries at :attr:`padding_idx` do not contribute to the gradient;
                                   therefore, the embedding vector at :attr:`padding_idx` is not updated during training,
                                   i.e. it remains as a fixed "pad". For a newly constructed Embedding,
                                   the embedding vector at :attr:`padding_idx` will default to all zeros,
                                   but can be updated to another value to be used as the padding vector.
      max_norm (float, optional): If given, each embedding vector with norm larger than :attr:`max_norm`
                                  is renormalized to have norm :attr:`max_norm`.
      norm_type (float, optional): The p of the p-norm to compute for the :attr:`max_norm` option. Default ``2``.
      scale_grad_by_freq (bool, optional): If given, this will scale gradients by the inverse of frequency of
                                              the words in the mini-batch. Default ``False``.
      sparse (bool, optional): If ``True``, gradient w.r.t. :attr:`weight` matrix will be a sparse tensor.
                               See Notes for more details regarding sparse gradients.
  
  Attributes:
      weight (Tensor): the learnable weights of the module of shape (num_embeddings, embedding_dim)
                       initialized from :math:`\mathcal{N}(0, 1)`
  
  Shape:
      - Input: :math:`(*)`, IntTensor or LongTensor of arbitrary shape containing the indices to extract
      - Output: :math:`(*, H)`, where `*` is the input shape and :math:`H=\text{embedding\_dim}`
  
  .. note::
      Keep in mind that only a limited number of optimizers support
      sparse gradients: currently it's :class:`optim.SGD` (`CUDA` and `CPU`),
      :class:`optim.SparseAdam` (`CUDA` and `CPU`) and :class:`optim.Adagrad` (`CPU`)
  
  .. note::
      When :attr:`max_norm` is not ``None``, :class:`Embedding`'s forward method will modify the
      :attr:`weight` tensor in-place. Since tensors needed for gradient computations cannot be
      modified in-place, performing a differentiable operation on ``Embedding.weight`` before
      calling :class:`Embedding`'s forward method requires cloning ``Embedding.weight`` when
      :attr:`max_norm` is not ``None``. For example::
  
          n, d, m = 3, 5, 7
          embedding = nn.Embedding(n, d, max_norm=True)
          W = torch.randn((m, d), requires_grad=True)
          idx = torch.tensor([1, 2])
          a = embedding.weight.clone() @ W.t()  # weight must be cloned for this to be differentiable
          b = embedding(idx) @ W.t()  # modifies weight in-place
          out = (a.unsqueeze(0) + b.unsqueeze(1))
          loss = out.sigmoid().prod()
          loss.backward()
  
  Examples::
  
      >>> # an Embedding module containing 10 tensors of size 3
      >>> embedding = nn.Embedding(10, 3)
      >>> # a batch of 2 samples of 4 indices each
      >>> input = torch.LongTensor([[1, 2, 4, 5], [4, 3, 2, 9]])
      >>> # xdoctest: +IGNORE_WANT("non-deterministic")
      >>> embedding(input)
      tensor([[[-0.0251, -1.6902,  0.7172],
               [-0.6431,  0.0748,  0.6969],
               [ 1.4970,  1.3448, -0.9685],
               [-0.3677, -2.7265, -0.1685]],
  
              [[ 1.4970,  1.3448, -0.9685],
               [ 0.4362, -0.4004,  0.9400],
               [-0.6431,  0.0748,  0.6969],
               [ 0.9124, -2.3616,  1.1151]]])
  
  
      >>> # example with padding_idx
      >>> embedding = nn.Embedding(10, 3, padding_idx=0)
      >>> input = torch.LongTensor([[0, 2, 0, 5]])
      >>> embedding(input)
      tensor([[[ 0.0000,  0.0000,  0.0000],
               [ 0.1535, -2.0309,  0.9315],
               [ 0.0000,  0.0000,  0.0000],
               [-0.1655,  0.9897,  0.0635]]])
  
      >>> # example of changing `pad` vector
      >>> padding_idx = 0
      >>> embedding = nn.Embedding(3, 3, padding_idx=padding_idx)
      >>> embedding.weight
      Parameter containing:
      tensor([[ 0.0000,  0.0000,  0.0000],
              [-0.7895, -0.7089, -0.0364],
              [ 0.6778,  0.5803,  0.2678]], requires_grad=True)
      >>> with torch.no_grad():
      ...     embedding.weight[padding_idx] = torch.ones(3)
      >>> embedding.weight
      Parameter containing:
      tensor([[ 1.0000,  1.0000,  1.0000],
              [-0.7895, -0.7089, -0.0364],
              [ 0.6778,  0.5803,  0.2678]], requires_grad=True)
code: def _fill_padding_idx_with_zero(self) -> None:
      if self.padding_idx is not None:
          with torch.no_grad():
              self.weight[self.padding_idx].fill_(0)
  
imports: from typing import Optional
  import torch
  from torch import Tensor
  from torch.nn.parameter import Parameter
  from .module import Module
  from ..None import functional
  from ..None import init
label_desc: Use image node_id 3 for calling the Embedding obj's underlying member method code with example usage: obj._fill_padding_idx_with_zero() without return types