Updated thw whole test folder.

Signed-off-by: VahidooX <vnoroozi@nvidia.com>

tests/asr/test_asr.py

@@ -164,14 +164,14 @@ def remove_test_json():
             for s in test_strings:
                 f.write('{"audio_filepath": "", "duration": 1.0, "text": ' f'"{s}"}}\n')
         parser = parsers.make_parser(self.labels, 'en')
-        manifest = collections.ASRAudioText(manifests_files=[manifest_paths], parser=parser,)
+        manifest = collections.ASRAudioText(manifests_files=[manifest_paths], parser=parser)
 
         for i, s in enumerate(normalized_strings):
             self.assertTrue(manifest[i].text_tokens == parser(s))
 
     def test_pytorch_audio_dataset(self):
         featurizer = WaveformFeaturizer.from_config(self.featurizer_config)
-        ds = AudioDataset(manifest_filepath=self.manifest_filepath, labels=self.labels, featurizer=featurizer,)
+        ds = AudioDataset(manifest_filepath=self.manifest_filepath, labels=self.labels, featurizer=featurizer)
 
         for i in range(len(ds)):
             if i == 5:
@@ -218,7 +218,7 @@ def create_good_preprocessor_1():
 
         def create_good_preprocessor_2():
             nemo_asr.AudioToMelSpectrogramPreprocessor(
-                window_size=None, window_stride=None, n_window_size=256, n_window_stride=32,
+                window_size=None, window_stride=None, n_window_size=256, n_window_stride=32
             )
 
         self.assertRaises(ValueError, create_broken_preprocessor_1)
@@ -361,19 +361,19 @@ def test_jasper_training(self):
         # print(jasper_encoder)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}
         )
 
     def test_double_jasper_training(self):
@@ -424,17 +424,17 @@ def test_double_jasper_training(self):
         log_probs = mx_max1(x1=log_probs1, x2=log_probs2)
         encoded_len = mx_max2(x1=encoded_len1, x2=encoded_len2)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(tensors=[loss], print_func=lambda x: print(str(x[0].item())))
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}
         )
 
     def test_quartznet_training(self):
@@ -474,19 +474,19 @@ def test_quartznet_training(self):
         encoded, encoded_len = jasper_encoder(audio_signal=processed_signal, length=p_length)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}
         )
 
     def test_stft_conv(self):
@@ -528,17 +528,17 @@ def test_stft_conv(self):
         # print(jasper_encoder)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(tensors=[loss], print_func=lambda x: print(str(x[0].item())))
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}
         )
 
     def test_clas(self):
@@ -570,7 +570,7 @@ def test_clas(self):
             feat_in=cfg['input']['train']['features'],
         )
         connector = nemo_asr.JasperRNNConnector(
-            in_channels=cfg['encoder']['jasper'][-1]['filters'], out_channels=cfg['decoder']['hidden_size'],
+            in_channels=cfg['encoder']['jasper'][-1]['filters'], out_channels=cfg['decoder']['hidden_size']
         )
         decoder = nemo.backends.pytorch.common.DecoderRNN(
             voc_size=len(self.labels), bos_id=0, **cfg['decoder']  # fictive
@@ -589,11 +589,11 @@ def test_clas(self):
         callback = nemo.core.SimpleLossLoggerCallback(tensors=[loss], print_func=lambda x: print(str(x[0].item())))
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}
         )
 
     def test_jasper_eval(self):
@@ -633,14 +633,11 @@ def test_jasper_eval(self):
         # print(jasper_encoder)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
         predictions = greedy_decoder(log_probs=log_probs)
 
-        from nemo.collections.asr.helpers import (
-            process_evaluation_batch,
-            process_evaluation_epoch,
-        )
+        from nemo.collections.asr.helpers import process_evaluation_batch, process_evaluation_epoch
 
         eval_callback = nemo.core.EvaluatorCallback(
             eval_tensors=[loss, predictions, transcript, transcript_len],
@@ -649,7 +646,7 @@ def test_jasper_eval(self):
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         neural_factory.eval(callbacks=[eval_callback])
 

tests/asr/test_weight_share.py

@@ -106,7 +106,7 @@ def __check_if_weights_are_equal(self, w1: Dict, w2: Dict):
         else:
             for key in w1.keys():
                 all_same = all_same and np.array_equal(
-                    w1[key][0].cpu().detach().numpy(), w2[key][0].cpu().detach().numpy(),
+                    w1[key][0].cpu().detach().numpy(), w2[key][0].cpu().detach().numpy()
                 )
         return all_same
 
@@ -141,16 +141,16 @@ def test_tie_weights2(self):
         embd.tie_weights_with(
             proj,
             weight_names=["embedding.weight"],
-            name2name_and_transform={"embedding.weight": ("projection.weight", WeightShareTransform.SAME,)},
+            name2name_and_transform={"embedding.weight": ("projection.weight", WeightShareTransform.SAME)},
         )
         self.assertTrue(
-            np.array_equal(embd.embedding.weight.detach().numpy(), proj.projection.weight.detach().numpy(),)
+            np.array_equal(embd.embedding.weight.detach().numpy(), proj.projection.weight.detach().numpy())
         )
         was = embd.embedding.weight.detach().numpy()
         embd.embedding.weight.data = torch.tensor(np.random.randint(0, 10, (3, 2)) * 1.0)
         after = embd.embedding.weight.detach().numpy()
         self.assertTrue(
-            np.array_equal(embd.embedding.weight.detach().numpy(), proj.projection.weight.detach().numpy(),)
+            np.array_equal(embd.embedding.weight.detach().numpy(), proj.projection.weight.detach().numpy())
         )
         self.assertFalse(np.array_equal(was, after))
 
@@ -161,9 +161,9 @@ def test_set_weights(self):
         weights = torch.tensor(np.random.randint(0, 10, (3, 2)) * 1.0)
         name2weights = {"embedding.weight": (weights, True)}
         embd.set_weights(name2weight=name2weights)
-        self.assertTrue(np.array_equal(embd.embedding.weight.detach().numpy(), weights.detach().numpy(),))
+        self.assertTrue(np.array_equal(embd.embedding.weight.detach().numpy(), weights.detach().numpy()))
         weights = torch.tensor(np.random.randint(0, 10, (3, 2)) * 1.0)
-        self.assertFalse(np.array_equal(embd.embedding.weight.detach().numpy(), weights.detach().numpy(),))
+        self.assertFalse(np.array_equal(embd.embedding.weight.detach().numpy(), weights.detach().numpy()))
 
     def test_freeze_unfreeze_TrainableNM(self):
         path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../data/jasper_smaller.yaml"))
@@ -205,24 +205,24 @@ def test_freeze_unfreeze_TrainableNM(self):
         # print(jasper_encoder)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 2, "lr": 0.0003},
+            [loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 2, "lr": 0.0003}
         )
 
     def test_freeze_unfreeze_Wrapper(self):
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, placement=nemo.core.DeviceType.GPU, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, placement=nemo.core.DeviceType.GPU, create_tb_writer=False
         )
 
         dl_train = nemo.backends.pytorch.ZerosDataLayer(
@@ -244,7 +244,7 @@ def test_freeze_unfreeze_Wrapper(self):
 
         # NOTICE: pretrain=True argument
         resnet = neural_factory.get_module(
-            name="resnet18", params={"num_classes": 2}, collection="torchvision", pretrained=True,
+            name="resnet18", params={"num_classes": 2}, collection="torchvision", pretrained=True
         )
 
         L_train = neural_factory.get_module(name="CrossEntropyLoss", collection="toys", params={})
@@ -259,13 +259,13 @@ def test_freeze_unfreeze_Wrapper(self):
         train_loss = L_train(predictions=outputs, labels=labels)
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[train_loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[train_loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         optimizer = neural_factory.get_trainer()
         optimizer.train(
-            [train_loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 2, "lr": 0.0003},
+            [train_loss], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 2, "lr": 0.0003}
         )

tests/asr/test_zeroDS.py

@@ -105,10 +105,10 @@ def test_simple_train(self):
         loss_tensor = loss(predictions=y_pred, target=y)
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[loss_tensor], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[loss_tensor], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         neural_factory.train(
-            [loss_tensor], callbacks=[callback], optimization_params={"num_epochs": 3, "lr": 0.0003}, optimizer="sgd",
+            [loss_tensor], callbacks=[callback], optimization_params={"num_epochs": 3, "lr": 0.0003}, optimizer="sgd"
         )
 
     def test_asr_with_zero_ds(self):
@@ -148,16 +148,16 @@ def test_asr_with_zero_ds(self):
         # print(jasper_encoder)
         log_probs = jasper_decoder(encoder_output=encoded)
         loss = ctc_loss(
-            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len,
+            log_probs=log_probs, targets=transcript, input_length=encoded_len, target_length=transcript_len
         )
 
         callback = nemo.core.SimpleLossLoggerCallback(
-            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'),
+            tensors=[loss], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}')
         )
         # Instantiate an optimizer to perform `train` action
         neural_factory = nemo.core.NeuralModuleFactory(
-            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False,
+            backend=nemo.core.Backend.PyTorch, local_rank=None, create_tb_writer=False
         )
         neural_factory.train(
-            [loss], callbacks=[callback], optimization_params={"num_epochs": 2, "lr": 0.0003}, optimizer="sgd",
+            [loss], callbacks=[callback], optimization_params={"num_epochs": 2, "lr": 0.0003}, optimizer="sgd"
         )