Replace pytest's paremeterization with parameterized (#1157)

Also replaces `assert_allclose` with `assertEqual`.

Co-authored-by: krishnakalyan3 <[email protected]>

Author: krishnakalyan3

test/torchaudio_unittest/functional/functional_cpu_test.py

@@ -5,6 +5,7 @@
 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,15 +54,15 @@ def test_one_channel(self):
         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],
                                   [1.0, 2.0, 3.0, 4.0]]])
         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 @@ def test_DB_to_amplitude(self):
         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,61 +113,66 @@ def test_DB_to_amplitude(self):
         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):
-    expected_norm_tensor = complex_tensor.pow(2).sum(-1).pow(power / 2)
-    norm_tensor = F.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)
+        self.assertEqual(norm_tensor, expected_norm_tensor, atol=1e-5, rtol=1e-5)
 
-    torch.testing.assert_allclose(norm_tensor, expected_norm_tensor, atol=1e-5, rtol=1e-5)
 
+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)
 
-@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):
+        other_axis = 1 if axis == 2 else 2
 
-    mask_specgram = F.mask_along_axis(specgram, mask_param, mask_value, axis)
+        masked_columns = (mask_specgram == mask_value).sum(other_axis)
+        num_masked_columns = (masked_columns == mask_specgram.size(other_axis)).sum()
+        num_masked_columns //= mask_specgram.size(0)
 
-    other_axis = 1 if axis == 2 else 2
+        assert mask_specgram.size() == specgram.size()
+        assert num_masked_columns < mask_param
 
-    masked_columns = (mask_specgram == mask_value).sum(other_axis)
-    num_masked_columns = (masked_columns == mask_specgram.size(other_axis)).sum()
-    num_masked_columns //= mask_specgram.size(0)
 
-    assert mask_specgram.size() == specgram.size()
-    assert num_masked_columns < mask_param
+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)
 
+        mask_specgrams = F.mask_along_axis_iid(specgrams, mask_param, mask_value, axis)
 
-@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):
-    torch.random.manual_seed(42)
-    specgrams = torch.randn(4, 2, 1025, 400)
+        other_axis = 2 if axis == 3 else 3
 
-    mask_specgrams = F.mask_along_axis_iid(specgrams, mask_param, mask_value, axis)
+        masked_columns = (mask_specgrams == mask_value).sum(other_axis)
+        num_masked_columns = (masked_columns == mask_specgrams.size(other_axis)).sum(-1)
 
-    other_axis = 2 if axis == 3 else 3
-
-    masked_columns = (mask_specgrams == mask_value).sum(other_axis)
-    num_masked_columns = (masked_columns == mask_specgrams.size(other_axis)).sum(-1)
-
-    assert mask_specgrams.size() == specgrams.size()
-    assert (num_masked_columns < mask_param).sum() == num_masked_columns.numel()
+        assert mask_specgrams.size() == specgrams.size()
+        assert (num_masked_columns < mask_param).sum() == num_masked_columns.numel()

test/torchaudio_unittest/librosa_compatibility_test.py

@@ -7,6 +7,8 @@
 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,42 +113,49 @@ def test_amplitude_to_DB(self):
         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):
-    # 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.
-
-    complex_specgrams = complex_specgrams.type(torch.float64)
-    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)
-
-    # == Test shape
-    expected_size = list(complex_specgrams.size())
-    expected_size[-2] = int(np.ceil(expected_size[-2] / rate))
-
-    assert complex_specgrams.dim() == complex_specgrams_stretch.dim()
-    assert complex_specgrams_stretch.size() == torch.Size(expected_size)
-
-    # == Test values
-    index = [0] * (complex_specgrams.dim() - 3) + [slice(None)] * 3
-    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,
-                                                     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)
+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]
+
+        complex_specgrams_stretch = F.phase_vocoder(complex_specgrams, rate=rate, phase_advance=phase_advance)
+
+        # == Test shape
+        expected_size = list(complex_specgrams.size())
+        expected_size[-2] = int(np.ceil(expected_size[-2] / rate))
+
+        assert complex_specgrams.dim() == complex_specgrams_stretch.dim()
+        assert complex_specgrams_stretch.size() == torch.Size(expected_size)
+
+        # == Test values
+        index = [0] * (complex_specgrams.dim() - 3) + [slice(None)] * 3
+        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,
+            rate=rate,
+            hop_length=hop_length)
+
+        complex_stretch = complex_specgrams_stretch[index].numpy()
+        complex_stretch = complex_stretch[..., 0] + 1j * complex_stretch[..., 1]
+
+        self.assertEqual(complex_stretch, torch.from_numpy(expected_complex_stretch), atol=1e-5, rtol=1e-5)
 
 
 def _load_audio_asset(*asset_paths, **kwargs):