zzy34407230
/
mindspore2022
Not watched
1
0
Fork 0
Code
Releases 22 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: cdd3e50e98
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdd3e50e98'
${ noResults }
mindspore2022/tests/ut/python/dataset/test_spectrogram.py

433 lines
23 kB
Raw Blame History 

  1. # Copyright 2021 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. # ==============================================================================

  15. """

  16. Testing Spectrogram Python API

  17. """

  18. import numpy as np

  19. 

  20. import mindspore.dataset as ds

  21. import mindspore.dataset.audio.transforms as audio

  22. from mindspore import log as logger

  23. from mindspore.dataset.audio.utils import WindowType, BorderType

  24. 

  25. 

  26. def count_unequal_element(data_expected, data_me, rtol, atol):

  27.     """ Precision calculation func """

  28.     assert data_expected.shape == data_me.shape

  29.     total_count = len(data_expected.flatten())

  30.     error = np.abs(data_expected - data_me)

  31.     greater = np.greater(error, atol + np.abs(data_expected) * rtol)

  32.     loss_count = np.count_nonzero(greater)

  33.     assert (loss_count / total_count) < rtol, "\ndata_expected_std:{0}\ndata_me_error:{1}\nloss:{2}".format(

  34.         data_expected[greater], data_me[greater], error[greater])

  35. 

  36. 

  37. def test_spectrogram_pipeline():

  38.     """

  39.     Feature: mindspore pipeline mode normal testcase: spectrogram op.

  40.     Description: input audio signal to test pipeline.

  41.     Expectation: success.

  42.     """

  43.     logger.info("test_spectrogram_pipeline")

  44. 

  45.     wav = [[[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]]]

  46.     dataset = ds.NumpySlicesDataset(wav, column_names=["audio"], shuffle=False)

  47.     out = audio.Spectrogram(n_fft=8)

  48.     dataset = dataset.map(operations=out, input_columns=["audio"], output_columns=["Spectrogram"],

  49.                           column_order=['Spectrogram'])

  50.     result = np.array([[[2.8015e+01, 1.2100e+02, 3.1354e+02, 1.6900e+02, 2.5000e+01,

  51.                          1.0843e+01, 1.2100e+02, 3.3150e+02],

  52.                         [3.2145e+00, 3.3914e+01, 9.4728e+01, 4.5914e+01, 9.9142e+00,

  53.                          4.5858e+00, 3.3914e+01, 9.5685e+01],

  54.                         [1.0000e+00, 1.7157e-01, 1.5000e+00, 1.7157e-01, 1.7157e-01,

  55.                          5.0000e-01, 1.7157e-01, 7.5000e-01],

  56.                         [4.2893e-02, 2.5736e-01, 5.8579e-01, 2.5736e-01, 2.5736e-01,

  57.                          5.8579e-01, 2.5736e-01, 1.2868e-01],

  58.                         [5.0000e-01, 1.0000e+00, 8.5787e-02, 1.0000e+00, 1.0000e+00,

  59.                          5.0000e-01, 1.0000e+00, 6.2868e-01]]])

  60.     for data1 in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):

  61.         count_unequal_element(data1["Spectrogram"], result, 0.0001, 0.0001)

  62. 

  63. 

  64. def test_spectrogram_eager():

  65.     """

  66.     Feature: mindspore eager mode normal testcase: spectrogram op.

  67.     Description: input audio signal to test eager.

  68.     Expectation: success.

  69.     """

  70.     logger.info("test_spectrogram_eager")

  71.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  72.     out = audio.Spectrogram(n_fft=8, win_length=8, window=WindowType.HANN,

  73.                             pad_mode=BorderType.REFLECT)(np.array(wav, dtype="float"))

  74.     result = np.array([[[2.8015e+01, 1.2100e+02, 3.1354e+02, 1.6900e+02, 2.5000e+01,

  75.                          1.0843e+01, 1.2100e+02, 3.3150e+02],

  76.                         [3.2145e+00, 3.3914e+01, 9.4728e+01, 4.5914e+01, 9.9142e+00,

  77.                          4.5858e+00, 3.3914e+01, 9.5685e+01],

  78.                         [1.0000e+00, 1.7157e-01, 1.5000e+00, 1.7157e-01, 1.7157e-01,

  79.                          5.0000e-01, 1.7157e-01, 7.5000e-01],

  80.                         [4.2893e-02, 2.5736e-01, 5.8579e-01, 2.5736e-01, 2.5736e-01,

  81.                          5.8579e-01, 2.5736e-01, 1.2868e-01],

  82.                         [5.0000e-01, 1.0000e+00, 8.5787e-02, 1.0000e+00, 1.0000e+00,

  83.                          5.0000e-01, 1.0000e+00, 6.2868e-01]]])

  84.     count_unequal_element(out, result, 0.0001, 0.0001)

  85. 

  86. 

  87. def test_spectrogram_window_hamming_padmode_constant():

  88.     """

  89.     Feature: test spectrogram parameter: window, pad_mode.

  90.     Description: test parameter.

  91.     Expectation: success.

  92.     """

  93.     logger.info("test_spectrogram_window_hamming_padmode_constant")

  94.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  95.     out = audio.Spectrogram(n_fft=8, window=WindowType.HAMMING,

  96.                             pad_mode=BorderType.CONSTANT)(np.array(wav, dtype="float"))

  97.     result = np.array([[[1.1389e+01, 1.3736e+02, 3.5534e+02, 2.0164e+02, 3.0914e+01,

  98.                          1.3465e+01, 1.3736e+02, 2.5064e+02],

  99.                         [5.6934e+00, 3.1860e+01, 8.5291e+01, 3.8484e+01, 9.1907e+00,

  100.                          4.5576e+00, 3.1860e+01, 1.0027e+02],

  101.                         [1.9633e-01, 7.4475e-02, 1.2696e+00, 7.4475e-02, 7.4475e-02,

  102.                          4.2320e-01, 7.4475e-02, 1.1765e+01],

  103.                         [5.0570e-01, 3.8456e-01, 6.8326e-01, 3.8456e-01, 3.8456e-01,

  104.                          6.8326e-01, 3.8456e-01, 5.4501e+00],

  105.                         [6.1665e-01, 8.4640e-01, 7.2610e-02, 8.4640e-01, 8.4640e-01,

  106.                          4.2320e-01, 8.4640e-01, 1.0642e+00]]])

  107.     count_unequal_element(out, result, 0.0001, 0.0001)

  108. 

  109. 

  110. def test_spectrogram_nfft_10_window_bartlett_padmode_edge():

  111.     """

  112.     Feature: test spectrogram parameter: n_fft, window, pad_mode.

  113.     Description: test parameter.

  114.     Expectation: success.

  115.     """

  116.     logger.info("test_spectrogram_nfft_10_window_bartlett_padmode_edge")

  117.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  118.     out = audio.Spectrogram(n_fft=10, window=WindowType.BARTLETT,

  119.                             pad_mode=BorderType.EDGE)(np.array(wav, dtype="float"))

  120.     result = np.array([[[4.0960e+01, 2.6244e+02, 4.0000e+02, 7.7440e+01, 2.5000e+01,

  121.                          2.6244e+02, 5.9536e+02],

  122.                         [4.7655e+00, 5.6721e+01, 9.4681e+01, 2.3822e+01, 5.9597e+00,

  123.                          5.6721e+01, 1.1597e+02],

  124.                         [5.3889e-01, 5.8360e-03, 9.2361e-01, 5.8359e-03, 9.2361e-01,

  125.                          5.8360e-03, 2.4944e-01],

  126.                         [1.1449e-01, 9.9859e-01, 3.1897e-01, 2.9828e-01, 1.0403e+00,

  127.                          9.9859e-01, 1.3072e+00],

  128.                         [1.8111e-01, 2.7416e-01, 4.7639e-01, 2.7416e-01, 4.7639e-01,

  129.                          2.7416e-01, 7.0557e-02],

  130.                         [6.4000e-01, 3.6000e-01, 0.0000e+00, 2.5600e+00, 1.0000e+00,

  131.                          3.6000e-01, 1.4400e+00]]])

  132.     count_unequal_element(out, result, 0.0001, 0.0001)

  133. 

  134. 

  135. def test_spectrogram_onsided_false():

  136.     """

  137.     Feature: test spectrogram parameter: onesided.

  138.     Description: test parameter.

  139.     Expectation: success.

  140.     """

  141.     logger.info("test_spectrogram_onsided_false")

  142.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  143.     out = audio.Spectrogram(n_fft=10, window=WindowType.BARTLETT,

  144.                             pad_mode=BorderType.EDGE, onesided=False)(np.array(wav, dtype="float"))

  145.     result = np.array([[[4.0960e+01, 2.6244e+02, 4.0000e+02, 7.7440e+01, 2.5000e+01,

  146.                          2.6244e+02, 5.9536e+02],

  147.                         [4.7655e+00, 5.6721e+01, 9.4681e+01, 2.3822e+01, 5.9597e+00,

  148.                          5.6721e+01, 1.1597e+02],

  149.                         [5.3889e-01, 5.8360e-03, 9.2361e-01, 5.8359e-03, 9.2361e-01,

  150.                          5.8360e-03, 2.4944e-01],

  151.                         [1.1449e-01, 9.9859e-01, 3.1897e-01, 2.9828e-01, 1.0403e+00,

  152.                          9.9859e-01, 1.3072e+00],

  153.                         [1.8111e-01, 2.7416e-01, 4.7639e-01, 2.7416e-01, 4.7639e-01,

  154.                          2.7416e-01, 7.0557e-02],

  155.                         [6.4000e-01, 3.6000e-01, 0.0000e+00, 2.5600e+00, 1.0000e+00,

  156.                          3.6000e-01, 1.4400e+00],

  157.                         [1.8111e-01, 2.7416e-01, 4.7639e-01, 2.7416e-01, 4.7639e-01,

  158.                          2.7416e-01, 7.0557e-02],

  159.                         [1.1449e-01, 9.9859e-01, 3.1897e-01, 2.9828e-01, 1.0403e+00,

  160.                          9.9859e-01, 1.3072e+00],

  161.                         [5.3889e-01, 5.8360e-03, 9.2361e-01, 5.8359e-03, 9.2361e-01,

  162.                          5.8360e-03, 2.4944e-01],

  163.                         [4.7655e+00, 5.6721e+01, 9.4681e+01, 2.3822e+01, 5.9597e+00,

  164.                          5.6721e+01, 1.1597e+02]]])

  165.     count_unequal_element(out, result, 0.0001, 0.0001)

  166. 

  167. 

  168. def test_spectrogram_power_0():

  169.     """

  170.     Feature: test spectrogram parameter: power.

  171.     Description: test parameter.

  172.     Expectation: success.

  173.     """

  174.     logger.info("test_spectrogram_power_0")

  175.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  176.     out = audio.Spectrogram(n_fft=8, window=WindowType.HANN,

  177.                             pad_mode=BorderType.REFLECT, power=0)(np.array(wav, dtype="float"))

  178.     result = np.array([[[[5.2929e+00, 0.0000e+00],

  179.                          [1.1000e+01, 0.0000e+00],

  180.                          [1.7707e+01, 0.0000e+00],

  181.                          [1.3000e+01, 0.0000e+00],

  182.                          [5.0000e+00, 0.0000e+00],

  183.                          [3.2929e+00, 0.0000e+00],

  184.                          [1.1000e+01, 0.0000e+00],

  185.                          [1.8207e+01, 0.0000e+00]],

  186.                         [[-1.7929e+00, -2.5288e-07],

  187.                          [-5.5000e+00, 1.9142e+00],

  188.                          [-9.7071e+00, 7.0711e-01],

  189.                          [-6.5000e+00, -1.9142e+00],

  190.                          [-2.5000e+00, -1.9142e+00],

  191.                          [-1.2929e+00, 1.7071e+00],

  192.                          [-5.5000e+00, 1.9142e+00],

  193.                          [-9.7071e+00, 1.2071e+00]],

  194.                         [[-1.0000e+00, 0.0000e+00],

  195.                          [0.0000e+00, -4.1421e-01],

  196.                          [1.0000e+00, -7.0711e-01],

  197.                          [0.0000e+00, 4.1421e-01],

  198.                          [0.0000e+00, 4.1421e-01],

  199.                          [0.0000e+00, -7.0711e-01],

  200.                          [0.0000e+00, -4.1421e-01],

  201.                          [5.0000e-01, -7.0711e-01]],

  202.                         [[-2.0711e-01, -2.5288e-07],

  203.                          [-5.0000e-01, -8.5787e-02],

  204.                          [-2.9289e-01, 7.0711e-01],

  205.                          [5.0000e-01, 8.5786e-02],

  206.                          [5.0000e-01, 8.5786e-02],

  207.                          [-7.0711e-01, -2.9289e-01],

  208.                          [-5.0000e-01, -8.5787e-02],

  209.                          [-2.9289e-01, 2.0711e-01]],

  210.                         [[7.0711e-01, 0.0000e+00],

  211.                          [1.0000e+00, 0.0000e+00],

  212.                          [2.9289e-01, 0.0000e+00],

  213.                          [-1.0000e+00, 0.0000e+00],

  214.                          [-1.0000e+00, 0.0000e+00],

  215.                          [7.0711e-01, 0.0000e+00],

  216.                          [1.0000e+00, 0.0000e+00],

  217.                          [7.9289e-01, 0.0000e+00]]]])

  218.     count_unequal_element(out, result, 0.0001, 0.0001)

  219. 

  220. 

  221. def test_spectrogram_center_false():

  222.     """

  223.     Feature: test spectrogram parameter: center.

  224.     Description: test parameter.

  225.     Expectation: success.

  226.     """

  227.     logger.info("test_spectrogram_center_false")

  228.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  229.     out = audio.Spectrogram(n_fft=8, window=WindowType.HANN,

  230.                             center=False, pad_mode=BorderType.REFLECT)(np.array(wav, dtype="float"))

  231.     result = np.array([[[1.2100e+02, 3.1354e+02, 1.6900e+02, 2.5000e+01, 1.0843e+01,

  232.                          1.2100e+02],

  233.                         [3.3914e+01, 9.4728e+01, 4.5914e+01, 9.9142e+00, 4.5858e+00,

  234.                          3.3914e+01],

  235.                         [1.7157e-01, 1.5000e+00, 1.7157e-01, 1.7157e-01, 5.0000e-01,

  236.                          1.7157e-01],

  237.                         [2.5736e-01, 5.8579e-01, 2.5736e-01, 2.5736e-01, 5.8579e-01,

  238.                          2.5736e-01],

  239.                         [1.0000e+00, 8.5787e-02, 1.0000e+00, 1.0000e+00, 5.0000e-01,

  240.                          1.0000e+00]]])

  241.     count_unequal_element(out, result, 0.0001, 0.0001)

  242. 

  243. 

  244. def test_spectrogram_normalized_true():

  245.     """

  246.     Feature: test spectrogram parameter: normalized.

  247.     Description: test parameter.

  248.     Expectation: success.

  249.     """

  250.     logger.info("test_spectrogram_normalized_true")

  251.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  252.     out = audio.Spectrogram(n_fft=8, window=WindowType.HANN,

  253.                             center=False, normalized=True, pad_mode=BorderType.REFLECT)(np.array(wav, dtype="float"))

  254.     result = np.array([[[4.0333e+01, 1.0451e+02, 5.6333e+01, 8.3333e+00, 3.6144e+00,

  255.                          4.0333e+01],

  256.                         [1.1305e+01, 3.1576e+01, 1.5305e+01, 3.3047e+00, 1.5286e+00,

  257.                          1.1305e+01],

  258.                         [5.7191e-02, 5.0000e-01, 5.7191e-02, 5.7191e-02, 1.6667e-01,

  259.                          5.7191e-02],

  260.                         [8.5786e-02, 1.9526e-01, 8.5786e-02, 8.5786e-02, 1.9526e-01,

  261.                          8.5786e-02],

  262.                         [3.3333e-01, 2.8596e-02, 3.3333e-01, 3.3333e-01, 1.6667e-01,

  263.                          3.3333e-01]]])

  264.     count_unequal_element(out, result, 0.0001, 0.0001)

  265. 

  266. 

  267. def test_spectrogram_inputrank_3():

  268.     """

  269.     Feature: test spectrogram parameter: input rank.

  270.     Description: test input rank.

  271.     Expectation: success.

  272.     """

  273.     logger.info("test_spectrogram_inputrank_3")

  274.     wav = np.array([[[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1]],

  275.                     [[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1]]])

  276.     out = audio.Spectrogram(n_fft=8, window=WindowType.HANN, pad_mode=BorderType.REFLECT)(np.array(wav, dtype="float"))

  277.     result = np.array([[[[2.8015e+01, 1.2100e+02, 3.1354e+02, 1.6900e+02, 3.3558e+01],

  278.                          [3.2145e+00, 3.3914e+01, 9.4728e+01, 4.5914e+01, 6.7145e+00],

  279.                          [1.0000e+00, 1.7157e-01, 1.5000e+00, 1.7157e-01, 7.5000e-01],

  280.                          [4.2893e-02, 2.5736e-01, 5.8579e-01, 2.5736e-01, 1.2868e-01],

  281.                          [5.0000e-01, 1.0000e+00, 8.5787e-02, 1.0000e+00, 6.2868e-01]]],

  282.                        [[[2.8015e+01, 1.2100e+02, 3.1354e+02, 1.6900e+02, 3.3558e+01],

  283.                          [3.2145e+00, 3.3914e+01, 9.4728e+01, 4.5914e+01, 6.7145e+00],

  284.                          [1.0000e+00, 1.7157e-01, 1.5000e+00, 1.7157e-01, 7.5000e-01],

  285.                          [4.2893e-02, 2.5736e-01, 5.8579e-01, 2.5736e-01, 1.2868e-01],

  286.                          [5.0000e-01, 1.0000e+00, 8.5787e-02, 1.0000e+00, 6.2868e-01]]]])

  287.     count_unequal_element(out, result, 0.0001, 0.0001)

  288. 

  289. 

  290. def test_spectrogram_winlength_7():

  291.     """

  292.     Feature: test spectrogram parameter: win_length.

  293.     Description: test parameter.

  294.     Expectation: success.

  295.     """

  296.     logger.info("test_spectrogram_winlength_7")

  297.     wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  298.     out = audio.Spectrogram(n_fft=8, win_length=7, window=WindowType.HANN,)(np.array(wav, dtype="float"))

  299.     result = np.array([[[2.0140e+01, 4.9000e+01, 1.5006e+02, 2.5284e+02, 1.5006e+02,

  300.                          4.9000e+01, 4.5220e+00, 1.2250e+01, 7.6562e+01, 1.9600e+02,

  301.                          2.7265e+02],

  302.                         [5.0272e+00, 1.9488e+01, 5.5103e+01, 1.0153e+02, 5.5103e+01,

  303.                          1.9488e+01, 2.0179e+00, 6.5089e+00, 2.9144e+01, 7.1406e+01,

  304.                          1.0662e+02],

  305.                         [4.2200e-01, 5.4020e-01, 1.0554e+00, 4.8321e+00, 1.0554e+00,

  306.                          5.4020e-01, 9.6867e-01, 4.0345e-01, 7.8188e-01, 1.0872e+00,

  307.                          3.3055e+00],

  308.                         [1.2817e-01, 3.8618e-01, 2.1917e-01, 2.6102e-01, 2.1917e-01,

  309.                          3.8618e-01, 4.3028e-01, 3.7738e-01, 2.0158e-01, 4.2135e-01,

  310.                          5.7616e-02],

  311.                         [3.7364e-01, 7.1574e-01, 8.1719e-01, 9.0949e-13, 8.1720e-01,

  312.                          7.1573e-01, 2.7823e-01, 7.1573e-01, 8.1719e-01, 7.1574e-01,

  313.                          3.7364e-01]]])

  314.     count_unequal_element(out, result, 0.0001, 0.0001)

  315. 

  316. 

  317. def test_spectrogram_param():

  318.     """

  319.     Feature: test spectrogram invalid parameter.

  320.     Description: test some invalid parameters.

  321.     Expectation: success.

  322.     """

  323.     try:

  324.         _ = audio.Spectrogram(n_fft=-1)

  325.     except ValueError as error:

  326.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  327.         assert "Input n_fft is not within the required interval of [1, 2147483647]." in str(error)

  328.     try:

  329.         _ = audio.Spectrogram(n_fft=0)

  330.     except ValueError as error:

  331.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  332.         assert "Input n_fft is not within the required interval of [1, 2147483647]." in str(error)

  333.     try:

  334.         _ = audio.Spectrogram(win_length=-1)

  335.     except ValueError as error:

  336.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  337.         assert "Input win_length is not within the required interval of [1, 2147483647]." in str(error)

  338.     try:

  339.         _ = audio.Spectrogram(win_length="s")

  340.     except TypeError as error:

  341.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  342.         assert "Argument win_length with value s is not of type [<class 'int'>], but got <class 'str'>." in str(error)

  343.     try:

  344.         _ = audio.Spectrogram(hop_length=-1)

  345.     except ValueError as error:

  346.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  347.         assert "Input hop_length is not within the required interval of [1, 2147483647]." in str(error)

  348.     try:

  349.         _ = audio.Spectrogram(hop_length=-100)

  350.     except ValueError as error:

  351.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  352.         assert "Input hop_length is not within the required interval of [1, 2147483647]." in str(error)

  353.     try:

  354.         _ = audio.Spectrogram(win_length=300, n_fft=200)

  355.     except ValueError as error:

  356.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  357.         assert "Input win_length should be no more than n_fft, but got win_length: 300 and n_fft: 200." \

  358.                in str(error)

  359.     try:

  360.         _ = audio.Spectrogram(pad=-1)

  361.     except ValueError as error:

  362.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  363.         assert "Input pad is not within the required interval of [0, 2147483647]." in str(error)

  364.     try:

  365.         _ = audio.Spectrogram(power=-1)

  366.     except ValueError as error:

  367.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  368.         assert "Input power is not within the required interval of [0, 16777216]." in str(error)

  369.     try:

  370.         _ = audio.Spectrogram(n_fft=False)

  371.     except TypeError as error:

  372.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  373.         assert "Argument n_fft with value False is not of type (<class 'int'>,)" in str(error)

  374.     try:

  375.         _ = audio.Spectrogram(n_fft="s")

  376.     except TypeError as error:

  377.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  378.         assert "Argument n_fft with value s is not of type [<class 'int'>], but got <class 'str'>." \

  379.                in str(error)

  380.     try:

  381.         _ = audio.Spectrogram(window=False)

  382.     except TypeError as error:

  383.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  384.         assert "Argument window with value False is not of type [<enum 'WindowType'>], but got <class 'bool'>." \

  385.                in str(error)

  386.     try:

  387.         _ = audio.Spectrogram(pad_mode=False)

  388.     except TypeError as error:

  389.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  390.         assert "Argument pad_mode with value False is not of type [<enum 'BorderType'>], but got <class 'bool'>." \

  391.                in str(error)

  392.     try:

  393.         _ = audio.Spectrogram(onesided="s")

  394.     except TypeError as error:

  395.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  396.         assert "Argument onesided with value s is not of type [<class 'bool'>], but got <class 'str'>." in str(error)

  397.     try:

  398.         _ = audio.Spectrogram(center="s")

  399.     except TypeError as error:

  400.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  401.         assert "Argument center with value s is not of type [<class 'bool'>], but got <class 'str'>." in str(error)

  402.     try:

  403.         _ = audio.Spectrogram(normalized="s")

  404.     except TypeError as error:

  405.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  406.         assert "Argument normalized with value s is not of type [<class 'bool'>], but got <class 'str'>." in str(error)

  407.     try:

  408.         _ = audio.Spectrogram(normalized=1)

  409.     except TypeError as error:

  410.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  411.         assert "Argument normalized with value 1 is not of type [<class 'bool'>], but got <class 'int'>." in str(error)

  412.     try:

  413.         wav = np.array([[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]])

  414.         _ = audio.Spectrogram(n_fft=100, center=False)(wav)

  415.     except RuntimeError as error:

  416.         logger.info("Got an exception in Spectrogram: {}".format(str(error)))

  417.         assert "Unexpected error. Spectrogram: n_fft should be more than 0 and less than 30," \

  418.                " but got n_fft: 100." in str(error)

  419. 

  420. 

  421. if __name__ == "__main__":

  422.     test_spectrogram_pipeline()

  423.     test_spectrogram_eager()

  424.     test_spectrogram_window_hamming_padmode_constant()

  425.     test_spectrogram_nfft_10_window_bartlett_padmode_edge()

  426.     test_spectrogram_onsided_false()

  427.     test_spectrogram_power_0()

  428.     test_spectrogram_center_false()

  429.     test_spectrogram_normalized_true()

  430.     test_spectrogram_inputrank_3()

  431.     test_spectrogram_winlength_7()

  432.     test_spectrogram_param()