code: def istft(
      y_r,
      y_i,
      window_size,
      stride,
      fft_size,
      window_type="hanning",
      center=True,
      pad_mode="reflect",
      as_stft_backward=False,
  ):
      """Computes the inverse shoft-time Fourier transform
  
      Note: We use a constant square inverse window for the reconstruction
      of the time-domain signal, therefore, the first and last
      `window_size - stride` are not perfectly reconstructed.
  
      Args:
          y_r (~nnabla.Variable): Real part of STFT of size `batch_size x fft_size//2 + 1 x frame_size`.
          y_i (~nnabla.Variable): Imaginary part of STFT of size `batch_size x fft_size//2 + 1 x frame_size`.
          window_size (int): Size of STFT analysis window.
          stride (int): Number of samples that we shift the window, also called `hop size`.
          fft_size (int): Size of the FFT, (STFT has `fft_size // 2 + 1` frequency bins).
          window_type (str): Analysis window, can be either `hanning`, `hamming` or `rectangular`.
              For convenience, also `window_type=None` is supported which is equivalent to `window_type='rectangular'`.
          center (bool): If `True`, then it is assumed that the time-domain signal has centered frames.
          pad_mode (str): Padding mode corresponding to STFT `pad_mode`, which can be `'constant'` or `'reflect'`. `'constant'` pads with `0`.
              This option is ignored for the normal use of ISTFT. You need to set the same `pad_mode` only when `as_stft_backward == True`.
          as_stft_backward (bool): If `True`, then forward execution behaves as backward execution of STFT,
              treating inputs `y_r` and `y_i` as outputs gradient of STFT and output `x` as input gradient of STFT.
              This option is only used in nn.grad operator.
  
      Returns:
          ~nnabla.Variable: Time domain sequence of size `batch_size x sample_size`.
      """
      from .function_bases import istft as istft_base
  
      if window_type is None:
          window_type = "rectangular"
      return istft_base(
          y_r,
          y_i,
          window_size,
          stride,
          fft_size,
          window_type,
          center,
          pad_mode,
          as_stft_backward,
      )
  
imports: from __future__ import absolute_import
  from .function_bases import *
  from .None import dtypes
  import nnabla
  import numpy
  from .normalization_functions import *
  from .numpy_compat_functions import *
label_desc: Use image node_id 24 for calling a global function with example usage: istft(y_r, y_i, window_size, stride, fft_size, window_type, center, pad_mode, as_stft_backward) and returns: istft_base