code: def _itakura_mask(sz1, sz2, max_slope=2.0, be=None):
      """Compute the Itakura mask without checking that the constraints
      are feasible. In most cases, you should use itakura_mask instead.
  
      Parameters
      ----------
      sz1 : int
          The size of the first time series
      sz2 : int
          The size of the second time series.
      max_slope : float (default = 2)
          The maximum slope of the parallelogram.
      be : Backend object or string or None
          Backend. If `be` is an instance of the class `NumPyBackend` or the string `"numpy"`,
          the NumPy backend is used.
          If `be` is an instance of the class `PyTorchBackend` or the string `"pytorch"`,
          the PyTorch backend is used.
          If `be` is `None`, the backend is determined by the input arrays.
          See our :ref:`dedicated user-guide page <backend>` for more information.
  
      Returns
      -------
      mask : array-like, shape=(sz1, sz2)
          Itakura mask.
      """
      be = instantiate_backend(be)
      min_slope = 1 / float(max_slope)
      max_slope *= float(sz1) / float(sz2)
      min_slope *= float(sz1) / float(sz2)
  
      lower_bound = be.empty((2, sz2))
      lower_bound[0] = min_slope * be.arange(sz2)
      lower_bound[1] = (
          (sz1 - 1) - max_slope * (sz2 - 1) + max_slope * be.arange(sz2)
      )
      lower_bound_ = be.empty(sz2)
      for i in range(sz2):
          lower_bound_[i] = max(
              be.round(lower_bound[0, i], decimals=2),
              be.round(lower_bound[1, i], decimals=2),
          )
      lower_bound_ = be.ceil(lower_bound_)
  
      upper_bound = be.empty((2, sz2))
      upper_bound[0] = max_slope * be.arange(sz2)
      upper_bound[1] = (
          (sz1 - 1) - min_slope * (sz2 - 1) + min_slope * be.arange(sz2)
      )
      upper_bound_ = be.empty(sz2)
      for i in range(sz2):
          upper_bound_[i] = min(
              be.round(upper_bound[0, i], decimals=2),
              be.round(upper_bound[1, i], decimals=2),
          )
      upper_bound_ = be.floor(upper_bound_ + 1)
  
      mask = be.full((sz1, sz2), be.inf)
      for i in range(sz2):
          mask[int(lower_bound_[i]) : int(upper_bound_[i]), i] = 0.0
      return mask
  
imports: import warnings
  import numpy
  from numba import njit, prange
  from tslearn.backend import instantiate_backend
  from tslearn.utils import to_time_series
  from .utils import _cdist_generic
label_desc: Use image node_id 29 for calling a global function with example usage: _itakura_mask(sz1, sz2, max_slope, be) and returns: mask