mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-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.
@@ -77,7 +78,7 @@ class AllpassBiquad(AudioTensorOperation):
             in range of (0, 1]. Default: 0.707.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        TypeError: If `sample_rate` is not of type int.
         ValueError: If `sample_rate` is 0.
         TypeError: If `central_freq` is not of type float.
         TypeError: If `Q` is not of type float.
@@ -116,22 +117,22 @@ 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
             ScaleType.POWER or ScaleType.MAGNITUDE. Default: ScaleType.POWER.
         ref_value (float, optional): Multiplier reference value for generating
-            `db_multiplier`. Default: 1.0. The formula is
+            `db_multiplier` . Default: 1.0. The formula is
 
-            :math:`\text{db_multiplier} = Log10(max(\text{ref_value}, amin))`.
+            :math:`\text{db_multiplier} = Log10(max(\text{ref_value}, amin))` .
 
         amin (float, optional): Lower bound to clamp the input waveform, which must
             be greater than zero. Default: 1e-10.
         top_db (float, optional): Minimum cut-off decibels, which must be non-negative. Default: 80.0.
 
     Raises:
-        TypeError: If `stype` is not of type :class:`mindspore.dataset.audio.utils.ScaleType`.
+        TypeError: If `stype` is not of type :class:`mindspore.dataset.audio.ScaleType` .
         TypeError: If `ref_value` is not of type float.
         ValueError: If `ref_value` is not a positive number.
         TypeError: If `amin` is not of type float.
@@ -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.
@@ -214,7 +215,7 @@ class BandBiquad(AudioTensorOperation):
             If False, uses mode oriented to pitched audio, i.e. voice, singing, or instrumental music. Default: False.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        TypeError: If `sample_rate` is not of type int.
         ValueError: If `sample_rate` is 0.
         TypeError: If `central_freq` is not of type float.
         TypeError: If `Q` is not of type float.
@@ -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.
@@ -275,7 +276,7 @@ class BandpassBiquad(AudioTensorOperation):
             If False, uses a constant 0dB peak gain. Default: False.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        TypeError: If `sample_rate` is not of type int.
         ValueError: If `sample_rate` is 0.
         TypeError: If `central_freq` is not of type float.
         TypeError: If `Q` is not of type float.
@@ -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.
@@ -332,7 +333,7 @@ class BandrejectBiquad(AudioTensorOperation):
             in range of (0, 1]. Default: 0.707.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        TypeError: If `sample_rate` is not of type int.
         ValueError: If `sample_rate` is 0.
         TypeError: If `central_freq` is not of type float.
         TypeError: If `Q` is not of type float.
@@ -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.
@@ -385,7 +386,7 @@ class BassBiquad(AudioTensorOperation):
             in range of (0, 1]. Default: 0.707.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        TypeError: If `sample_rate` is not of type int.
         ValueError: If `sample_rate` is 0.
         TypeError: If `gain` is not of type float.
         TypeError: If `central_freq` is not of type float.
@@ -420,15 +421,28 @@ class BassBiquad(AudioTensorOperation):
 class Biquad(TensorOperation):
     """
     Perform a biquad filter of input audio.
+    Mathematical fomulas refer to: `Digital_biquad_filter <https://en.wikipedia.org/wiki/Digital_biquad_filter>`_ .
 
     Args:
         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
         >>>
@@ -456,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:
@@ -498,25 +512,37 @@ DE_C_BORDER_TYPE = {
 
 class ComputeDeltas(AudioTensorOperation):
     r"""
-    Compute delta coefficients of a spectrogram.
+    Compute delta coefficients, also known as differential coefficients, of a spectrogram.
+
+    Delta coefficients help to understand the dynamics of the power spectrum. It can be
+    computed using the following formula.
 
     .. math::
         d_{t}=\frac{{\textstyle\sum_{n=1}^{N}}n(c_{t+n}-c_{t-n})}{2{\textstyle\sum_{n=1}^{N}}n^{2}}
 
-    Args:
-        win_length (int, optional): The window length used for computing delta, must be no less than 3 (default=5).
-        pad_mode (BorderType, optional): Mode parameter passed to padding (default=BorderType.EDGE).It can be any of
-            [BorderType.CONSTANT, BorderType.EDGE, BorderType.REFLECT, BordBorderTypeer.SYMMETRIC].
+    where :math:`d_{t}` is the deltas at time :math:`t` , :math:`c_{t}` is the spectrogram coefficients
+    at time :math:`t` , :math:`N` is :math:`(\text{win_length} - 1) // 2` .
 
-            - BorderType.CONSTANT, means it fills the border with constant values.
+    Args:
+        win_length (int, optional): The window length used for computing delta, must be no less than 3. Default: 5.
+        pad_mode (BorderType, optional): Mode parameter passed to padding, can be BorderType.CONSTANT, BorderType.EDGE,
+            BorderType.REFLECT or BorderType.SYMMETRIC. Default: BorderType.EDGE.
 
-            - BorderType.EDGE, means it pads with the last value on the edge.
+            - BorderType.CONSTANT, pad with a constant value.
+            - BorderType.EDGE, pad with the last value on the edge.
+            - BorderType.REFLECT, reflect the value on the edge while omitting the last one.
+              For example, pad [1, 2, 3, 4] with 2 elements on both sides will result in [3, 2, 1, 2, 3, 4, 3, 2].
+            - BorderType.SYMMETRIC, reflect the value on the edge while repeating the last one.
+              For example, pad [1, 2, 3, 4] with 2 elements on both sides will result in [2, 1, 1, 2, 3, 4, 4, 3].
 
-            - BorderType.REFLECT, means it reflects the values on the edge omitting the last
-              value of edge.
+    Raises:
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is less than 3.
+        TypeError: If `pad_mode` is not of type :class:`mindspore.dataset.audio.BorderType` .
+        RuntimeError: If input tensor is not in shape of <..., freq, time>.
 
-            - BorderType.SYMMETRIC, means it reflects the values on the edge repeating the last
-              value of edge.
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -546,9 +572,8 @@ 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,
@@ -589,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
         >>>
@@ -610,12 +642,20 @@ class DBToAmplitude(AudioTensorOperation):
 
 class DCShift(AudioTensorOperation):
     """
-    Apply a DC shift to the audio.
+    Apply a DC shift to the audio. This can be useful to remove DC offset from audio.
 
     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
@@ -638,11 +678,20 @@ class DCShift(AudioTensorOperation):
 
 class DeemphBiquad(AudioTensorOperation):
     """
-    Design two-pole deemph filter for audio waveform of dimension of (..., time).
+    Apply Compact Disc (IEC 60908) de-emphasis (a treble attenuation shelving filter) to the audio waveform.
+
+    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 must be 44100 or 48000.
+        sample_rate (int): Sampling rate of the waveform, must be 44100 or 48000 (Hz).
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        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
@@ -670,13 +719,28 @@ class DetectPitchFrequency(AudioTensorOperation):
 
     Args:
         sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be zero.
-        frame_time (float, optional): Duration of a frame, the value must be greater than zero (default=0.01).
+        frame_time (float, optional): Duration of a frame, the value must be greater than zero. Default: 0.01.
         win_length (int, optional): The window length for median smoothing (in number of frames), the value must be
-            greater than zero (default=30).
-        freq_low (int, optional): Lowest frequency that can be detected (Hz), the value must be greater than zero
-            (default=85).
-        freq_high (int, optional): Highest frequency that can be detected (Hz), the value must be greater than zero
-            (default=3400).
+            greater than zero. Default: 30.
+        freq_low (int, optional): Lowest frequency that can be detected (Hz), the value must be greater than zero.
+            Default: 85.
+        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
@@ -714,12 +778,20 @@ class Dither(AudioTensorOperation):
 
     Args:
         density_function (DensityFunction, optional): The density function of a continuous
-            random variable. Can be one of DensityFunction.TPDF (Triangular Probability Density Function),
+            random variable, can be DensityFunction.TPDF (Triangular Probability Density Function),
             DensityFunction.RPDF (Rectangular Probability Density Function) or
-            DensityFunction.GPDF (Gaussian Probability Density Function)
-            (default=DensityFunction.TPDF).
+            DensityFunction.GPDF (Gaussian Probability Density Function).
+            Default: DensityFunction.TPDF.
         noise_shaping (bool, optional): A filtering process that shapes the spectral
-            energy of quantisation error (default=False).
+            energy of quantisation error. Default: False.
+
+    Raises:
+        TypeError: If `density_function` is not of type :class:`mindspore.dataset.audio.DensityFunction` .
+        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
@@ -742,13 +814,26 @@ class Dither(AudioTensorOperation):
 
 class EqualizerBiquad(AudioTensorOperation):
     """
-    Design biquad equalizer filter and perform filtering. Similar to SoX implementation.
+    Design biquad equalizer filter and perform filtering.
+
+    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).
+        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
@@ -783,11 +868,10 @@ class Fade(AudioTensorOperation):
     Add a fade in and/or fade out to an waveform.
 
     Args:
-        fade_in_len (int, optional): Length of fade-in (time frames), which must be non-negative (default=0).
-        fade_out_len (int, optional): Length of fade-out (time frames), which must be non-negative (default=0).
-        fade_shape (FadeShape, optional): Shape of fade (default=FadeShape.LINEAR). Can be one of
-            FadeShape.QUARTER_SINE, FadeShape.HALF_SINE, FadeShape.LINEAR, FadeShape.LOGARITHMIC or
-            FadeShape.EXPONENTIAL.
+        fade_in_len (int, optional): Length of fade-in (time frames), which must be non-negative. Default: 0.
+        fade_out_len (int, optional): Length of fade-out (time frames), which must be non-negative. Default: 0.
+        fade_shape (FadeShape, optional): Shape of fade, five different types can be chosen as defined in FadeShape.
+            Default: FadeShape.LINEAR.
 
             -FadeShape.QUARTER_SINE, means it tend to 0 in an quarter sin function.
 
@@ -803,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
@@ -829,13 +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.
+        clamp (bool, optional): If True, clamp the output signal to be in the range [-1, 1]. Default: True.
+
+    Raises:
+        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
@@ -870,18 +964,42 @@ class Flanger(AudioTensorOperation):
     """
     Apply a flanger effect to the audio.
 
+    Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
+
     Args:
         sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz).
-        delay (float, optional): Desired delay in milliseconds (ms), range: [0, 30] (default=0.0).
-        depth (float, optional): Desired delay depth in milliseconds (ms), range: [0, 10] (default=2.0).
-        regen (float, optional): Desired regen (feedback gain) in dB, range: [-95, 95] (default=0.0).
-        width (float, optional): Desired width (delay gain) in dB, range: [0, 100] (default=71.0).
-        speed (float, optional): Modulation speed in Hz, range: [0.1, 10] (default=0.5).
-        phase (float, optional): Percentage phase-shift for multi-channel, range: [0, 100] (default=25.0).
-        modulation (Modulation, optional): Modulation of the input tensor (default=Modulation.SINUSOIDAL).
-            It can be one of Modulation.SINUSOIDAL or Modulation.TRIANGULAR.
-        interpolation (Interpolation, optional): Interpolation of the input tensor (default=Interpolation.LINEAR).
-            It can be one of Interpolation.LINEAR or Interpolation.QUADRATIC.
+        delay (float, optional): Desired delay in milliseconds, in range of [0, 30]. Default: 0.0.
+        depth (float, optional): Desired delay depth in milliseconds, in range of [0, 10]. Default: 2.0.
+        regen (float, optional): Desired regen (feedback gain) in dB, in range of [-95, 95]. Default: 0.0.
+        width (float, optional): Desired width (delay gain) in dB, in range of [0, 100]. Default: 71.0.
+        speed (float, optional): Modulation speed in Hz, in range of [0.1, 10]. Default: 0.5.
+        phase (float, optional): Percentage phase-shift for multi-channel, in range of [0, 100]. Default: 25.0.
+        modulation (Modulation, optional): Modulation method, can be Modulation.SINUSOIDAL or Modulation.TRIANGULAR.
+            Default: Modulation.SINUSOIDAL.
+        interpolation (Interpolation, optional): Interpolation method, can be Interpolation.LINEAR or
+            Interpolation.QUADRATIC. Default: Interpolation.LINEAR.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is zero.
+        TypeError: If `delay` is not of type float.
+        ValueError: If `delay` is not in range of [0, 30].
+        TypeError: If `depth` is not of type float.
+        ValueError: If `depth` is not in range of [0, 10].
+        TypeError: If `regen` is not of type float.
+        ValueError: If `regen` is not in range of [-95, 95].
+        TypeError: If `width` is not of type float.
+        ValueError: If `width` is not in range of [0, 100].
+        TypeError: If `speed` is not of type float.
+        ValueError: If `speed` is not in range of [0.1, 10].
+        TypeError: If `phase` is not of type float.
+        ValueError: If `phase` is not in range of [0, 100].
+        TypeError: If `modulation` is not of type :class:`mindspore.dataset.audio.Modulation` .
+        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
@@ -917,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.
@@ -932,9 +1050,9 @@ class FrequencyMasking(AudioTensorOperation):
 
     Raises:
         TypeError: If `iid_masks` is not of type bool.
-        TypeError: If `freq_mask_param` is not of type integer.
+        TypeError: If `freq_mask_param` is not of type int.
         ValueError: If `freq_mask_param` is greater than the length of audio waveform in frequency domain.
-        TypeError: If `mask_start` is not of type integer.
+        TypeError: If `mask_start` is not of type int.
         ValueError: If `mask_start` is a negative number.
         TypeError: If `mask_value` is not of type float.
         ValueError: If `mask_value` is a negative number.
@@ -974,7 +1092,13 @@ class Gain(AudioTensorOperation):
     Apply amplification or attenuation to the whole waveform.
 
     Args:
-        gain_db (float): Gain adjustment in decibels (dB) (default=1.0).
+        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
@@ -996,28 +1120,49 @@ class Gain(AudioTensorOperation):
 
 class GriffinLim(AudioTensorOperation):
     r"""
-    Approximate magnitude spectrogram inversion using the GriffinLim algorithm.
-
-    .. math::
-        x(n)=\frac{\sum_{m=-\infty}^{\infty} w(m S-n) y_{w}(m S, n)}{\sum_{m=-\infty}^{\infty} w^{2}(m S-n)}
+    Compute waveform from a linear scale magnitude spectrogram using the Griffin-Lim transformation.
 
-    where w represents the window function, y represents the reconstructed signal of each frame and x represents the
-    whole signal.
+    About Griffin-Lim please refer to `A fast Griffin-Lim algorithm <https://doi.org/10.1109/WASPAA.2013.6701851>`_
+    and `Signal estimation from modified short-time Fourier transform <https://doi.org/10.1109/ICASSP.1983.1172092>`_ .
 
     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).
+        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` .
         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).
+            WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN or WindowType.KAISER. Default: WindowType.HANN.
             Currently kaiser window is not supported on macOS.
-        power (float, optional): Exponent for the magnitude spectrogram (default=2.0).
-        momentum (float, optional): The momentum for fast Griffin-Lim (default=0.99).
-        length (int, optional): Length of the expected output waveform (default=None, will be set to the value of last
-            dimension of the stft matrix).
-        rand_init (bool, optional): Flag for random phase initialization or all-zero phase initialization
-            (default=True).
+        power (float, optional): Exponent for the magnitude spectrogram. Default: 2.0.
+        momentum (float, optional): The momentum for fast Griffin-Lim. Default: 0.99.
+        length (int, optional): Length of the expected output waveform. Default: None, will be set to the value of last
+            dimension of the stft matrix.
+        rand_init (bool, optional): Flag for random phase initialization or all-zero phase initialization.
+            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
@@ -1029,7 +1174,7 @@ class GriffinLim(AudioTensorOperation):
     """
 
     @check_griffin_lim
-    def __init__(self, n_fft=400, n_iter=32, win_length=None, hop_length=None, window_type=WindowType.HANN, power=2,
+    def __init__(self, n_fft=400, n_iter=32, win_length=None, hop_length=None, window_type=WindowType.HANN, power=2.0,
                  momentum=0.99, length=None, rand_init=True):
         super().__init__()
         self.n_fft = n_fft
@@ -1050,12 +1195,25 @@ class GriffinLim(AudioTensorOperation):
 
 class HighpassBiquad(AudioTensorOperation):
     """
-    Design biquad highpass filter and perform filtering. Similar to SoX implementation.
+    Design biquad highpass filter and perform filtering.
+
+    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).
+        Q (float, optional): Quality factor, 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 `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
@@ -1079,22 +1237,46 @@ class HighpassBiquad(AudioTensorOperation):
 
 class InverseMelScale(AudioTensorOperation):
     """
-    Solve for a normal STFT form a mel frequency STFT, using a conversion matrix.
+    Solve for a normal STFT from a mel frequency STFT, using a conversion matrix.
 
     Args:
         n_stft (int): Number of bins in STFT.
-        n_mels (int, optional): Number of mel filterbanks (default=128).
-        sample_rate (int, optional): Sample rate of audio signal (default=16000).
-        f_min (float, optional): Minimum frequency (default=0.0).
-        f_max (float, optional): Maximum frequency (default=None, will be set to sample_rate // 2).
-        max_iter (int, optional): Maximum number of optimization iterations (default=100000).
-        tolerance_loss (float, optional): Value of loss to stop optimization at (default=1e-5).
-        tolerance_change (float, optional): Difference in losses to stop optimization at (default=1e-8).
-        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).
-        mel_type (MelType, optional): Mel scale to use, can be MelType.SLANEY or MelType.HTK (default=MelType.HTK).
+        n_mels (int, optional): Number of mel filterbanks. Default: 128.
+        sample_rate (int, optional): Sample rate of audio signal. Default: 16000.
+        f_min (float, optional): Minimum frequency. Default: 0.0.
+        f_max (float, optional): Maximum frequency. Default: None, will be set to `sample_rate // 2` .
+        max_iter (int, optional): Maximum number of optimization iterations. Default: 100000.
+        tolerance_loss (float, optional): Value of loss to stop optimization at. Default: 1e-5.
+        tolerance_change (float, optional): Difference in losses to stop optimization at. Default: 1e-8.
+        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, 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
@@ -1130,18 +1312,199 @@ 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):
     """
-    Design two-pole filter for audio waveform of dimension of (..., time).
+    Perform an IIR filter by evaluating different equation.
 
     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).
+        clamp (bool, optional): If True, clamp the output signal to be in the range [-1, 1]. Default: True.
+
+    Raises:
+        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 input tensor is not in shape of <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1178,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.
@@ -1187,7 +1550,7 @@ class LowpassBiquad(AudioTensorOperation):
             in range of (0, 1]. Default: 0.707.
 
     Raises:
-        TypeError: If `sample_rate` is not of type integer.
+        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.
@@ -1223,7 +1586,13 @@ class Magphase(AudioTensorOperation):
     Separate a complex-valued spectrogram with shape (..., 2) into its magnitude and phase.
 
     Args:
-        power (float): Power of the norm, which must be non-negative (default=1.0).
+        power (float): Power of the norm, which must be non-negative. Default: 1.0.
+
+    Raises:
+        RuntimeError: If the shape of input audio waveform does not match (..., 2).
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1245,13 +1614,21 @@ class Magphase(AudioTensorOperation):
 
 class MaskAlongAxis(AudioTensorOperation):
     """
-    Apply a mask along `axis`. Mask will be applied from indices `[mask_start, mask_start + mask_width)`.
+    Apply a mask along `axis` . Mask will be applied from indices `[mask_start, mask_start + mask_width)` .
 
     Args:
         mask_start (int): Starting position of the mask, which must be non negative.
-        mask_width (int): The width of the mask, which must be non negative.
+        mask_width (int): The width of the mask, which must be larger than 0.
         mask_value (float): Value to assign to the masked columns.
-        axis (int): Axis to apply masking on (1 for frequency and 2 for time).
+        axis (int): Axis to apply mask on (1 for frequency and 2 for time).
+
+    Raises:
+        ValueError: If `mask_start` is invalid (< 0).
+        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
@@ -1276,15 +1653,27 @@ class MaskAlongAxis(AudioTensorOperation):
 
 class MaskAlongAxisIID(AudioTensorOperation):
     """
-    Apply a mask along `axis`. Mask will be applied from indices `[mask_start, mask_start + mask_width)`, where
-    `mask_width` is sampled from `uniform[0, mask_param]`, and `mask_start` from `uniform[0, max_length - mask_width]`,
-    `max_length` is the number of columns of the specified axis of the spectrogram.
+    Apply a mask along `axis` . Mask will be applied from indices `[mask_start, mask_start + mask_width)` , where
+    `mask_width` is sampled from `uniform[0, mask_param]` , and `mask_start` from
+    `uniform[0, max_length - mask_width]` , `max_length` is the number of columns of the specified axis
+    of the spectrogram.
 
     Args:
         mask_param (int): Number of columns to be masked, will be uniformly sampled from
             [0, mask_param], must be non negative.
         mask_value (float): Value to assign to the masked columns.
-        axis (int): Axis to apply masking on (1 for frequency and 2 for time).
+        axis (int): Axis to apply mask on (1 for frequency and 2 for time).
+
+    Raises:
+        TypeError: If `mask_param` is not of type int.
+        ValueError: If `mask_param` is a negative value.
+        TypeError: If `mask_value` is not of type float.
+        TypeError: If `axis` is not of type int.
+        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
@@ -1318,15 +1707,32 @@ class MelScale(AudioTensorOperation):
     Convert normal STFT to STFT at the Mel scale.
 
     Args:
-        n_mels (int, optional): Number of mel filterbanks (default=128).
-        sample_rate (int, optional): Sample rate of audio signal (default=16000).
-        f_min (float, optional): Minimum frequency (default=0).
-        f_max (float, optional): Maximum frequency (default=None, will be set to sample_rate // 2).
-        n_stft (int, optional): Number of bins in STFT (default=201).
+        n_mels (int, optional): Number of mel filterbanks. Default: 128.
+        sample_rate (int, optional): Sample rate of audio signal. Default: 16000.
+        f_min (float, optional): Minimum frequency. Default: 0.0.
+        f_max (float, optional): Maximum frequency. Default: None, will be set to `sample_rate // 2` .
+        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).
-        mel_type (MelType, optional): Type to use, value should be MelType.SLANEY or MelType.HTK (default=MelType.HTK).
+            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
@@ -1339,7 +1745,7 @@ class MelScale(AudioTensorOperation):
     """
 
     @check_mel_scale
-    def __init__(self, n_mels=128, sample_rate=16000, f_min=0, f_max=None, n_stft=201, norm=NormType.NONE,
+    def __init__(self, n_mels=128, sample_rate=16000, f_min=0.0, f_max=None, n_stft=201, norm=NormType.NONE,
                  mel_type=MelType.HTK):
         super().__init__()
         self.n_mels = n_mels
@@ -1355,12 +1761,215 @@ 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.
+    Decode mu-law encoded signal, refer to `mu-law algorithm <https://en.wikipedia.org/wiki/M-law_algorithm>`_ .
 
     Args:
-        quantization_channels (int, optional): Number of channels, which must be positive (Default: 256).
+        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.
+        RuntimeError: If input tensor is not in shape of <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1385,7 +1994,14 @@ class MuLawEncoding(AudioTensorOperation):
     Encode signal based on mu-law companding.
 
     Args:
-        quantization_channels (int, optional): Number of channels, which must be positive (Default: 256).
+        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
@@ -1407,12 +2023,24 @@ class MuLawEncoding(AudioTensorOperation):
 
 class Overdrive(AudioTensorOperation):
     """
-    Apply overdrive on input audio.
+    Apply an overdrive effect to the audio waveform.
+
+    Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
-        gain (float, optional): Desired gain at the boost (or attenuation) in dB, in range of [0, 100] (default=20.0).
+        gain (float, optional): Desired gain at the boost (or attenuation) in dB, in range of [0, 100]. Default: 20.0.
         color (float, optional): Controls the amount of even harmonic content in the over-driven output,
-            in range of [0, 100] (default=20.0).
+            in range of [0, 100]. Default: 20.0.
+
+    Raises:
+        TypeError: If `gain` is not of type float.
+        ValueError: If `gain` is not in range of [0, 100].
+        TypeError: If `color` is not of type float.
+        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
@@ -1437,18 +2065,37 @@ class Phaser(AudioTensorOperation):
     """
     Apply a phasing effect to the audio.
 
+    Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
+
     Args:
         sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz).
-        gain_in (float, optional): Desired input gain at the boost (or attenuation) in dB.
-            Allowed range of values is [0, 1] (default=0.4).
-        gain_out (float, optional): Desired output gain at the boost (or attenuation) in dB.
-            Allowed range of values is [0, 1e9] (default=0.74).
-        delay_ms (float, optional): Desired delay in milli seconds. Allowed range of values is [0, 5] (default=3.0).
-        decay (float, optional): Desired decay relative to gain-in. Allowed range of values is [0, 0.99] (default=0.4).
-        mod_speed (float, optional): Modulation speed in Hz. Allowed range of values is [0.1, 2] (default=0.5).
+        gain_in (float, optional): Desired input gain at the boost (or attenuation) in dB,
+            in range of [0.0, 1.0]. Default: 0.4.
+        gain_out (float, optional): Desired output gain at the boost (or attenuation) in dB,
+            in range of [0.0, 1e9]. Default: 0.74.
+        delay_ms (float, optional): Desired delay in milliseconds, in range of [0.0, 5.0]. Default: 3.0.
+        decay (float, optional): Desired decay relative to gain-in, in range of [0.0, 0.99]. Default: 0.4.
+        mod_speed (float, optional): Modulation speed in Hz, in range of [0.1, 2.0]. Default: 0.5.
         sinusoidal (bool, optional): If True, use sinusoidal modulation (preferable for multiple instruments).
-            If False, use triangular modulation (gives single instruments a sharper
-            phasing effect) (default=True).
+            If False, use triangular modulation (gives single instruments a sharper phasing effect). Default: True.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        TypeError: If `gain_in` is not of type float.
+        ValueError: If `gain_in` is not in range of [0.0, 1.0].
+        TypeError: If `gain_out` is not of type float.
+        ValueError: If `gain_out` is not in range of [0.0, 1e9].
+        TypeError: If `delay_ms` is not of type float.
+        ValueError: If `delay_ms` is not in range of [0.0, 5.0].
+        TypeError: If `decay` is not of type float.
+        ValueError: If `decay` is not in range of [0.0, 0.99].
+        TypeError: If `mod_speed` is not of type float.
+        ValueError: If `mod_speed` is not in range of [0.1, 2.0].
+        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
@@ -1478,11 +2125,20 @@ class Phaser(AudioTensorOperation):
 
 class PhaseVocoder(AudioTensorOperation):
     """
-    Given a STFT tensor, speed up in time without modifying pitch by a factor of rate.
+    Given a STFT spectrogram, speed up in time without modifying pitch by a factor of rate.
 
     Args:
         rate (float): Speed-up factor.
-        phase_advance (numpy.ndarray): Expected phase advance in each bin in shape of (freq, 1).
+        phase_advance (numpy.ndarray): Expected phase advance in each bin, in shape of (freq, 1).
+
+    Raises:
+        TypeError: If `rate` is not of type float.
+        ValueError: If `rate` is not a positive number.
+        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
@@ -1504,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}
 
@@ -1513,16 +2231,30 @@ class Resample(AudioTensorOperation):
     Resample a signal from one frequency to another. A resample method can be given.
 
     Args:
-        orig_freq (float, optional): The original frequency of the signal, which must be positive (default=16000).
-        new_freq (float, optional): The desired frequency, which must be positive (default=16000).
-        resample_method (ResampleMethod, optional): The resample method, which can be
-            ResampleMethod.SINC_INTERPOLATION and ResampleMethod.KAISER_WINDOW
-            (default=ResampleMethod.SINC_INTERPOLATION).
-        lowpass_filter_width (int, optional): Controls the shaperness of the filter, more means sharper but less
-            efficient, which must be positive (default=6).
+        orig_freq (float, optional): The original frequency of the signal, must be positive. Default: 16000.
+        new_freq (float, optional): The desired frequency, must be positive. Default: 16000.
+        resample_method (ResampleMethod, optional): The resample method to use, can be ResampleMethod.SINC_INTERPOLATION
+            or ResampleMethod.KAISER_WINDOW. Default: ResampleMethod.SINC_INTERPOLATION.
+        lowpass_filter_width (int, optional): Controls the sharpness of the filter, more means sharper but less
+            efficient, must be positive. Default: 6.
         rolloff (float, optional): The roll-off frequency of the filter, as a fraction of the Nyquist. Lower values
-            reduce anti-aliasing, but also reduce some of the highest frequencies, range: (0, 1] (default=0.99).
-        beta (float, optional): The shape parameter used for kaiser window (default=None, will use 14.769656459379492).
+            reduce anti-aliasing, but also reduce some of the highest frequencies, in range of (0, 1]. Default: 0.99.
+        beta (float, optional): The shape parameter used for kaiser window. Default: None, will use 14.769656459379492.
+
+    Raises:
+        TypeError: If `orig_freq` is not of type float.
+        ValueError: If `orig_freq` is not a positive number.
+        TypeError: If `new_freq` is not of type float.
+        ValueError: If `new_freq` is not a positive number.
+        TypeError: If `resample_method` is not of type :class:`mindspore.dataset.audio.ResampleMethod` .
+        TypeError: If `lowpass_filter_width` is not of type int.
+        ValueError: If `lowpass_filter_width` is not a positive number.
+        TypeError: If `rolloff` is not of type float.
+        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
@@ -1555,12 +2287,21 @@ class Resample(AudioTensorOperation):
 
 class RiaaBiquad(AudioTensorOperation):
     """
-    Apply RIAA vinyl playback equalization. Similar to SoX implementation.
+    Apply RIAA vinyl playback equalization.
+
+    Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
         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
         >>>
@@ -1584,12 +2325,23 @@ class SlidingWindowCmn(AudioTensorOperation):
     Apply sliding-window cepstral mean (and optionally variance) normalization per utterance.
 
     Args:
-        cmn_window (int, optional): Window in frames for running average CMN computation (default=600).
+        cmn_window (int, optional): Window in frames for running average CMN computation. Default: 600.
         min_cmn_window (int, optional): Minimum CMN window used at start of decoding (adds latency only at start).
-            Only applicable if center is False, ignored if center is True (default=100).
+            Only applicable if center is False, ignored if center is True. Default: 100.
         center (bool, optional): If True, use a window centered on the current frame. If False, window is
-            to the left. (default=False).
-        norm_vars (bool, optional): If True, normalize variance to one. (default=False).
+            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
@@ -1621,17 +2373,35 @@ DE_C_WINDOW_TYPE = {WindowType.BARTLETT: cde.WindowType.DE_WINDOW_TYPE_BARTLETT,
 
 class SpectralCentroid(TensorOperation):
     """
-    Create a spectral centroid from an audio signal.
+    Compute the spectral centroid for each channel along the time axis.
 
     Args:
-        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz).
-        n_fft (int, optional): Size of FFT, creates n_fft // 2 + 1 bins (default=400).
-        win_length (int, optional): Window size (default=None, will use n_fft).
-        hop_length (int, optional): Length of hop between STFT windows (default=None, will use win_length // 2).
-        pad (int, optional): Two sided padding of signal (default=0).
+        sample_rate (int): Sampling rate of audio signal, e.g. 44100 (Hz).
+        n_fft (int, optional): Size of FFT, creates `n_fft // 2 + 1` bins. Default: 400.
+        win_length (int, optional): Window size. Default: None, will use `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows. Default: None, will use `win_length // 2` .
+        pad (int, optional): Two sided padding of signal. Default: 0.
         window (WindowType, optional): Window function that is applied/multiplied to each frame/window,
-            which can be WindowType.BARTLETT, WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN
-            or WindowType.KAISER (default=WindowType.HANN).
+            can be WindowType.BARTLETT, WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN
+            or WindowType.KAISER. Default: WindowType.HANN.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is a negative number.
+        TypeError: If `n_fft` is not of type int.
+        ValueError: If `n_fft` is not a positive number.
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is not a positive number.
+        ValueError: If `win_length` is greater than `n_fft` .
+        TypeError: If `hop_length` is not of type int.
+        ValueError: If `hop_length` is not a positive number.
+        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` .
+        RuntimeError: If input tensor is not in shape of <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1662,21 +2432,43 @@ class Spectrogram(TensorOperation):
     Create a spectrogram from an audio signal.
 
     Args:
-        n_fft (int, optional): Size of FFT, creates n_fft // 2 + 1 bins (default=400).
-        win_length (int, optional): Window size (default=None, will use n_fft).
-        hop_length (int, optional): Length of hop between STFT windows (default=None, will use win_length // 2).
-        pad (int): Two sided padding of signal (default=0).
+        n_fft (int, optional): Size of FFT, creates `n_fft // 2 + 1` bins. Default: 400.
+        win_length (int, optional): Window size. Default: None, will use `n_fft` .
+        hop_length (int, optional): Length of hop between STFT windows. Default: None, will use `win_length // 2` .
+        pad (int, optional): Two sided padding of signal. Default: 0.
         window (WindowType, optional): Window function that is applied/multiplied to each frame/window,
-            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.
-        power (float, optional): Exponent for the magnitude spectrogram, which must be greater
-            than or equal to 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,
-            which can be BorderType.REFLECT, BorderType.CONSTANT, BorderType.EDGE, BorderType.SYMMETRIC
-            (default=BorderType.REFLECT).
-        onesided (bool, optional): Controls whether to return half of results to avoid redundancy (default=True).
+            can be WindowType.BARTLETT, WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN
+            or WindowType.KAISER. Currently, Kaiser window is not supported on macOS. Default: WindowType.HANN.
+        power (float, optional): Exponent for the magnitude spectrogram, must be non negative,
+            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.
+
+    Raises:
+        TypeError: If `n_fft` is not of type int.
+        ValueError: If `n_fft` is not a positive number.
+        TypeError: If `win_length` is not of type int.
+        ValueError: If `win_length` is not a positive number.
+        ValueError: If `win_length` is greater than `n_fft` .
+        TypeError: If `hop_length` is not of type int.
+        ValueError: If `hop_length` is not a positive number.
+        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 `power` is not of type float.
+        ValueError: If `power` is a negative number.
+        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.
+        RuntimeError: If input tensor is not in shape of <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1713,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.
@@ -1769,20 +2561,20 @@ 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:
         hop_length (int, optional): Length of hop between STFT windows, i.e. the number of samples
-            between consecutive frames. Default: None, will use `n_freq - 1`.
+            between consecutive frames. Default: None, will use `n_freq - 1` .
         n_freq (int, optional): Number of filter banks from STFT. Default: 201.
         fixed_rate (float, optional): Rate to speed up or slow down by. Default: None, will keep
             the original rate.
 
     Raises:
-        TypeError: If `hop_length` is not of type integer.
+        TypeError: If `hop_length` is not of type int.
         ValueError: If `hop_length` is not a positive number.
-        TypeError: If `n_freq` is not of type integer.
+        TypeError: If `n_freq` is not of type int.
         ValueError: If `n_freq` is not a positive number.
         TypeError: If `fixed_rate` is not of type float.
         ValueError: If `fixed_rate` is not a positive number.
@@ -1822,13 +2614,28 @@ class TimeStretch(AudioTensorOperation):
 
 class TrebleBiquad(AudioTensorOperation):
     """
-    Design a treble tone-control effect. Similar to SoX implementation.
+    Design a treble tone-control effect.
+
+    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 (in Hz), which can't be zero.
         gain (float): Desired gain at the boost (or attenuation) in dB.
-        central_freq (float, optional): Central frequency (in Hz) (default=3000).
-        Q(float, optional): Quality factor, https://en.wikipedia.org/wiki/Q_factor, range: (0, 1] (default=0.707).
+        central_freq (float, optional): Central frequency (in Hz). Default: 3000.
+        Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
+            in range of (0, 1]. Default: 0.707.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is 0.
+        TypeError: If `gain` is not of type float.
+        TypeError: If `central_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 input tensor is not in shape of <..., time>.
+
+    Supported Platforms:
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1853,37 +2660,82 @@ class TrebleBiquad(AudioTensorOperation):
 
 class Vad(AudioTensorOperation):
     """
-    Attempt to trim silent background sounds from the end of the voice recording.
+    Voice activity detector.
+
+    Attempt to trim silence and quiet background sounds from the ends of recordings of speech.
+
+    Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
-        sample_rate (int): Sample rate of audio signal.
-        trigger_level (float, optional): The measurement level used to trigger activity detection (default=7.0).
-        trigger_time (float, optional): The time constant (in seconds) used to help ignore short sounds (default=0.25).
-        search_time (float, optional): The amount of audio (in seconds) to search for quieter/shorter sounds to include
-            prior to the detected trigger point (default=1.0).
-        allowed_gap (float, optional): The allowed gap (in seconds) between quiteter/shorter sounds to include prior to
-            the detected trigger point (default=0.25).
+        sample_rate (int): Sampling rate of audio signal.
+        trigger_level (float, optional): The measurement level used to trigger activity detection. Default: 7.0.
+        trigger_time (float, optional): The time constant (in seconds) used to help ignore short bursts of
+            sounds. Default: 0.25.
+        search_time (float, optional): The amount of audio (in seconds) to search for quieter/shorter bursts of audio
+            to include prior to the detected trigger point. Default: 1.0.
+        allowed_gap (float, optional): The allowed gap (in seconds) between quieter/shorter bursts of audio to include
+            prior to the detected trigger point. Default: 0.25.
         pre_trigger_time (float, optional): The amount of audio (in seconds) to preserve before the trigger point and
-            any found quieter/shorter bursts (default=0.0).
-        boot_time (float, optional): The time for the initial noise estimate (default=0.35).
-        noise_up_time (float, optional): Time constant used by the adaptive noise estimator, when the noise level is
-            increasing (default=0.1).
-        noise_down_time (float, optional): Time constant used by the adaptive noise estimator, when the noise level is
-            decreasing (default=0.01).
-        noise_reduction_amount (float, optional): The amount of noise reduction used in the detection algorithm
-            (default=1.35).
-        measure_freq (float, optional): The frequency of the algorithm’s processing (default=20.0).
-        measure_duration (float, optional): The duration of measurement (default=None, use twice the measurement
-            period).
-        measure_smooth_time (float, optional): The time constant used to smooth spectral measurements (default=0.4).
-        hp_filter_freq (float, optional): The "Brick-wall" frequency of high-pass filter applied at the input to the
-            detector algorithm (default=50.0).
-        lp_filter_freq (float, optional): The "Brick-wall" frequency of low-pass filter applied at the input to the
-            detector algorithm (default=6000.0).
-        hp_lifter_freq (float, optional): The "Brick-wall" frequency of high-pass lifter applied at the input to the
-            detector algorithm (default=150.0).
-        lp_lifter_freq (float, optional): The "Brick-wall" frequency of low-pass lifter applied at the input to the
-            detector algorithm (default=2000.0).
+            any found quieter/shorter bursts. Default: 0.0.
+        boot_time (float, optional): The time for the initial noise estimate. Default: 0.35.
+        noise_up_time (float, optional): Time constant used by the adaptive noise estimator for when the noise level is
+            increasing. Default: 0.1.
+        noise_down_time (float, optional): Time constant used by the adaptive noise estimator for when the noise level
+            is decreasing. Default: 0.01.
+        noise_reduction_amount (float, optional): Amount of noise reduction to use in the detection algorithm.
+            Default: 1.35.
+        measure_freq (float, optional): Frequency of the algorithm's processing/measurements. Default: 20.0.
+        measure_duration (float, optional): The duration of measurement. Default: None, will use twice the measurement
+            period.
+        measure_smooth_time (float, optional): Time constant used to smooth spectral measurements. Default: 0.4.
+        hp_filter_freq (float, optional): The 'Brick-wall' frequency of high-pass filter applied at the input to the
+            detector algorithm. Default: 50.0.
+        lp_filter_freq (float, optional): The 'Brick-wall' frequency of low-pass filter applied at the input to the
+            detector algorithm. Default: 6000.0.
+        hp_lifter_freq (float, optional): The 'Brick-wall' frequency of high-pass lifter used in the
+            detector algorithm. Default: 150.0.
+        lp_lifter_freq (float, optional): The 'Brick-wall' frequency of low-pass lifter used in the
+            detector algorithm. Default: 2000.0.
+
+    Raises:
+        TypeError: If `sample_rate` is not of type int.
+        ValueError: If `sample_rate` is not a positive number.
+        TypeError: If `trigger_level` is not of type float.
+        TypeError: If `trigger_time` is not of type float.
+        ValueError: If `trigger_time` is a negative number.
+        TypeError: If `search_time` is not of type float.
+        ValueError: If `search_time` is a negative number.
+        TypeError: If `allowed_gap` is not of type float.
+        ValueError: If `allowed_gap` is a negative number.
+        TypeError: If `pre_trigger_time` is not of type float.
+        ValueError: If `pre_trigger_time` is a negative number.
+        TypeError: If `boot_time` is not of type float.
+        ValueError: If `boot_time` is a negative number.
+        TypeError: If `noise_up_time` is not of type float.
+        ValueError: If `noise_up_time` is a negative number.
+        TypeError: If `noise_down_time` is not of type float.
+        ValueError: If `noise_down_time` is a negative number.
+        ValueError: If `noise_up_time` is less than `noise_down_time` .
+        TypeError: If `noise_reduction_amount` is not of type float.
+        ValueError: If `noise_reduction_amount` is a negative number.
+        TypeError: If `measure_freq` is not of type float.
+        ValueError: If `measure_freq` is not a positive number.
+        TypeError: If `measure_duration` is not of type float.
+        ValueError: If `measure_duration` is a negative number.
+        TypeError: If `measure_smooth_time` is not of type float.
+        ValueError: If `measure_smooth_time` is a negative number.
+        TypeError: If `hp_filter_freq` is not of type float.
+        ValueError: If `hp_filter_freq` is not a positive number.
+        TypeError: If `lp_filter_freq` is not of type float.
+        ValueError: If `lp_filter_freq` is not a positive number.
+        TypeError: If `hp_lifter_freq` is not of type float.
+        ValueError: If `hp_lifter_freq` is not a positive number.
+        TypeError: If `lp_lifter_freq` is not of type float.
+        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
@@ -1933,15 +2785,25 @@ DE_C_GAIN_TYPE = {GainType.AMPLITUDE: cde.GainType.DE_GAIN_TYPE_AMPLITUDE,
 
 class Vol(AudioTensorOperation):
     """
-    Apply amplification or attenuation to the whole waveform.
+    Adjust volume of waveform.
 
     Args:
-        gain (float): Value of gain adjustment.
-            If gain_type = amplitude, gain stands for nonnegative amplitude ratio.
-            If gain_type = power, gain stands for power.
-            If gain_type = db, gain stands for decibels.
-        gain_type (GainType, optional): Type of gain, contains the following three enumeration values
-            GainType.AMPLITUDE, GainType.POWER and GainType.DB (default=GainType.AMPLITUDE).
+        gain (float): Gain at the boost (or attenuation).
+            If `gain_type` is GainType.AMPLITUDE, it is a non negative amplitude ratio.
+            If `gain_type` is GainType.POWER, it is a power (voltage squared).
+            If `gain_type` is GainType.DB, it is in decibels.
+        gain_type (GainType, optional): Type of gain, can be GainType.AMPLITUDE, GainType.POWER
+            or GainType.DB. Default: GainType.AMPLITUDE.
+
+    Raises:
+        TypeError: If `gain` is not of type float.
+        TypeError: If `gain_type` is not of type :class:`mindspore.dataset.audio.GainType` .
+        ValueError: If `gain` is a negative number when `gain_type` is GainType.AMPLITUDE.
+        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