mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/dataset/audio/transforms.py

@@ -22,15 +22,16 @@ their training models.
 import numpy as np
 
 import mindspore._c_dataengine as cde
-from .utils import BorderType, DensityFunction, FadeShape, GainType, Interpolation, MelType, Modulation, NormType, \
-    ResampleMethod, ScaleType, WindowType
+from .utils import BorderType, DensityFunction, FadeShape, GainType, Interpolation, MelType, Modulation, NormMode, \
+    NormType, ResampleMethod, ScaleType, WindowType
 from .validators import check_allpass_biquad, check_amplitude_to_db, check_band_biquad, check_bandpass_biquad, \
     check_bandreject_biquad, check_bass_biquad, check_biquad, check_complex_norm, check_compute_deltas, \
     check_contrast, check_db_to_amplitude, check_dc_shift, check_deemph_biquad, check_detect_pitch_frequency, \
     check_dither, check_equalizer_biquad, check_fade, check_flanger, check_gain, check_griffin_lim, \
-    check_highpass_biquad, check_inverse_mel_scale, check_lfilter, check_lowpass_biquad, check_magphase, \
-    check_mask_along_axis, check_mask_along_axis_iid, check_masking, check_mel_scale, check_mu_law_coding, \
-    check_overdrive, check_phase_vocoder, check_phaser, check_resample, check_riaa_biquad, check_sliding_window_cmn, \
+    check_highpass_biquad, check_inverse_mel_scale, check_inverse_spectrogram, check_lfcc, check_lfilter, \
+    check_lowpass_biquad, check_magphase, check_mask_along_axis, check_mask_along_axis_iid, check_masking, \
+    check_mel_scale, check_mel_spectrogram, check_mfcc, check_mu_law_coding, check_overdrive, check_phase_vocoder, \
+    check_phaser, check_pitch_shift, check_resample, check_riaa_biquad, check_sliding_window_cmn, \
     check_spectral_centroid, check_spectrogram, check_time_stretch, check_treble_biquad, check_vad, check_vol
 from ..transforms.py_transforms_util import Implementation
 from ..transforms.transforms import TensorOperation
@@ -68,7 +69,7 @@ class AllpassBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -116,7 +117,7 @@ class AmplitudeToDB(AudioTensorOperation):
     Turn the input audio waveform from the amplitude/power scale to decibel scale.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., freq, time).
+        The shape of the audio waveform to be processed needs to be <..., freq, time>.
 
     Args:
         stype (ScaleType, optional): Scale of the input waveform, which can be
@@ -170,7 +171,7 @@ class Angle(AudioTensorOperation):
     Calculate the angle of complex number sequence.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., complex=2).
+        The shape of the audio waveform to be processed needs to be <..., complex=2>.
         The first dimension represents the real part while the second represents the imaginary.
 
     Raises:
@@ -203,7 +204,7 @@ class BandBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -264,7 +265,7 @@ class BandpassBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -323,7 +324,7 @@ class BandrejectBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -375,7 +376,7 @@ class BassBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -426,10 +427,22 @@ class Biquad(TensorOperation):
         b0 (float): Numerator coefficient of current input, x[n].
         b1 (float): Numerator coefficient of input one time step ago x[n-1].
         b2 (float): Numerator coefficient of input two time steps ago x[n-2].
-        a0 (float): Denominator coefficient of current output y[n], the value can't be zero, typically 1.
+        a0 (float): Denominator coefficient of current output y[n], the value can't be 0, typically 1.
         a1 (float): Denominator coefficient of current output y[n-1].
         a2 (float): Denominator coefficient of current output y[n-2].
 
+    Raises:
+        TypeError: If `b0` is not of type float.
+        TypeError: If `b1` is not of type float.
+        TypeError: If `b2` is not of type float.
+        TypeError: If `a0` is not of type float.
+        TypeError: If `a1` is not of type float.
+        TypeError: If `a2` is not of type float.
+        ValueError: If `a0` is 0.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -457,7 +470,7 @@ class ComplexNorm(AudioTensorOperation):
     Compute the norm of complex number sequence.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., complex=2).
+        The shape of the audio waveform to be processed needs to be <..., complex=2>.
         The first dimension represents the real part while the second represents the imaginary.
 
     Args:
@@ -528,6 +541,9 @@ class ComputeDeltas(AudioTensorOperation):
         TypeError: If `pad_mode` is not of type :class:`mindspore.dataset.audio.BorderType` .
         RuntimeError: If input tensor is not in shape of <..., freq, time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>> from mindspore.dataset.audio import BorderType
@@ -557,7 +573,7 @@ class Contrast(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         enhancement_amount (float, optional): Controls the amount of the enhancement,
@@ -598,6 +614,13 @@ class DBToAmplitude(AudioTensorOperation):
         ref (float): Reference which the output will be scaled by.
         power (float): If power equals 1, will compute DB to power. If 0.5, will compute DB to amplitude.
 
+    Raises:
+        TypeError: If `ref` is not of type float.
+        TypeError: If `power` is not of type float.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -624,7 +647,15 @@ class DCShift(AudioTensorOperation):
     Args:
         shift (float): The amount to shift the audio, the value must be in the range [-2.0, 2.0].
         limiter_gain (float, optional): Used only on peaks to prevent clipping,
-            the value should be much less than 1, such as 0.05 or 0.02.
+            the value should be much less than 1, such as 0.05 or 0.02. Default: None, will be set to `shift` .
+
+    Raises:
+        TypeError: If `shift` is not of type float.
+        ValueError: If `shift` is not in range [-2.0, 2.0].
+        TypeError: If `limiter_gain` is not of type float.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -659,6 +690,9 @@ class DeemphBiquad(AudioTensorOperation):
         ValueError: If `sample_rate` is not 44100 or 48000.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -693,6 +727,21 @@ class DetectPitchFrequency(AudioTensorOperation):
         freq_high (int, optional): Highest frequency that can be detected (Hz), the value must be greater than zero.
             Default: 3400.
 
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is 0.
+        TypeError: If `frame_time` is not of type float.
+        ValueError: If `frame_time` is not positive.
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is not positive.
+        TypeError: If `freq_low` is not of type int.
+        ValueError: If `freq_low` is not positive.
+        TypeError: If `freq_high` is not of type int.
+        ValueError: If `freq_high` is not positive.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -741,6 +790,9 @@ class Dither(AudioTensorOperation):
         TypeError: If `noise_shaping` is not of type bool.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -767,11 +819,22 @@ class EqualizerBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
-        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be zero.
+        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be 0.
         center_freq (float): Central frequency (in Hz).
         gain (float): Desired gain at the boost (or attenuation) in dB.
         Q (float, optional): https://en.wikipedia.org/wiki/Q_factor, range: (0, 1]. Default: 0.707.
 
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is 0.
+        TypeError: If `center_freq` is not of type float.
+        TypeError: If `gain` is not of type float.
+        TypeError: If `Q` is not of type float.
+        ValueError: If `Q` is not in range of (0, 1].
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -824,6 +887,9 @@ class Fade(AudioTensorOperation):
         RuntimeError: If fade_in_len exceeds waveform length.
         RuntimeError: If fade_out_len exceeds waveform length.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>> from mindspore.dataset.audio import FadeShape
@@ -850,16 +916,20 @@ class Filtfilt(AudioTensorOperation):
     Apply an IIR filter forward and backward to a waveform.
 
     Args:
-        a_coeffs (Sequence): denominator coefficients of difference equation of dimension of (n_order + 1).
+        a_coeffs (Sequence[float]): Denominator coefficients of difference equation of dimension.
             Lower delays coefficients are first, e.g. [a0, a1, a2, ...].
             Must be same size as b_coeffs (pad with 0's as necessary).
-        b_coeffs (Sequence): numerator coefficients of difference equation of dimension of (n_order + 1).
+        b_coeffs (Sequence[float]): Numerator coefficients of difference equation of dimension.
             Lower delays coefficients are first, e.g. [b0, b1, b2, ...].
             Must be same size as a_coeffs (pad with 0's as necessary).
         clamp (bool, optional): If True, clamp the output signal to be in the range [-1, 1]. Default: True.
 
     Raises:
-        RuntimeError: If the shape of input audio waveform does not match <..., time>.
+        TypeError: If `a_coeffs` is not of type Sequence[float].
+        TypeError: If `b_coeffs` is not of type Sequence[float].
+        ValueError: If `a_coeffs` and `b_coeffs` are of different sizes.
+        TypeError: If `clamp` is not of type bool.
+        RuntimeError: If shape of the input audio is not <..., time>.
 
     Examples:
         >>> import numpy as np
@@ -928,6 +998,9 @@ class Flanger(AudioTensorOperation):
         TypeError: If `interpolation` is not of type :class:`mindspore.dataset.audio.Interpolation` .
         RuntimeError: If input tensor is not in shape of <..., channel, time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -962,7 +1035,7 @@ class FrequencyMasking(AudioTensorOperation):
     Apply masking to a spectrogram in the frequency domain.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., freq, time).
+        The shape of the audio waveform to be processed needs to be <..., freq, time>.
 
     Args:
         iid_masks (bool, optional): Whether to apply different masks to each example/channel. Default: False.
@@ -1021,6 +1094,12 @@ class Gain(AudioTensorOperation):
     Args:
         gain_db (float): Gain adjustment in decibels (dB). Default: 1.0.
 
+    Raises:
+        TypeError: If `gain_db` is not of type float.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1049,8 +1128,9 @@ class GriffinLim(AudioTensorOperation):
     Args:
         n_fft (int, optional): Size of FFT. Default: 400.
         n_iter (int, optional): Number of iteration for phase recovery. Default: 32.
-        win_length (int, optional): Window size for GriffinLim. Default: None, will be set to n_fft.
-        hop_length (int, optional): Length of hop between STFT windows. Default: None, will be set to win_length // 2.
+        win_length (int, optional): Window size for GriffinLim. Default: None, will be set to `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows.
+            Default: None, will be set to `win_length // 2` .
         window_type (WindowType, optional): Window type for GriffinLim, which can be WindowType.BARTLETT,
             WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN or WindowType.KAISER. Default: WindowType.HANN.
             Currently kaiser window is not supported on macOS.
@@ -1062,9 +1142,28 @@ class GriffinLim(AudioTensorOperation):
             Default: True.
 
     Raises:
+        TypeError: If `n_fft` is not of type int.
+        ValueError: If `n_fft` is not positive.
+        TypeError: If `n_iter` is not of type int.
+        ValueError: If `n_iter` is not positive.
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is a negative number.
+        TypeError: If `hop_length` is not of type int.
+        ValueError: If `hop_length` is a negative number.
+        TypeError: If `window_type` is not of type :class:`mindspore.dataset.audio.WindowType` .
+        TypeError: If `power` is not of type float.
+        ValueError: If `power` is not positive.
+        TypeError: If `momentum` is not of type float.
+        ValueError: If `momentum` is a negative number.
+        TypeError: If `length` is not of type int.
+        ValueError: If `length` is a negative number.
+        TypeError: If `rand_init` is not of type bool.
         RuntimeError: If `n_fft` is not less than `length` .
         RuntimeError: If `win_length` is not less than `n_fft` .
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1101,12 +1200,20 @@ class HighpassBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
-        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be zero.
+        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be 0.
         cutoff_freq (float): Filter cutoff frequency (in Hz).
         Q (float, optional): Quality factor, https://en.wikipedia.org/wiki/Q_factor, range: (0, 1]. Default: 0.707.
 
     Raises:
-        RuntimeError: If the shape of input audio waveform does not match (..., time).
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is 0.
+        TypeError: If `cutoff_freq` is not of type float.
+        TypeError: If `Q` is not of type float.
+        ValueError: If `Q` is not in range of (0, 1].
+        RuntimeError: If the shape of input audio waveform does not match <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1144,9 +1251,33 @@ class InverseMelScale(AudioTensorOperation):
         sgdargs (dict, optional): Arguments for the SGD optimizer. Default: None, will be set to
             {'sgd_lr': 0.1, 'sgd_momentum': 0.9}.
         norm (NormType, optional): Normalization method, can be NormType.SLANEY or NormType.NONE.
-            Default: NormType.NONE.
+            Default: NormType.NONE, no narmalization.
         mel_type (MelType, optional): Mel scale to use, can be MelType.SLANEY or MelType.HTK. Default: MelType.HTK.
 
+    Raises:
+        TypeError: If `n_stft` is not of type int.
+        ValueError: If `n_stft` is not positive.
+        TypeError: If `n_mels` is not of type int.
+        ValueError: If `n_mels` is not positive.
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is not positive.
+        TypeError: If `f_min` is not of type float.
+        ValueError: If `f_min` is greater than or equal to `f_max` .
+        TypeError: If `f_max` is not of type float.
+        ValueError: If `f_max` is a negative number.
+        TypeError: If `max_iter` is not of type int.
+        ValueError: If `max_iter` is a negative number.
+        TypeError: If `tolerance_loss` is not of type float.
+        ValueError: If `tolerance_loss` is a negative number.
+        TypeError: If `tolerance_change` is not of type float.
+        ValueError: If `tolerance_change` is a negative number.
+        TypeError: If `sgdargs` is not of type dict.
+        TypeError: If `norm` is not of type  :class:`mindspore.dataset.audio.NormType` .
+        TypeError: If `mel_type` is not of type  :class:`mindspore.dataset.audio.MelType` .
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1181,6 +1312,177 @@ class InverseMelScale(AudioTensorOperation):
                                             DE_C_NORM_TYPE.get(self.norm), DE_C_MEL_TYPE.get(self.mel_type))
 
 
+class InverseSpectrogram(AudioTensorOperation):
+    """
+    Create an inverse spectrogram to recover an audio signal from a spectrogram.
+
+    Args:
+        length (int, optional): The output length of the waveform, must be non negative. Default: None,
+            means to output the whole waveform.
+        n_fft (int, optional): Size of FFT, creates `n_fft // 2 + 1` bins, which should be greater than 0.
+            Default: 400.
+        win_length (int, optional): Window size, which should be greater than 0.
+            Default: None, will be set to `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows, which should be greater than 0.
+            Default: None, will be set to `win_length // 2` .
+        pad (int, optional): Two sided padding of signal, cannot be less than 0. Default: 0.
+        window (WindowType, optional): A function to create a window tensor that is applied/multiplied to each
+            frame/window. Default: WindowType.HANN.
+        normalized (bool, optional): Whether the spectrogram was normalized by magnitude after stft. Default: False.
+        center (bool, optional): Whether the signal in spectrogram was padded on both sides. Default: True.
+        pad_mode (BorderType, optional): Controls the padding method used when `center` is True,
+            can be BorderType.REFLECT, BorderType.CONSTANT, BorderType.EDGE or BorderType.SYMMETRIC.
+            Default: BorderType.REFLECT.
+        onesided (bool, optional): Controls whether spectrogram was used to return half of results to avoid
+            redundancy. Default: True.
+
+    Raises:
+        TypeError: If `length` is not of type int.
+        ValueError: If `length` is a negative number.
+        TypeError: If `n_fft` is not of type int.
+        ValueError: If `n_fft` is not positive.
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is not positive.
+        TypeError: If `hop_length` is not of type int.
+        ValueError: If `hop_length` is not positive.
+        TypeError: If `pad` is not of type int.
+        ValueError: If `pad` is a negative number.
+        TypeError: If `window` is not of type :class:`mindspore.dataset.audio.WindowType` .
+        TypeError: If `normalized` is not of type bool.
+        TypeError: If `center` is not of type bool.
+        TypeError: If `pad_mode` is not of type :class:`mindspore.dataset.audio.BorderType` .
+        TypeError: If `onesided` is not of type bool.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>>
+        >>> waveform = np.array([[[0.8236, 0.2049, 0.3335], [0.5933, 0.9911, 0.2482],
+        ...                      [0.3007, 0.9054, 0.7598], [0.5394, 0.2842, 0.5634], [0.6363, 0.2226, 0.2288]]])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
+        >>> transforms = [audio.InverseSpectrogram(1, 400, 400, 200)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+    """
+
+    @check_inverse_spectrogram
+    def __init__(self, length=None, n_fft=400, win_length=None, hop_length=None, pad=0,
+                 window=WindowType.HANN, normalized=False, center=True,
+                 pad_mode=BorderType.REFLECT, onesided=True):
+        super().__init__()
+        self.length = length if length is not None else 0
+        self.n_fft = n_fft
+        self.win_length = win_length if win_length is not None else n_fft
+        self.hop_length = hop_length if hop_length is not None else self.win_length // 2
+        self.pad = pad
+        self.window = window
+        self.normalized = normalized
+        self.center = center
+        self.pad_mode = pad_mode
+        self.onesided = onesided
+
+    def parse(self):
+        return cde.InverseSpectrogramOperation(self.length, self.n_fft, self.win_length, self.hop_length, self.pad,
+                                               DE_C_WINDOW_TYPE.get(self.window), self.normalized, self.center,
+                                               DE_C_BORDER_TYPE.get(self.pad_mode), self.onesided)
+
+
+DE_C_NORM_MODE = {NormMode.ORTHO: cde.NormMode.DE_NORM_MODE_ORTHO,
+                  NormMode.NONE: cde.NormMode.DE_NORM_MODE_NONE}
+
+
+class LFCC(AudioTensorOperation):
+    """
+    Create LFCC for a raw audio signal.
+
+    Note:
+        The shape of the audio waveform to be processed needs to be <..., time>.
+
+    Args:
+        sample_rate (int, optional): Sample rate of audio signal. Default: 16000.
+        n_filter (int, optional) : Number of linear filters to apply. Default: 128.
+        n_lfcc (int, optional) : Number of lfc coefficients to retain. Default: 40.
+        f_min (float, optional): Minimum frequency. Default: 0.0.
+        f_max (float, optional): Maximum frequency. Default: None, will be set to `sample_rate // 2` .
+        dct_type (int, optional) : Type of DCT to use. The value can only be 2. Default: 2.
+        norm (NormMode, optional) : Norm to use. Default: NormMode.ORTHO.
+        log_lf (bool, optional) : Whether to use log-lf spectrograms instead of db-scaled. Default: False.
+        speckwargs (dict, optional) : Arguments for :class:`mindspore.dataset.audio.Spectrogram`.
+            Default: None, the default setting is a dict including
+
+            - 'n_fft': 400
+            - 'win_length': n_fft
+            - 'hop_length': win_length // 2
+            - 'pad': 0
+            - 'window': WindowType.HANN
+            - 'power': 2.0
+            - 'normalized': False
+            - 'center': True
+            - 'pad_mode': BorderType.REFLECT
+            - 'onesided': True
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        TypeError: If `n_filter` is not of type int.
+        TypeError: If `n_lfcc` is not of type int.
+        TypeError: If `norm` is not of type :class:`mindspore.dataset.audio.NormMode` .
+        TypeError: If `log_lf` is not of type bool.
+        TypeError: If `speckwargs` is not of type dict.
+        ValueError: If `sample_rate` is 0.
+        ValueError: If `n_lfcc` is less than 0.
+        ValueError: If `f_min` is greater than `f_max` .
+        ValueError: If `f_min` is greater than `sample_rate // 2` when `f_max` is set to None.
+        ValueError: If `dct_type` is not 2.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
+        >>>
+        >>> waveform = np.random.random([1, 1, 300])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
+        >>> transforms = [audio.LFCC()]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+    """
+
+    @check_lfcc
+    def __init__(self, sample_rate=16000, n_filter=128, n_lfcc=40, f_min=0.0, f_max=None, dct_type=2,
+                 norm=NormMode.ORTHO, log_lf=False, speckwargs=None):
+        super().__init__()
+        self.sample_rate = sample_rate
+        self.n_filter = n_filter
+        self.n_lfcc = n_lfcc
+        self.f_min = f_min
+        self.f_max = f_max if f_max is not None else sample_rate // 2
+        self.dct_type = dct_type
+        self.norm = norm
+        self.log_lf = log_lf
+        self.speckwargs = speckwargs
+        if speckwargs is None:
+            self.speckwargs = {}
+        self.speckwargs.setdefault("n_fft", 400)
+        self.speckwargs.setdefault("win_length", self.speckwargs.get("n_fft"))
+        self.speckwargs.setdefault("hop_length", self.speckwargs.get("win_length") // 2)
+        self.speckwargs.setdefault("pad", 0)
+        self.speckwargs.setdefault("window", WindowType.HANN)
+        self.speckwargs.setdefault("power", 2.0)
+        self.speckwargs.setdefault("normalized", False)
+        self.speckwargs.setdefault("center", True)
+        self.speckwargs.setdefault("pad_mode", BorderType.REFLECT)
+        self.speckwargs.setdefault("onesided", True)
+        self.window = self.speckwargs.get("window")
+        self.pad_mode = self.speckwargs.get("pad_mode")
+
+    def parse(self):
+        return cde.LFCCOperation(self.sample_rate, self.n_filter, self.n_lfcc, self.f_min, self.f_max,
+                                 self.dct_type, DE_C_NORM_MODE.get(self.norm), self.log_lf, self.speckwargs,
+                                 DE_C_WINDOW_TYPE.get(self.window), DE_C_BORDER_TYPE.get(self.pad_mode))
+
+
 class LFilter(AudioTensorOperation):
     """
     Perform an IIR filter by evaluating different equation.
@@ -1201,6 +1503,9 @@ class LFilter(AudioTensorOperation):
         TypeError: If `clamp` is not of type bool.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1236,7 +1541,7 @@ class LowpassBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., time).
+        The shape of the audio waveform to be processed needs to be <..., time>.
 
     Args:
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
@@ -1286,6 +1591,9 @@ class Magphase(AudioTensorOperation):
     Raises:
         RuntimeError: If the shape of input audio waveform does not match (..., 2).
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1319,6 +1627,9 @@ class MaskAlongAxis(AudioTensorOperation):
         ValueError: If `mask_width` is invalid (< 1).
         ValueError: If `axis` is not type of int or not within [1, 2].
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1361,6 +1672,9 @@ class MaskAlongAxisIID(AudioTensorOperation):
         ValueError: If `axis` is not in range of [1, 2].
         RuntimeError: If input tensor is not in shape of <..., freq, time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1400,9 +1714,26 @@ class MelScale(AudioTensorOperation):
         n_stft (int, optional): Number of bins in STFT. Default: 201.
         norm (NormType, optional): Type of norm, value should be NormType.SLANEY or NormType::NONE.
             If norm is NormType.SLANEY, divide the triangular mel weight by the width of the mel band.
-            Default: NormType.NONE.
+            Default: NormType.NONE, no narmalization.
         mel_type (MelType, optional): Type to use, value should be MelType.SLANEY or MelType.HTK. Default: MelType.HTK.
 
+    Raises:
+        TypeError: If `n_mels` is not of type int.
+        ValueError: If `n_mels` is not positive.
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is not positive.
+        TypeError: If `f_min` is not of type float.
+        ValueError: If `f_min` is greater than or equal to `f_max` .
+        TypeError: If `f_max` is not of type float.
+        ValueError: If `f_max` is a negative number.
+        TypeError: If `n_stft` is not of type int.
+        ValueError: If `n_stft` is not positive.
+        TypeError: If `norm` is not of type  :class:`mindspore.dataset.audio.NormType` .
+        TypeError: If `mel_type` is not of type  :class:`mindspore.dataset.audio.MelType` .
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1430,6 +1761,201 @@ class MelScale(AudioTensorOperation):
                                      DE_C_NORM_TYPE.get(self.norm), DE_C_MEL_TYPE.get(self.mel_type))
 
 
+class MelSpectrogram(AudioTensorOperation):
+    r"""
+    Create MelSpectrogram for a raw audio signal.
+
+    Args:
+        sample_rate (int, optional): Sampling rate of audio signal (in Hz), which can't be less than 0. Default: 16000.
+        n_fft (int, optional): Size of FFT, creates `n_fft // 2 + 1` bins, which should be greater than 0 and less than
+            twice of the last dimension size of the input. Default: 400.
+        win_length (int, optional): Window size, which should be greater than 0 and no more than `n_fft` . Default:
+            None, will be set to `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows, which should be greater than 0.
+            Default: None, will be set to `win_length // 2` .
+        f_min (float, optional): Minimum frequency, which can't be greater than `f_max` . Default: 0.0.
+        f_max (float, optional): Maximum frequency, which can't be less than 0. Default: None, will be set
+            to `sample_rate // 2` .
+        pad (int, optional): Two sided padding of signal, which can't be less than 0. Default: 0.
+        n_mels (int, optional): Number of mel filterbanks, which can't be less than 0. Default: 128.
+        window (WindowType, optional): A function to create a window tensor that is applied/multiplied to each
+            frame/window. Default: WindowType.HANN.
+        power (float, optional): Exponent for the magnitude spectrogram, which must be
+            greater than 0, e.g., 1 for energy, 2 for power, etc. Default: 2.0.
+        normalized (bool, optional): Whether to normalize by magnitude after stft. Default: False.
+        center (bool, optional): Whether to pad waveform on both sides. Default: True.
+        pad_mode (BorderType, optional): Controls the padding method used when `center` is True,
+            can be BorderType.REFLECT, BorderType.CONSTANT, BorderType.EDGE or BorderType.SYMMETRIC.
+            Default: BorderType.REFLECT.
+        onesided (bool, optional): Controls whether to return half of results to avoid redundancy. Default: True.
+        norm (NormType, optional): If 'slaney', divide the triangular mel weights by the width of the mel band
+            (area normalization). Default: NormType.NONE, no narmalization.
+        mel_scale (MelType, optional): Mel scale to use, can be MelType.SLANEY or MelType.HTK. Default: MelType.HTK.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        TypeError: If `n_fft` is not of type int.
+        TypeError: If `n_mels` is not of type int.
+        TypeError: If `f_min` is not of type float.
+        TypeError: If `f_max` is not of type float.
+        TypeError: If `window` is not of type :class:`mindspore.dataset.audio.WindowType` .
+        TypeError: If `norm` is not of type :class:`mindspore.dataset.audio.NormType` .
+        TypeError: If `mel_scale` is not of type :class:`mindspore.dataset.audio.MelType` .
+        TypeError: If `power` is not of type float.
+        TypeError: If `normalized` is not of type bool.
+        TypeError: If `center` is not of type bool.
+        TypeError: If `pad_mode` is not of type :class:`mindspore.dataset.audio.BorderType` .
+        TypeError: If `onesided` is not of type bool.
+        TypeError: If `pad` is not of type int.
+        TypeError: If `win_length` is not of type int.
+        TypeError: If `hop_length` is not of type int.
+        ValueError: If `sample_rate` is a negative number.
+        ValueError: If `n_fft` is not positive.
+        ValueError: If `n_mels` is a negative number.
+        ValueError: If `f_min` is greater than `f_max` .
+        ValueError: If `f_max` is a negative number.
+        ValueError: If `f_min` is not less than `sample_rate // 2` when `f_max` is set to None.
+        ValueError: If `power` is not positive.
+        ValueError: If `pad` is a negative number.
+        ValueError: If `win_length` is not positive.
+        ValueError: If `hop_length` is not positive.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>>
+        >>> from mindspore.dataset.audio import WindowType, BorderType, NormType, MelType
+        >>>
+        >>> waveform = np.array([[[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4]]])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
+        >>> transforms = [audio.MelSpectrogram(sample_rate=16000, n_fft=16, win_length=16, hop_length=8, f_min=0.0, \
+        ...                                    f_max=5000.0, pad=0, n_mels=8, window=WindowType.HANN, power=2.0, \
+        ...                                    normalized=False, center=True, pad_mode=BorderType.REFLECT, \
+        ...                                    onesided=True, norm=NormType.SLANEY,  mel_scale=MelType.HTK)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+    """
+
+    @check_mel_spectrogram
+    def __init__(self, sample_rate=16000, n_fft=400, win_length=None, hop_length=None, f_min=0.0, f_max=None, pad=0,
+                 n_mels=128, window=WindowType.HANN, power=2.0, normalized=False, center=True,
+                 pad_mode=BorderType.REFLECT, onesided=True, norm=NormType.NONE, mel_scale=MelType.HTK):
+        super().__init__()
+        self.sample_rate = sample_rate
+        self.n_fft = n_fft
+        self.win_length = win_length if win_length is not None else n_fft
+        self.hop_length = hop_length if hop_length is not None else self.win_length // 2
+        self.f_min = f_min
+        self.f_max = f_max if f_max is not None else sample_rate // 2
+        self.pad = pad
+        self.n_mels = n_mels
+        self.window = window
+        self.power = power
+        self.normalized = normalized
+        self.center = center
+        self.pad_mode = pad_mode
+        self.onesided = onesided
+        self.norm = norm
+        self.mel_scale = mel_scale
+
+    def parse(self):
+        return cde.MelSpectrogramOperation(self.sample_rate, self.n_fft, self.win_length, self.hop_length, self.f_min,
+                                           self.f_max, self.pad, self.n_mels, DE_C_WINDOW_TYPE.get(self.window),
+                                           self.power, self.normalized, self.center,
+                                           DE_C_BORDER_TYPE.get(self.pad_mode), self.onesided,
+                                           DE_C_NORM_TYPE.get(self.norm), DE_C_MEL_TYPE.get(self.mel_scale))
+
+
+class MFCC(AudioTensorOperation):
+    """
+    Create MFCC for a raw audio signal.
+
+    Args:
+        sample_rate (int, optional): Sampling rate of audio signal (in Hz), can't be less than 0. Default: 16000.
+        n_mfcc (int, optional): Number of mfc coefficients to retain, can't be less than 0. Default: 40.
+        dct_type (int, optional): Type of DCT (discrete cosine transform) to use, can only be 2. Default: 2.
+        norm (NormMode, optional): Norm to use. Default: NormMode.ORTHO.
+        log_mels (bool, optional): Whether to use log-mel spectrograms instead of db-scaled. Default: False.
+        melkwargs (dict, optional): Arguments for :class:`mindspore.dataset.audio.MelSpectrogram`.
+            Default: None, the default setting is a dict including
+
+            - 'n_fft': 400
+            - 'win_length': n_fft
+            - 'hop_length': win_length // 2
+            - 'f_min': 0.0
+            - 'f_max': sample_rate // 2
+            - 'pad': 0
+            - 'window': WindowType.HANN
+            - 'power': 2.0
+            - 'normalized': False
+            - 'center': True
+            - 'pad_mode': BorderType.REFLECT
+            - 'onesided': True
+            - 'norm': NormType.NONE
+            - 'mel_scale': MelType.HTK
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        TypeError: If `log_mels` is not of type bool.
+        TypeError: If `norm` is not of type :class:`mindspore.dataset.audio.NormMode` .
+        TypeError: If `n_mfcc` is not of type int.
+        TypeError: If `melkwargs` is not of type dict.
+        ValueError: If `sample_rate` is a negative number.
+        ValueError: If `n_mfcc` is a negative number.
+        ValueError: If `dct_type` is not 2.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>>
+        >>> waveform = np.array([[0.8236, 0.2049, 0.3335], [0.5933, 0.9911, 0.2482],
+        ...                      [0.3007, 0.9054, 0.7598], [0.5394, 0.2842, 0.5634], [0.6363, 0.2226, 0.2288]])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
+        >>> transforms = [audio.MFCC(4000, 1500, 2)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+    """
+
+    @check_mfcc
+    def __init__(self, sample_rate=16000, n_mfcc=40, dct_type=2, norm=NormMode.ORTHO, log_mels=False, melkwargs=None):
+        super().__init__()
+        self.sample_rate = sample_rate
+        self.n_mfcc = n_mfcc
+        self.dct_type = dct_type
+        self.norm = norm
+        self.log_mels = log_mels
+        self.melkwargs = melkwargs
+        if melkwargs is None:
+            self.melkwargs = {}
+        self.melkwargs.setdefault("n_fft", 400)
+        self.melkwargs.setdefault("win_length", self.melkwargs.get("n_fft"))
+        self.melkwargs.setdefault("hop_length", self.melkwargs.get("win_length") // 2)
+        self.melkwargs.setdefault("f_min", 0.0)
+        self.melkwargs.setdefault("f_max", sample_rate // 2)
+        self.melkwargs.setdefault("pad", 0)
+        self.melkwargs.setdefault("n_mels", 128)
+        self.melkwargs.setdefault("window", WindowType.HANN)
+        self.melkwargs.setdefault("power", 2.0)
+        self.melkwargs.setdefault("normalized", False)
+        self.melkwargs.setdefault("center", True)
+        self.melkwargs.setdefault("pad_mode", BorderType.REFLECT)
+        self.melkwargs.setdefault("onesided", True)
+        self.melkwargs.setdefault("norm", NormType.NONE)
+        self.melkwargs.setdefault("mel_scale", MelType.HTK)
+        self.window = self.melkwargs.get("window")
+        self.pad_mode = self.melkwargs.get("pad_mode")
+        self.norm_mel = self.melkwargs.get("norm")
+        self.mel_scale = self.melkwargs.get("mel_scale")
+
+    def parse(self):
+        return cde.MFCCOperation(self.sample_rate, self.n_mfcc, self.dct_type, DE_C_NORM_MODE.get(self.norm),
+                                 self.log_mels, self.melkwargs, DE_C_WINDOW_TYPE.get(self.window),
+                                 DE_C_BORDER_TYPE.get(self.pad_mode), DE_C_NORM_TYPE.get(self.norm_mel),
+                                 DE_C_MEL_TYPE.get(self.mel_scale))
+
+
 class MuLawDecoding(AudioTensorOperation):
     """
     Decode mu-law encoded signal, refer to `mu-law algorithm <https://en.wikipedia.org/wiki/M-law_algorithm>`_ .
@@ -1470,6 +1996,13 @@ class MuLawEncoding(AudioTensorOperation):
     Args:
         quantization_channels (int, optional): Number of channels, which must be positive. Default: 256.
 
+    Raises:
+        TypeError: If `quantization_channels` is not of type int.
+        ValueError: If `quantization_channels` is not a positive number.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1506,6 +2039,9 @@ class Overdrive(AudioTensorOperation):
         ValueError: If `color` is not in range of [0, 100].
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1558,6 +2094,9 @@ class Phaser(AudioTensorOperation):
         TypeError: If `sinusoidal` is not of type bool.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1598,6 +2137,9 @@ class PhaseVocoder(AudioTensorOperation):
         TypeError: If `phase_advance` is not of type :class:`numpy.ndarray` .
         RuntimeError: If input tensor is not in shape of <..., freq, num_frame, complex=2>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1618,6 +2160,68 @@ class PhaseVocoder(AudioTensorOperation):
         return cde.PhaseVocoderOperation(self.rate, self.phase_advance)
 
 
+class PitchShift(AudioTensorOperation):
+    """
+    Shift the pitch of a waveform by `n_steps` steps.
+
+    Args:
+        sample_rate (int): Sampling rate of waveform (in Hz).
+        n_steps (int): The steps to shift waveform.
+        bins_per_octave (int, optional): The number of steps per octave. Default: 12.
+        n_fft (int, optional): Size of FFT, creates `n_fft // 2 + 1` bins. Default: 512.
+        win_length (int, optional): Window size. Default: None, will be set to `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows. Default: None,
+            will be set to `win_length // 4` .
+        window (WindowType, optional): Window tensor that is applied/multiplied to each frame/window.
+            Default: WindowType.HANN.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        TypeError: If `n_steps` is not of type int.
+        TypeError: If `bins_per_octave` is not of type int.
+        TypeError: If `n_fft` is not of type int.
+        TypeError: If `win_length` is not of type int.
+        TypeError: If `hop_length` is not of type int.
+        TypeError: If `window` is not of type :class:`mindspore.dataset.audio.WindowType` .
+        ValueError: If `sample_rate` is a negative number.
+        ValueError: If `bins_per_octave` is 0.
+        ValueError: If `n_fft` is a negative number.
+        ValueError: If `win_length` is not positive.
+        ValueError: If `hop_length` is not positive.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>>
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
+        >>> from mindspore.dataset.audio import WindowType
+        >>>
+        >>> waveform = np.random.random([1, 1, 300])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
+        >>> transforms = [audio.PitchShift(sample_rate=16000,n_steps=4)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+    """
+
+    @check_pitch_shift
+    def __init__(self, sample_rate, n_steps, bins_per_octave=12, n_fft=512, win_length=None,
+                 hop_length=None, window=WindowType.HANN):
+        super().__init__()
+        self.sample_rate = sample_rate
+        self.n_steps = n_steps
+        self.bins_per_octave = bins_per_octave
+        self.n_fft = n_fft
+        self.win_length = win_length if win_length is not None else n_fft
+        self.hop_length = hop_length if hop_length is not None else self.win_length // 4
+        self.window = window
+
+    def parse(self):
+        return cde.PitchShiftOperation(self.sample_rate, self.n_steps, self.bins_per_octave, self.n_fft,
+                                       self.win_length, self.hop_length, DE_C_WINDOW_TYPE.get(self.window))
+
+
 DE_C_RESAMPLE_METHOD = {ResampleMethod.SINC_INTERPOLATION: cde.ResampleMethod.DE_RESAMPLE_SINC_INTERPOLATION,
                         ResampleMethod.KAISER_WINDOW: cde.ResampleMethod.DE_RESAMPLE_KAISER_WINDOW}
 
@@ -1649,6 +2253,9 @@ class Resample(AudioTensorOperation):
         ValueError: If `rolloff` is not in range of (0, 1].
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>> from mindspore.dataset.audio import ResampleMethod
@@ -1688,6 +2295,13 @@ class RiaaBiquad(AudioTensorOperation):
         sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz),
             can only be one of 44100, 48000, 88200, 96000.
 
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is not any of [44100, 48000, 88200, 96000].
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1718,6 +2332,17 @@ class SlidingWindowCmn(AudioTensorOperation):
             to the left. Default: False.
         norm_vars (bool, optional): If True, normalize variance to one. Default: False.
 
+    Raises:
+        TypeError: If `cmn_window` is not of type int.
+        ValueError: If `cmn_window` is a negative number.
+        TypeError: If `min_cmn_window` is not of type int.
+        ValueError: If `min_cmn_window` is a negative number.
+        TypeError: If `center` is not of type bool.
+        TypeError: If `norm_vars` is not of type bool.
+
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1775,6 +2400,9 @@ class SpectralCentroid(TensorOperation):
         TypeError: If `window` is not of type :class:`mindspore.dataset.audio.WindowType` .
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1839,6 +2467,9 @@ class Spectrogram(TensorOperation):
         TypeError: If `onesided` is not of type bool.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -1874,7 +2505,7 @@ class TimeMasking(AudioTensorOperation):
     Apply masking to a spectrogram in the time domain.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., freq, time).
+        The shape of the audio waveform to be processed needs to be <..., freq, time>.
 
     Args:
         iid_masks (bool, optional): Whether to apply different masks to each example/channel. Default: False.
@@ -1930,7 +2561,7 @@ class TimeStretch(AudioTensorOperation):
     Stretch Short Time Fourier Transform (STFT) in time without modifying pitch for a given rate.
 
     Note:
-        The dimension of the audio waveform to be processed needs to be (..., freq, time, complex=2).
+        The shape of the audio waveform to be processed needs to be <..., freq, time, complex=2>.
         The first dimension represents the real part while the second represents the imaginary.
 
     Args:
@@ -2003,6 +2634,9 @@ class TrebleBiquad(AudioTensorOperation):
         ValueError: If `Q` is not in range of (0, 1].
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -2100,6 +2734,9 @@ class Vad(AudioTensorOperation):
         ValueError: If `lp_lifter_freq` is not a positive number.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>>
@@ -2165,6 +2802,9 @@ class Vol(AudioTensorOperation):
         ValueError: If `gain` is not a positive number when `gain_type` is GainType.POWER.
         RuntimeError: If input tensor is not in shape of <..., time>.
 
+    Supported Platforms:
+        ``CPU``
+
     Examples:
         >>> import numpy as np
         >>> from mindspore.dataset.audio import GainType