Replace pytest's paremeterization with parameterized (#1157)

Also replaces `assert_allclose` with `assertEqual`.
Co-authored-by: krishnakalyan3 <skalyan@cloudera.com>

test/torchaudio_unittest/functional/functional_cpu_test.py

@@ -5,6 +5,7 @@ import torchaudio
 import torchaudio.functional as F
 from parameterized import parameterized
 import pytest
+import itertools
 
 from torchaudio_unittest import common_utils
 from .functional_impl import Lfilter, Spectrogram
@@ -53,7 +54,7 @@ class TestComputeDeltas(common_utils.TorchaudioTestCase):
         specgram = torch.tensor([[[1.0, 2.0, 3.0, 4.0]]])
         expected = torch.tensor([[[0.5, 1.0, 1.0, 0.5]]])
         computed = F.compute_deltas(specgram, win_length=3)
-        torch.testing.assert_allclose(computed, expected)
+        self.assertEqual(computed, expected)
 
     def test_two_channels(self):
         specgram = torch.tensor([[[1.0, 2.0, 3.0, 4.0],
@@ -61,7 +62,7 @@ class TestComputeDeltas(common_utils.TorchaudioTestCase):
         expected = torch.tensor([[[0.5, 1.0, 1.0, 0.5],
                                   [0.5, 1.0, 1.0, 0.5]]])
         computed = F.compute_deltas(specgram, win_length=3)
-        torch.testing.assert_allclose(computed, expected)
+        self.assertEqual(computed, expected)
 
 
 class TestDetectPitchFrequency(common_utils.TorchaudioTestCase):
@@ -97,13 +98,13 @@ class TestDB_to_amplitude(common_utils.TorchaudioTestCase):
         db = F.amplitude_to_DB(torch.abs(x), multiplier, amin, db_multiplier, top_db=None)
         x2 = F.DB_to_amplitude(db, ref, power)
 
-        torch.testing.assert_allclose(x2, torch.abs(x), atol=5e-5, rtol=1e-5)
+        self.assertEqual(x2, torch.abs(x), atol=5e-5, rtol=1e-5)
 
         # Spectrogram amplitude -> DB -> amplitude
         db = F.amplitude_to_DB(spec, multiplier, amin, db_multiplier, top_db=None)
         x2 = F.DB_to_amplitude(db, ref, power)
 
-        torch.testing.assert_allclose(x2, spec, atol=5e-5, rtol=1e-5)
+        self.assertEqual(x2, spec, atol=5e-5, rtol=1e-5)
 
         # Waveform power -> DB -> power
         multiplier = 10.
@@ -112,36 +113,38 @@ class TestDB_to_amplitude(common_utils.TorchaudioTestCase):
         db = F.amplitude_to_DB(x, multiplier, amin, db_multiplier, top_db=None)
         x2 = F.DB_to_amplitude(db, ref, power)
 
-        torch.testing.assert_allclose(x2, torch.abs(x), atol=5e-5, rtol=1e-5)
+        self.assertEqual(x2, torch.abs(x), atol=5e-5, rtol=1e-5)
 
         # Spectrogram power -> DB -> power
         db = F.amplitude_to_DB(spec, multiplier, amin, db_multiplier, top_db=None)
         x2 = F.DB_to_amplitude(db, ref, power)
 
-        torch.testing.assert_allclose(x2, spec, atol=5e-5, rtol=1e-5)
+        self.assertEqual(x2, spec, atol=5e-5, rtol=1e-5)
 
 
-@pytest.mark.parametrize('complex_tensor', [
-    torch.randn(1, 2, 1025, 400, 2),
-    torch.randn(1025, 400, 2)
-])
-@pytest.mark.parametrize('power', [1, 2, 0.7])
-def test_complex_norm(complex_tensor, power):
+class TestComplexNorm(common_utils.TorchaudioTestCase):
+    @parameterized.expand(list(itertools.product(
+        [(1, 2, 1025, 400, 2), (1025, 400, 2)],
+        [1, 2, 0.7]
+    )))
+    def test_complex_norm(self, shape, power):
+        torch.random.manual_seed(42)
+        complex_tensor = torch.randn(*shape)
         expected_norm_tensor = complex_tensor.pow(2).sum(-1).pow(power / 2)
         norm_tensor = F.complex_norm(complex_tensor, power)
-
-    torch.testing.assert_allclose(norm_tensor, expected_norm_tensor, atol=1e-5, rtol=1e-5)
+        self.assertEqual(norm_tensor, expected_norm_tensor, atol=1e-5, rtol=1e-5)
 
 
-@pytest.mark.parametrize('specgram', [
-    torch.randn(2, 1025, 400),
-    torch.randn(1, 201, 100)
-])
-@pytest.mark.parametrize('mask_param', [100])
-@pytest.mark.parametrize('mask_value', [0., 30.])
-@pytest.mark.parametrize('axis', [1, 2])
-def test_mask_along_axis(specgram, mask_param, mask_value, axis):
-
+class TestMaskAlongAxis(common_utils.TorchaudioTestCase):
+    @parameterized.expand(list(itertools.product(
+        [(2, 1025, 400), (1, 201, 100)],
+        [100],
+        [0., 30.],
+        [1, 2]
+    )))
+    def test_mask_along_axis(self, shape, mask_param, mask_value, axis):
+        torch.random.manual_seed(42)
+        specgram = torch.randn(*shape)
         mask_specgram = F.mask_along_axis(specgram, mask_param, mask_value, axis)
 
         other_axis = 1 if axis == 2 else 2
@@ -154,10 +157,13 @@ def test_mask_along_axis(specgram, mask_param, mask_value, axis):
         assert num_masked_columns < mask_param
 
 
-@pytest.mark.parametrize('mask_param', [100])
-@pytest.mark.parametrize('mask_value', [0., 30.])
-@pytest.mark.parametrize('axis', [2, 3])
-def test_mask_along_axis_iid(mask_param, mask_value, axis):
+class TestMaskAlongAxisIID(common_utils.TorchaudioTestCase):
+    @parameterized.expand(list(itertools.product(
+        [100],
+        [0., 30.],
+        [2, 3]
+    )))
+    def test_mask_along_axis_iid(self, mask_param, mask_value, axis):
         torch.random.manual_seed(42)
         specgrams = torch.randn(4, 2, 1025, 400)
 

test/torchaudio_unittest/librosa_compatibility_test.py

@@ -7,6 +7,8 @@ import torch
 import torchaudio
 import torchaudio.functional as F
 from torchaudio._internal.module_utils import is_module_available
+from parameterized import parameterized
+import itertools
 
 LIBROSA_AVAILABLE = is_module_available('librosa')
 
@@ -111,19 +113,25 @@ class TestFunctional(common_utils.TorchaudioTestCase):
         self.assertEqual(ta_out, lr_out, atol=5e-5, rtol=1e-5)
 
 
-@pytest.mark.parametrize('complex_specgrams', [
-    torch.randn(2, 1025, 400, 2)
-])
-@pytest.mark.parametrize('rate', [0.5, 1.01, 1.3])
-@pytest.mark.parametrize('hop_length', [256])
 @unittest.skipIf(not LIBROSA_AVAILABLE, "Librosa not available")
-def test_phase_vocoder(complex_specgrams, rate, hop_length):
+class TestPhaseVocoder(common_utils.TorchaudioTestCase):
+    @parameterized.expand(list(itertools.product(
+        [(2, 1025, 400, 2)],
+        [0.5, 1.01, 1.3],
+        [256]
+    )))
+    def test_phase_vocoder(self, shape, rate, hop_length):
         # Due to cummulative sum, numerical error in using torch.float32 will
         # result in bottom right values of the stretched sectrogram to not
         # match with librosa.
-
+        torch.random.manual_seed(42)
+        complex_specgrams = torch.randn(*shape)
         complex_specgrams = complex_specgrams.type(torch.float64)
-    phase_advance = torch.linspace(0, np.pi * hop_length, complex_specgrams.shape[-3], dtype=torch.float64)[..., None]
+        phase_advance = torch.linspace(
+            0,
+            np.pi * hop_length,
+            complex_specgrams.shape[-3],
+            dtype=torch.float64)[..., None]
 
         complex_specgrams_stretch = F.phase_vocoder(complex_specgrams, rate=rate, phase_advance=phase_advance)
 
@@ -139,14 +147,15 @@ def test_phase_vocoder(complex_specgrams, rate, hop_length):
         mono_complex_specgram = complex_specgrams[index].numpy()
         mono_complex_specgram = mono_complex_specgram[..., 0] + \
             mono_complex_specgram[..., 1] * 1j
-    expected_complex_stretch = librosa.phase_vocoder(mono_complex_specgram,
+        expected_complex_stretch = librosa.phase_vocoder(
+            mono_complex_specgram,
             rate=rate,
             hop_length=hop_length)
 
         complex_stretch = complex_specgrams_stretch[index].numpy()
         complex_stretch = complex_stretch[..., 0] + 1j * complex_stretch[..., 1]
 
-    assert np.allclose(complex_stretch, expected_complex_stretch, atol=1e-5)
+        self.assertEqual(complex_stretch, torch.from_numpy(expected_complex_stretch), atol=1e-5, rtol=1e-5)
 
 
 def _load_audio_asset(*asset_paths, **kwargs):