code: def make_pad_mask(lengths, xs=None, length_dim=-1, maxlen=None):
      """Make mask tensor containing indices of padded part.
  
      Args:
          lengths (LongTensor or List): Batch of lengths (B,).
          xs (Tensor, optional): The reference tensor.
              If set, masks will be the same shape as this tensor.
          length_dim (int, optional): Dimension indicator of the above tensor.
              See the example.
  
      Returns:
          Tensor: Mask tensor containing indices of padded part.
                  dtype=torch.uint8 in PyTorch 1.2-
                  dtype=torch.bool in PyTorch 1.2+ (including 1.2)
  
      Examples:
          With only lengths.
  
          >>> lengths = [5, 3, 2]
          >>> make_pad_mask(lengths)
          masks = [[0, 0, 0, 0 ,0],
                   [0, 0, 0, 1, 1],
                   [0, 0, 1, 1, 1]]
  
          With the reference tensor.
  
          >>> xs = torch.zeros((3, 2, 4))
          >>> make_pad_mask(lengths, xs)
          tensor([[[0, 0, 0, 0],
                   [0, 0, 0, 0]],
                  [[0, 0, 0, 1],
                   [0, 0, 0, 1]],
                  [[0, 0, 1, 1],
                   [0, 0, 1, 1]]], dtype=torch.uint8)
          >>> xs = torch.zeros((3, 2, 6))
          >>> make_pad_mask(lengths, xs)
          tensor([[[0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1]],
                  [[0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1]],
                  [[0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1]]], dtype=torch.uint8)
  
          With the reference tensor and dimension indicator.
  
          >>> xs = torch.zeros((3, 6, 6))
          >>> make_pad_mask(lengths, xs, 1)
          tensor([[[0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [1, 1, 1, 1, 1, 1]],
                  [[0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1]],
                  [[0, 0, 0, 0, 0, 0],
                   [0, 0, 0, 0, 0, 0],
                   [1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1]]], dtype=torch.uint8)
          >>> make_pad_mask(lengths, xs, 2)
          tensor([[[0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1],
                   [0, 0, 0, 0, 0, 1]],
                  [[0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1],
                   [0, 0, 0, 1, 1, 1]],
                  [[0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1],
                   [0, 0, 1, 1, 1, 1]]], dtype=torch.uint8)
  
      """
      if length_dim == 0:
          raise ValueError(
              "length_dim cannot be 0: {}".format(length_dim)
          )
  
      # If the input dimension is 2 or 3,
      # then we use ESPnet-ONNX based implementation for tracable modeling.
      # otherwise we use the traditional implementation for research use.
      if isinstance(lengths, list):
          logging.warning(
              "Using make_pad_mask with a list of lengths is not tracable. "
              + "If you try to trace this function with type(lengths) == list, "
              + "please change the type of lengths to torch.LongTensor."
          )
  
      if (
          (xs is None or xs.dim() in (2, 3))
          and length_dim <= 2
          and (not isinstance(lengths, list) and lengths.dim() == 1)
      ):
          return _make_pad_mask_traceable(
              lengths, xs, length_dim, maxlen
          )
      else:
          return _make_pad_mask(lengths, xs, length_dim, maxlen)
  
file_path: espnet/espnet/nets/pytorch_backend/nets_utils.py
imports: import logging
  from typing import Dict
  import numpy
  import torch
label_desc: Use image node_id 3 for calling a global function with example usage: make_pad_mask(lengths, xs, length_dim, maxlen) and returns: _make_pad_mask_traceable, _make_pad_mask