Fixup

tests/aux_tests/test_speaker_manager.py

@@ -22,42 +22,42 @@ d_vectors_file_pth_path = os.path.join(get_tests_input_path(), "../data/dummy_sp
 class SpeakerManagerTest(unittest.TestCase):
     """Test SpeakerManager for loading embedding files and computing d_vectors from waveforms"""
 
-    # @staticmethod
+    @staticmethod
-    # def test_speaker_embedding():
+    def test_speaker_embedding():
-    #     # load config
+        # load config
-    #     config = load_config(encoder_config_path)
+        config = load_config(encoder_config_path)
-    #     config.audio.resample = True
+        config.audio.resample = True
 
-    #     # create a dummy speaker encoder
+        # create a dummy speaker encoder
-    #     model = setup_encoder_model(config)
+        model = setup_encoder_model(config)
-    #     save_checkpoint(model, None, None, get_tests_input_path(), 0)
+        save_checkpoint(model, None, None, get_tests_input_path(), 0)
 
-    #     # load audio processor and speaker encoder
+        # load audio processor and speaker encoder
-    #     ap = AudioProcessor(**config.audio)
+        ap = AudioProcessor(**config.audio)
-    #     manager = SpeakerManager(encoder_model_path=encoder_model_path, encoder_config_path=encoder_config_path)
+        manager = SpeakerManager(encoder_model_path=encoder_model_path, encoder_config_path=encoder_config_path)
 
-    #     # load a sample audio and compute embedding
+        # load a sample audio and compute embedding
-    #     waveform = ap.load_wav(sample_wav_path)
+        waveform = ap.load_wav(sample_wav_path)
-    #     mel = ap.melspectrogram(waveform)
+        mel = ap.melspectrogram(waveform)
-    #     d_vector = manager.compute_embeddings(mel)
+        d_vector = manager.compute_embeddings(mel)
-    #     assert d_vector.shape[1] == 256
+        assert d_vector.shape[1] == 256
 
-    #     # compute d_vector directly from an input file
+        # compute d_vector directly from an input file
-    #     d_vector = manager.compute_embedding_from_clip(sample_wav_path)
+        d_vector = manager.compute_embedding_from_clip(sample_wav_path)
-    #     d_vector2 = manager.compute_embedding_from_clip(sample_wav_path)
+        d_vector2 = manager.compute_embedding_from_clip(sample_wav_path)
-    #     d_vector = torch.FloatTensor(d_vector)
+        d_vector = torch.FloatTensor(d_vector)
-    #     d_vector2 = torch.FloatTensor(d_vector2)
+        d_vector2 = torch.FloatTensor(d_vector2)
-    #     assert d_vector.shape[0] == 256
+        assert d_vector.shape[0] == 256
-    #     assert (d_vector - d_vector2).sum() == 0.0
+        assert (d_vector - d_vector2).sum() == 0.0
 
-    #     # compute d_vector from a list of wav files.
+        # compute d_vector from a list of wav files.
-    #     d_vector3 = manager.compute_embedding_from_clip([sample_wav_path, sample_wav_path2])
+        d_vector3 = manager.compute_embedding_from_clip([sample_wav_path, sample_wav_path2])
-    #     d_vector3 = torch.FloatTensor(d_vector3)
+        d_vector3 = torch.FloatTensor(d_vector3)
-    #     assert d_vector3.shape[0] == 256
+        assert d_vector3.shape[0] == 256
-    #     assert (d_vector - d_vector3).sum() != 0.0
+        assert (d_vector - d_vector3).sum() != 0.0
 
-    #     # remove dummy model
+        # remove dummy model
-    #     os.remove(encoder_model_path)
+        os.remove(encoder_model_path)
 
     def test_speakers_file_processing(self):
         manager = SpeakerManager(d_vectors_file_path=d_vectors_file_path)