code: def _istft_v1(
      y_r,
      y_i,
      window_size,
      stride,
      fft_size,
      window_type="hanning",
      center=True,
  ):
      """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.
  
      Returns:
          ~nnabla.Variable: Time domain sequence of size `batch_size x sample_size`.
      """
      from nnabla.parameter import (
          get_parameter,
          get_parameter_or_create,
      )
  
      conv_cos = get_parameter("conv_cos")
      conv_sin = get_parameter("conv_sin")
  
      if conv_cos is None or conv_sin is None:
          if window_type == "hanning":
              window_func = np.hanning(window_size + 1)[:-1]
          elif window_type == "hamming":
              window_func = np.hamming(window_size + 1)[:-1]
          elif window_type == "rectangular" or window_type is None:
              window_func = np.ones(window_size)
          else:
              raise ValueError(
                  "Unknown window type {}.".format(window_type)
              )
  
          # pad window if `fft_size > window_size`
          if fft_size > window_size:
              diff = fft_size - window_size
              window_func = np.pad(
                  window_func,
                  (diff // 2, diff - diff // 2),
                  mode="constant",
              )
          elif fft_size < window_size:
              raise ValueError(
                  "FFT size has to be as least as large as window size."
              )
  
          # compute inverse STFT filter coefficients
          if fft_size % stride != 0:
              raise ValueError(
                  "FFT size needs to be a multiple of stride."
              )
  
          inv_window_func = np.zeros_like(window_func)
          for s in range(0, fft_size, stride):
              inv_window_func += np.roll(np.square(window_func), s)
  
          mat_cos = np.zeros((fft_size // 2 + 1, 1, fft_size))
          mat_sin = np.zeros((fft_size // 2 + 1, 1, fft_size))
  
          for w in range(fft_size // 2 + 1):
              alpha = 1.0 if w == 0 or w == fft_size // 2 else 2.0
              alpha /= fft_size
              for t in range(fft_size):
                  mat_cos[w, 0, t] = alpha * np.cos(
                      2.0 * np.pi * w * t / fft_size
                  )
                  mat_sin[w, 0, t] = alpha * np.sin(
                      2.0 * np.pi * w * t / fft_size
                  )
          mat_cos = mat_cos * window_func / inv_window_func
          mat_sin = mat_sin * window_func / inv_window_func
  
          conv_cos = get_parameter_or_create(
              "conv_cos", initializer=mat_cos, need_grad=False
          )
          conv_sin = get_parameter_or_create(
              "conv_sin", initializer=mat_sin, need_grad=False
          )
  
      # compute inverse STFT
      x_cos = deconvolution(y_r, conv_cos, stride=(stride,))
      x_sin = deconvolution(y_i, conv_sin, stride=(stride,))
  
      x = reshape(x_cos - x_sin, (x_cos.shape[0], x_cos.shape[2]))
  
      if center:
          x = x[:, fft_size // 2 : -fft_size // 2]
  
      return x
  
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 25 for calling a global function with example usage: _istft_v1(y_r, y_i, window_size, stride, fft_size, window_type, center) and returns: x