mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/dataset/audio/transforms.py

@@ -75,7 +75,7 @@ class AllpassBiquad(AudioTensorOperation):
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
         central_freq (float): Central frequency (in Hz).
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
+            in range of (0, 1]. Default: ``0.707``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -90,11 +90,16 @@ class AllpassBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
-        >>> transforms = [audio.AllpassBiquad(44100, 200.0)]
+        >>> transforms = [ds.audio.AllpassBiquad(44100, 200.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_allpass_biquad
@@ -121,15 +126,15 @@ class AmplitudeToDB(AudioTensorOperation):
 
     Args:
         stype (ScaleType, optional): Scale of the input waveform, which can be
-            ScaleType.POWER or ScaleType.MAGNITUDE. Default: ScaleType.POWER.
+            ``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.
+            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.ScaleType` .
@@ -146,12 +151,18 @@ class AmplitudeToDB(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>> from mindspore.dataset.audio import ScaleType
         >>>
         >>> waveform = np.random.random([1, 400 // 2 + 1, 30])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.AmplitudeToDB(stype=ScaleType.POWER)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_amplitude_to_db
@@ -182,11 +193,17 @@ class Angle(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1.43, 5.434], [23.54, 89.38]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Angle()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     def parse(self):
@@ -210,9 +227,10 @@ class BandBiquad(AudioTensorOperation):
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
         central_freq (float): Central frequency (in Hz).
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
-        noise (bool, optional) : If True, uses the alternate mode for un-pitched audio (e.g. percussion).
-            If False, uses mode oriented to pitched audio, i.e. voice, singing, or instrumental music. Default: False.
+            in range of (0, 1]. Default: ``0.707``.
+        noise (bool, optional) : If ``True``, uses the alternate mode for un-pitched audio (e.g. percussion).
+            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 int.
@@ -228,11 +246,17 @@ class BandBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.BandBiquad(44100, 200.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_band_biquad
@@ -271,9 +295,9 @@ class BandpassBiquad(AudioTensorOperation):
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
         central_freq (float): Central frequency (in Hz).
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
-        const_skirt_gain (bool, optional) : If True, uses a constant skirt gain (peak gain = Q);
-            If False, uses a constant 0dB peak gain. Default: False.
+            in range of (0, 1]. Default: ``0.707``.
+        const_skirt_gain (bool, optional) : If ``True``, uses a constant skirt gain (peak gain = Q);
+            If ``False``, uses a constant 0dB peak gain. Default: ``False``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -289,11 +313,17 @@ class BandpassBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.BandpassBiquad(44100, 200.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_bandpass_biquad
@@ -330,7 +360,7 @@ class BandrejectBiquad(AudioTensorOperation):
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
         central_freq (float): Central frequency (in Hz).
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
+            in range of (0, 1]. Default: ``0.707``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -345,11 +375,17 @@ class BandrejectBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03],[9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.BandrejectBiquad(44100, 200.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_bandreject_biquad
@@ -381,9 +417,9 @@ class BassBiquad(AudioTensorOperation):
     Args:
         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: 100.0.
+        central_freq (float, optional): Central frequency (in Hz). Default: ``100.0``.
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
+            in range of (0, 1]. Default: ``0.707``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -399,11 +435,17 @@ class BassBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.BassBiquad(44100, 100.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_bass_biquad
@@ -445,10 +487,15 @@ class Biquad(TensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> biquad_op = audio.Biquad(0.01, 0.02, 0.13, 1, 0.12, 0.3)
         >>> waveform_filtered = biquad_op(waveform)
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_biquad
@@ -474,7 +521,7 @@ class ComplexNorm(AudioTensorOperation):
         The first dimension represents the real part while the second represents the imaginary.
 
     Args:
-        power (float, optional): Power of the norm, which must be non-negative. Default: 1.0.
+        power (float, optional): Power of the norm, which must be non-negative. Default: ``1.0``.
 
     Raises:
         TypeError: If `power` is not of type float.
@@ -486,11 +533,17 @@ class ComplexNorm(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([2, 4, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.ComplexNorm()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_complex_norm
@@ -524,15 +577,15 @@ class ComputeDeltas(AudioTensorOperation):
     at time :math:`t` , :math:`N` is :math:`(\text{win_length} - 1) // 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, can be BorderType.CONSTANT, BorderType.EDGE,
-            BorderType.REFLECT or BorderType.SYMMETRIC. Default: BorderType.EDGE.
+        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.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.
+            - ``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.
+            - ``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].
 
     Raises:
@@ -546,12 +599,18 @@ class ComputeDeltas(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>> from mindspore.dataset.audio import BorderType
         >>>
         >>> waveform = np.random.random([1, 400 // 2 + 1, 30])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.ComputeDeltas(win_length=7, pad_mode=BorderType.EDGE)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_compute_deltas
@@ -577,7 +636,7 @@ class Contrast(AudioTensorOperation):
 
     Args:
         enhancement_amount (float, optional): Controls the amount of the enhancement,
-            in range of [0, 100]. Default: 75.0. Note that `enhancement_amount` equal
+            in range of [0, 100]. Default: ``75.0``. Note that `enhancement_amount` equal
             to 0 still gives a significant contrast enhancement.
 
     Raises:
@@ -590,11 +649,17 @@ class Contrast(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Contrast()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_contrast
@@ -623,11 +688,17 @@ class DBToAmplitude(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.DBToAmplitude(0.5, 0.5)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_db_to_amplitude
@@ -647,7 +718,8 @@ class DCShift(AudioTensorOperation):
     Args:
         shift (float): The amount to shift the audio, the value must be in the range [-2.0, 2.0].
         limiter_gain (float, optional): Used only on peaks to prevent clipping,
-            the value should be much less than 1, such as 0.05 or 0.02. Default: None, will be set to `shift` .
+            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.
@@ -659,11 +731,17 @@ class DCShift(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([0.60, 0.97, -1.04, -1.26, 0.97, 0.91, 0.48, 0.93])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.DCShift(0.5, 0.02)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_dc_shift
@@ -695,11 +773,17 @@ class DeemphBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.DeemphBiquad(44100)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_deemph_biquad
@@ -718,14 +802,14 @@ class DetectPitchFrequency(AudioTensorOperation):
     It is implemented using normalized cross-correlation function and median smoothing.
 
     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.
+        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``.
         win_length (int, optional): The window length for median smoothing (in number of frames), the value must be
-            greater than zero. Default: 30.
+            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.
+            Default: ``85``.
         freq_high (int, optional): Highest frequency that can be detected (Hz), the value must be greater than zero.
-            Default: 3400.
+            Default: ``3400``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -744,12 +828,18 @@ class DetectPitchFrequency(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[0.716064e-03, 5.347656e-03, 6.246826e-03, 2.089477e-02, 7.138305e-02],
         ...                      [4.156616e-02, 1.394653e-02, 3.550292e-02, 0.614379e-02, 3.840209e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.DetectPitchFrequency(30, 0.1, 3, 5, 25)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_detect_pitch_frequency
@@ -778,12 +868,12 @@ class Dither(AudioTensorOperation):
 
     Args:
         density_function (DensityFunction, optional): The density function of a continuous
-            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.
+            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``.
         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` .
@@ -795,11 +885,17 @@ class Dither(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1, 2, 3], [4, 5, 6]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Dither()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_dither
@@ -819,10 +915,10 @@ class EqualizerBiquad(AudioTensorOperation):
     Similar to `SoX <http://sox.sourceforge.net/sox.html>`_ implementation.
 
     Args:
-        sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz), the value can't be 0.
+        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.
@@ -837,11 +933,17 @@ class EqualizerBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.EqualizerBiquad(44100, 1500, 5.5, 0.7)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_equalizer_biquad
@@ -868,20 +970,20 @@ 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_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.
+            Default: ``FadeShape.LINEAR``.
 
-            -FadeShape.QUARTER_SINE, means it tend to 0 in an quarter sin function.
+            - ``FadeShape.QUARTER_SINE``, means it tend to 0 in an quarter sin function.
 
-            -FadeShape.HALF_SINE, means it tend to 0 in an half sin function.
+            - ``FadeShape.HALF_SINE``, means it tend to 0 in an half sin function.
 
-            -FadeShape.LINEAR, means it linear to 0.
+            - ``FadeShape.LINEAR``, means it linear to 0.
 
-            -FadeShape.LOGARITHMIC, means it tend to 0 in an logrithmic function.
+            - ``FadeShape.LOGARITHMIC``, means it tend to 0 in an logrithmic function.
 
-            -FadeShape.EXPONENTIAL, means it tend to 0 in an exponential function.
+            - ``FadeShape.EXPONENTIAL``, means it tend to 0 in an exponential function.
 
     Raises:
         RuntimeError: If fade_in_len exceeds waveform length.
@@ -892,12 +994,18 @@ class Fade(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>> from mindspore.dataset.audio import FadeShape
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03, 9.246826171875e-03, 1.0894775390625e-02]])
         >>> dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Fade(fade_in_len=3, fade_out_len=2, fade_shape=FadeShape.LINEAR)]
         >>> dataset = dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_fade
@@ -922,7 +1030,8 @@ class Filtfilt(AudioTensorOperation):
         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].
@@ -933,6 +1042,8 @@ class Filtfilt(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> a_coeffs = [0.1, 0.2, 0.3]
@@ -940,6 +1051,10 @@ class Filtfilt(AudioTensorOperation):
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Filtfilt(a_coeffs, b_coeffs)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_lfilter
@@ -968,16 +1083,16 @@ class Flanger(AudioTensorOperation):
 
     Args:
         sample_rate (int): Sampling rate of the waveform, e.g. 44100 (Hz).
-        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.
+        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.
@@ -1003,11 +1118,17 @@ class Flanger(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Flanger(44100)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_flanger
@@ -1038,15 +1159,15 @@ class FrequencyMasking(AudioTensorOperation):
         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.
-        freq_mask_param (int, optional): When `iid_masks` is True, length of the mask will be uniformly sampled
-            from [0, freq_mask_param]; When `iid_masks` is False, directly use it as length of the mask.
+        iid_masks (bool, optional): Whether to apply different masks to each example/channel. Default: ``False``.
+        freq_mask_param (int, optional): When `iid_masks` is ``True``, length of the mask will be uniformly sampled
+            from [0, freq_mask_param]; When `iid_masks` is ``False``, directly use it as length of the mask.
             The value should be in range of [0, freq_length], where `freq_length` is the length of audio waveform
-            in frequency domain. Default: 0.
-        mask_start (int, optional): Starting point to apply mask, only works when `iid_masks` is True. The value should
-            be in range of [0, freq_length - freq_mask_param], where `freq_length` is the length of audio waveform
-            in frequency domain. Default: 0.
-        mask_value (float, optional): Value to assign to the masked columns. Default: 0.0.
+            in frequency domain. Default: ``0``.
+        mask_start (int, optional): Starting point to apply mask, only works when `iid_masks` is ``True``.
+            The value should be in range of [0, freq_length - freq_mask_param], where `freq_length` is
+            the length of audio waveform in frequency domain. Default: ``0``.
+        mask_value (float, optional): Value to assign to the masked columns. Default: ``0.0``.
 
     Raises:
         TypeError: If `iid_masks` is not of type bool.
@@ -1063,12 +1184,18 @@ class FrequencyMasking(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([1, 3, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.FrequencyMasking(freq_mask_param=1)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
 
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
+
     .. image:: frequency_masking_original.png
 
     .. image:: frequency_masking.png
@@ -1092,7 +1219,7 @@ 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.
@@ -1102,11 +1229,17 @@ class Gain(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Gain(1.2)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_gain
@@ -1126,20 +1259,20 @@ class GriffinLim(AudioTensorOperation):
     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` .
+        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.
-            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.
+            Default: ``None``, will be set to `win_length // 2` .
+        window_type (WindowType, optional): Window type for GriffinLim, which can be ``WindowType.BARTLETT``,
+            ``WindowType.BLACKMAN``, ``WindowType.HAMMING``, ``WindowType.HANN`` or ``WindowType.KAISER``.
+            Default: ``WindowType.HANN``. Currently kaiser window is not supported on macOS.
+        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.
+            Default: ``True``.
 
     Raises:
         TypeError: If `n_fft` is not of type int.
@@ -1166,11 +1299,17 @@ class GriffinLim(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([201, 6])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.GriffinLim(n_fft=400)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_griffin_lim
@@ -1202,7 +1341,7 @@ class HighpassBiquad(AudioTensorOperation):
     Args:
         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.
@@ -1217,11 +1356,17 @@ class HighpassBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.HighpassBiquad(44100, 1500, 0.7)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_highpass_biquad
@@ -1241,18 +1386,19 @@ class InverseMelScale(AudioTensorOperation):
 
     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
+        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.
+        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.
@@ -1280,11 +1426,17 @@ class InverseMelScale(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.randn(2, 2, 3, 2)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.InverseMelScale(20, 3, 16000, 0, 8000, 10)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_inverse_mel_scale
@@ -1317,24 +1469,24 @@ 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,
+        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.
+            Default: ``400``.
         win_length (int, optional): Window size, which should be greater than 0.
-            Default: None, will be set to `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` .
-        pad (int, optional): Two sided padding of signal, cannot be less than 0. Default: 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.
+            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.
+            redundancy. Default: ``True``.
 
     Raises:
         TypeError: If `length` is not of type int.
@@ -1358,12 +1510,18 @@ class InverseSpectrogram(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> 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"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_inverse_spectrogram
@@ -1400,16 +1558,16 @@ class LFCC(AudioTensorOperation):
         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.
+        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
+            Default: ``None``, the default setting is a dict including
 
             - 'n_fft': 400
             - 'win_length': n_fft
@@ -1433,7 +1591,7 @@ class LFCC(AudioTensorOperation):
         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.
+        ValueError: If `dct_type` is not ``2``.
 
     Supported Platforms:
         ``CPU``
@@ -1447,6 +1605,10 @@ class LFCC(AudioTensorOperation):
         >>> 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"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_lfcc
@@ -1494,7 +1656,7 @@ class LFilter(AudioTensorOperation):
         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].
@@ -1508,6 +1670,8 @@ class LFilter(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
         >>> a_coeffs = [0.1, 0.2, 0.3]
@@ -1515,6 +1679,10 @@ class LFilter(AudioTensorOperation):
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.LFilter(a_coeffs, b_coeffs)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_lfilter
@@ -1547,7 +1715,7 @@ class LowpassBiquad(AudioTensorOperation):
         sample_rate (int): Sampling rate (in Hz), which can't be zero.
         cutoff_freq (float): Filter cutoff frequency (in Hz).
         Q (float, optional): `Quality factor <https://en.wikipedia.org/wiki/Q_factor>`_ ,
-            in range of (0, 1]. Default: 0.707.
+            in range of (0, 1]. Default: ``0.707``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -1562,12 +1730,18 @@ class LowpassBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> 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.LowpassBiquad(4000, 1500, 0.7)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_lowpass_biquad
@@ -1583,10 +1757,10 @@ class LowpassBiquad(AudioTensorOperation):
 
 class Magphase(AudioTensorOperation):
     """
-    Separate a complex-valued spectrogram with shape (..., 2) into its magnitude and phase.
+    Separate a complex-valued spectrogram with shape :math:`(..., 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).
@@ -1596,11 +1770,17 @@ class Magphase(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([2, 4, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Magphase()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_magphase
@@ -1632,11 +1812,17 @@ class MaskAlongAxis(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([1, 20, 20])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.MaskAlongAxis(0, 10, 0.5, 1)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mask_along_axis
@@ -1677,11 +1863,17 @@ class MaskAlongAxisIID(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform= np.random.random([1, 20, 20])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.MaskAlongAxisIID(5, 0.5, 2)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mask_along_axis_iid
@@ -1707,15 +1899,16 @@ 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.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, no narmalization.
-        mel_type (MelType, optional): Type to use, value should 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` .
+        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``, 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.
@@ -1736,12 +1929,18 @@ class MelScale(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> 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.MelScale(4000, 1500, 0.7)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mel_scale
@@ -1766,31 +1965,33 @@ class MelSpectrogram(AudioTensorOperation):
     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.
+        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.
+            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
+            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.
+        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.
+            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.
+            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.
+            (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.
@@ -1825,6 +2026,8 @@ class MelSpectrogram(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> from mindspore.dataset.audio import WindowType, BorderType, NormType, MelType
         >>>
@@ -1835,6 +2038,10 @@ class MelSpectrogram(AudioTensorOperation):
         ...                                    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"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mel_spectrogram
@@ -1872,13 +2079,13 @@ 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.
+        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
+            Default: ``None``, the default setting is a dict including
 
             - 'n_fft': 400
             - 'win_length': n_fft
@@ -1903,19 +2110,25 @@ class MFCC(AudioTensorOperation):
         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.
+        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.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"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mfcc
@@ -1961,7 +2174,7 @@ class MuLawDecoding(AudioTensorOperation):
     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.
@@ -1973,11 +2186,17 @@ class MuLawDecoding(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([1, 3, 4])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.MuLawDecoding()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mu_law_coding
@@ -1994,7 +2213,7 @@ 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.
@@ -2005,11 +2224,17 @@ class MuLawEncoding(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([1, 3, 4])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.MuLawEncoding()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_mu_law_coding
@@ -2028,9 +2253,10 @@ class Overdrive(AudioTensorOperation):
     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.
@@ -2044,11 +2270,17 @@ class Overdrive(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Overdrive()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_overdrive
@@ -2070,14 +2302,15 @@ class Phaser(AudioTensorOperation):
     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,
-            in range of [0.0, 1.0]. Default: 0.4.
+            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.
+            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``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -2099,11 +2332,17 @@ class Phaser(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Phaser(44100)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_phaser
@@ -2142,12 +2381,18 @@ class PhaseVocoder(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([2, 44, 10, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> phase_advance = np.random.random([44, 1])
         >>> transforms = [audio.PhaseVocoder(rate=2, phase_advance=phase_advance)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_phase_vocoder
@@ -2167,13 +2412,13 @@ class PitchShift(AudioTensorOperation):
     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,
+        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.
+            Default: ``WindowType.HANN``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -2203,6 +2448,10 @@ class PitchShift(AudioTensorOperation):
         >>> 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"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_pitch_shift
@@ -2231,15 +2480,18 @@ 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, 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.
+        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.
+            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, in range of (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.
@@ -2258,6 +2510,8 @@ class Resample(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>> from mindspore.dataset.audio import ResampleMethod
         >>>
         >>> waveform = np.random.random([1, 30])
@@ -2266,6 +2520,10 @@ class Resample(AudioTensorOperation):
         ...                              resample_method=ResampleMethod.SINC_INTERPOLATION,
         ...                              lowpass_filter_width=6, rolloff=0.99, beta=None)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_resample
@@ -2304,11 +2562,17 @@ class RiaaBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float64)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.RiaaBiquad(44100)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_riaa_biquad
@@ -2325,12 +2589,12 @@ 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.
-        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.
+            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``.
 
     Raises:
         TypeError: If `cmn_window` is not of type int.
@@ -2345,11 +2609,17 @@ class SlidingWindowCmn(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[[1, 2, 3], [4, 5, 6]]], dtype=np.float64)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.SlidingWindowCmn()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_sliding_window_cmn
@@ -2376,14 +2646,14 @@ class SpectralCentroid(TensorOperation):
     Compute the spectral centroid for each channel along the time axis.
 
     Args:
-        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.
+        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,
-            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.
@@ -2405,11 +2675,17 @@ class SpectralCentroid(TensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([5, 10, 20])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.SpectralCentroid(44100)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_spectral_centroid
@@ -2432,21 +2708,21 @@ 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, optional): 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,
-            can be WindowType.BARTLETT, WindowType.BLACKMAN, WindowType.HAMMING, WindowType.HANN
-            or WindowType.KAISER. Currently, Kaiser window is not supported on macOS. Default: WindowType.HANN.
+            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.
+            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.
@@ -2472,11 +2748,17 @@ class Spectrogram(TensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([5, 10, 20])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Spectrogram()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_spectrogram
@@ -2508,15 +2790,15 @@ class TimeMasking(AudioTensorOperation):
         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.
-        time_mask_param (int, optional): When `iid_masks` is True, length of the mask will be uniformly sampled
-            from [0, time_mask_param]; When `iid_masks` is False, directly use it as length of the mask.
+        iid_masks (bool, optional): Whether to apply different masks to each example/channel. Default: ``False``.
+        time_mask_param (int, optional): When `iid_masks` is ``True``, length of the mask will be uniformly sampled
+            from [0, time_mask_param]; When `iid_masks` is ``False``, directly use it as length of the mask.
             The value should be in range of [0, time_length], where `time_length` is the length of audio waveform
-            in time domain. Default: 0.
-        mask_start (int, optional): Starting point to apply mask, only works when `iid_masks` is True. The value should
-            be in range of [0, time_length - time_mask_param], where `time_length` is the length of audio waveform
-            in time domain. Default: 0.
-        mask_value (float, optional): Value to assign to the masked columns. Default: 0.0.
+            in time domain. Default: ``0``.
+        mask_start (int, optional): Starting point to apply mask, only works when `iid_masks` is ``True``.
+            The value should be in range of [0, time_length - time_mask_param], where `time_length` is
+            the length of audio waveform in time domain. Default: ``0``.
+        mask_value (float, optional): Value to assign to the masked columns. Default: ``0.0``.
 
     Raises:
         TypeError: If `iid_masks` is not of type bool.
@@ -2533,12 +2815,18 @@ class TimeMasking(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([4, 3, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.TimeMasking(time_mask_param=1)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
 
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
+
     .. image:: time_masking_original.png
 
     .. image:: time_masking.png
@@ -2566,9 +2854,9 @@ class TimeStretch(AudioTensorOperation):
 
     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` .
-        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
+            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:
@@ -2585,12 +2873,18 @@ class TimeStretch(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([44, 10, 2])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.TimeStretch()]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
 
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
+
     .. image:: time_stretch_rate1.5.png
 
     .. image:: time_stretch_original.png
@@ -2621,9 +2915,9 @@ class TrebleBiquad(AudioTensorOperation):
     Args:
         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.
+        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.
+            in range of (0, 1]. Default: ``0.707``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -2639,11 +2933,17 @@ class TrebleBiquad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float64)
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.TrebleBiquad(44100, 200.0)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_treble_biquad
@@ -2668,34 +2968,34 @@ class Vad(AudioTensorOperation):
 
     Args:
         sample_rate (int): Sampling rate of audio signal.
-        trigger_level (float, optional): The measurement level used to trigger activity detection. Default: 7.0.
+        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.
+            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.
+            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.
+            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.
+            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.
+            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.
+            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.
+        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.
+            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.
+            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.
+            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.
+            detector algorithm. Default: ``2000.0``.
 
     Raises:
         TypeError: If `sample_rate` is not of type int.
@@ -2739,11 +3039,17 @@ class Vad(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>>
         >>> waveform = np.random.random([2, 1000])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Vad(sample_rate=600)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_vad
@@ -2789,17 +3095,17 @@ class Vol(AudioTensorOperation):
 
     Args:
         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.
+            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.
+        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:
@@ -2807,12 +3113,18 @@ class Vol(AudioTensorOperation):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.audio as audio
         >>> from mindspore.dataset.audio import GainType
         >>>
         >>> waveform = np.random.random([20, 30])
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
         >>> transforms = [audio.Vol(gain=10, gain_type=GainType.DB)]
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
+
+    Tutorial Examples:
+        - `Illustration of audio transforms
+          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/audio_gallery.html>`_
     """
 
     @check_vol