torch (version 0.0.1)

torch_stft: Stft

Description

Stft

Arguments

input

(Tensor) the input tensor

n_fft

(int) size of Fourier transform

hop_length

(int, optional) the distance between neighboring sliding window frames. Default: None (treated as equal to floor(n_fft / 4))

win_length

(int, optional) the size of window frame and STFT filter. Default: None (treated as equal to n_fft)

window

(Tensor, optional) the optional window function. Default: None (treated as window of all $1$ s)

center

(bool, optional) whether to pad input on both sides so that the $t$-th frame is centered at time $t\times \text{hop\_length}$. Default: True

pad_mode

(string, optional) controls the padding method used when center is True. Default: "reflect"

normalized

(bool, optional) controls whether to return the normalized STFT results Default: False

onesided

(bool, optional) controls whether to return half of results to avoid redundancy Default: True

Short-time Fourier transform (STFT).

Short-time Fourier transform (STFT).

Ignoring the optional batch dimension, this method computes the following
expression:

$$X[m,\omega ]=\sum _{k=0}^{\text{win\_length-1}}\text{window}[k]\text{input}[m\times \text{hop\_length}+k]\exp (-j\frac{2\pi \cdot \omega k}{\text{win\_length}}),$$ where $m$ is the index of the sliding window, and $\omega$ is the frequency that $0\le \omega <\text{n\_fft}$. When onesided is the default value True,

* `input` must be either a 1-D time sequence or a 2-D batch of time
  sequences.
* If `hop_length` is ``None`` (default), it is treated as equal to
  ``floor(n_fft / 4)``.
* If `win_length` is ``None`` (default), it is treated as equal to
  `n_fft`.
* `window` can be a 1-D tensor of size `win_length`, e.g., from
  `torch_hann_window`. If `window` is ``None`` (default), it is
  treated as if having \eqn{1} everywhere in the window. If
  \eqn{\mbox{win\_length} < \mbox{n\_fft}}, `window` will be padded on
  both sides to length `n_fft` before being applied.
* If `center` is ``True`` (default), `input` will be padded on
  both sides so that the \eqn{t}-th frame is centered at time
  \eqn{t \times \mbox{hop\_length}}. Otherwise, the \eqn{t}-th frame
  begins at time  \eqn{t \times \mbox{hop\_length}}.
* `pad_mode` determines the padding method used on `input` when
  `center` is ``True``. See `torch_nn.functional.pad` for
  all available options. Default is ``"reflect"``.
* If `onesided` is ``True`` (default), only values for \eqn{\omega}
  in \eqn{\left[0, 1, 2, \dots, \left\lfloor \frac{\mbox{n\_fft}}{2} \right\rfloor + 1\right]}
  are returned because the real-to-complex Fourier transform satisfies the
  conjugate symmetry, i.e., \eqn{X[m, \omega] = X[m, \mbox{n\_fft} - \omega]^*}.
* If `normalized` is ``True`` (default is ``False``), the function
  returns the normalized STFT results, i.e., multiplied by \eqn{(\mbox{frame\_length})^{-0.5}}.
Returns the real and the imaginary parts together as one tensor of size
\eqn{(* \times N \times T \times 2)}, where \eqn{*} is the optional
batch size of `input`, \eqn{N} is the number of frequencies where
STFT is applied, \eqn{T} is the total number of frames used, and each pair
in the last dimension represents a complex number as the real part and the
imaginary part.
.. warning::
  This function changed signature at version 0.4.1. Calling with the
  previous signature may cause error or return incorrect result.