From 4f8126048286a0dde97856a57431ca9c074108c7 Mon Sep 17 00:00:00 2001 From: VahidooX Date: Fri, 31 Jan 2020 12:56:23 -0800 Subject: [PATCH] Updated thw whole test folder. Signed-off-by: VahidooX --- tests/asr/test_asr.py | 49 ++++++++++++++++------------------ tests/asr/test_weight_share.py | 30 ++++++++++----------- tests/asr/test_zeroDS.py | 12 ++++----- tests/test_deploy_export.py | 27 ++++++++++--------- tests/test_infer.py | 8 +++--- tests/test_neural_factory.py | 10 +++---- tests/test_neural_types.py | 42 ++++++++++++++--------------- tests/test_pytorch_trainers.py | 12 ++++----- tests/tts/test_tts.py | 24 ++++++++--------- 9 files changed, 102 insertions(+), 112 deletions(-) diff --git a/tests/asr/test_asr.py b/tests/asr/test_asr.py index 1f21df4f07e0..7958c4805277 100644 --- a/tests/asr/test_asr.py +++ b/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]) diff --git a/tests/asr/test_weight_share.py b/tests/asr/test_weight_share.py index b5840630d1fd..8a5245135c48 100644 --- a/tests/asr/test_weight_share.py +++ b/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} ) diff --git a/tests/asr/test_zeroDS.py b/tests/asr/test_zeroDS.py index 304d63d67d9e..ae0232735739 100644 --- a/tests/asr/test_zeroDS.py +++ b/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" ) diff --git a/tests/test_deploy_export.py b/tests/test_deploy_export.py index a2194807512a..bbb7a7c64661 100644 --- a/tests/test_deploy_export.py +++ b/tests/test_deploy_export.py @@ -25,6 +25,7 @@ import nemo import nemo.collections.asr as nemo_asr import nemo.collections.nlp as nemo_nlp +import nemo.collections.nlp.nm.trainables.common.token_classification_nm from tests.common_setup import NeMoUnitTest @@ -37,9 +38,7 @@ def __test_export_route(self, module, out_name, mode, input_example=None): if out.exists(): os.remove(out) - self.nf.deployment_export( - module=module, output=out_name, input_example=input_example, d_format=mode, - ) + self.nf.deployment_export(module=module, output=out_name, input_example=input_example, d_format=mode) self.assertTrue(out.exists()) if out.exists(): @@ -55,7 +54,9 @@ def test_simple_module_export(self): ) def test_TokenClassifier_module_export(self): - t_class = nemo_nlp.TokenClassifier(hidden_size=512, num_classes=16, use_transformer_pretrained=False) + t_class = nemo.collections.nlp.nm.trainables.common.token_classification_nm.TokenClassifier( + hidden_size=512, num_classes=16, use_transformer_pretrained=False + ) self.__test_export_route( module=t_class, out_name="t_class.pt", @@ -64,7 +65,9 @@ def test_TokenClassifier_module_export(self): ) def test_TokenClassifier_module_onnx_export(self): - t_class = nemo_nlp.TokenClassifier(hidden_size=512, num_classes=16, use_transformer_pretrained=False) + t_class = nemo.collections.nlp.nm.trainables.common.token_classification_nm.TokenClassifier( + hidden_size=512, num_classes=16, use_transformer_pretrained=False + ) self.__test_export_route( module=t_class, out_name="t_class.onnx", @@ -75,25 +78,23 @@ def test_TokenClassifier_module_onnx_export(self): def test_jasper_decoder_export_ts(self): j_decoder = nemo_asr.JasperDecoderForCTC(feat_in=1024, num_classes=33) self.__test_export_route( - module=j_decoder, out_name="j_decoder.ts", mode=nemo.core.DeploymentFormat.TORCHSCRIPT, input_example=None, + module=j_decoder, out_name="j_decoder.ts", mode=nemo.core.DeploymentFormat.TORCHSCRIPT, input_example=None ) def test_hf_bert_ts(self): - bert = nemo_nlp.huggingface.BERT(pretrained_model_name="bert-base-uncased") + bert = nemo.collections.nlp.nm.trainables.common.huggingface.BERT(pretrained_model_name="bert-base-uncased") input_example = ( torch.randint(low=0, high=16, size=(2, 16)).cuda(), torch.randint(low=0, high=1, size=(2, 16)).cuda(), torch.randint(low=0, high=1, size=(2, 16)).cuda(), ) self.__test_export_route( - module=bert, out_name="bert.ts", mode=nemo.core.DeploymentFormat.TORCHSCRIPT, input_example=input_example, + module=bert, out_name="bert.ts", mode=nemo.core.DeploymentFormat.TORCHSCRIPT, input_example=input_example ) def test_hf_bert_pt(self): - bert = nemo_nlp.huggingface.BERT(pretrained_model_name="bert-base-uncased") - self.__test_export_route( - module=bert, out_name="bert.pt", mode=nemo.core.DeploymentFormat.PYTORCH, - ) + bert = nemo.collections.nlp.nm.trainables.common.huggingface.BERT(pretrained_model_name="bert-base-uncased") + self.__test_export_route(module=bert, out_name="bert.pt", mode=nemo.core.DeploymentFormat.PYTORCH) def test_jasper_encoder_to_onnx(self): with open("tests/data/jasper_smaller.yaml") as file: @@ -110,5 +111,5 @@ def test_jasper_encoder_to_onnx(self): module=jasper_encoder, out_name="jasper_encoder.onnx", mode=nemo.core.DeploymentFormat.ONNX, - input_example=(torch.randn(16, 64, 256).cuda(), torch.randn(256).cuda(),), + input_example=(torch.randn(16, 64, 256).cuda(), torch.randn(256).cuda()), ) diff --git a/tests/test_infer.py b/tests/test_infer.py index 8e83ca1a0f2b..7de67ed5ad05 100644 --- a/tests/test_infer.py +++ b/tests/test_infer.py @@ -105,22 +105,20 @@ def test_infer_errors(self): with self.assertRaisesRegex(ValueError, "use_cache was set, but cache was empty"): evaluated_tensors = neural_factory.infer( - tensors=[twenty_tensor, thirty_tensor], verbose=False, use_cache=True, + tensors=[twenty_tensor, thirty_tensor], verbose=False, use_cache=True ) new_ten_tensor = minusten(mod_in=twenty_tensor) evaluated_tensors = neural_factory.infer(tensors=[new_ten_tensor], verbose=False, cache=True) with self.assertRaisesRegex(ValueError, "cache was set but was not empty"): - evaluated_tensors = neural_factory.infer( - tensors=[twenty_tensor, thirty_tensor], verbose=False, cache=True, - ) + evaluated_tensors = neural_factory.infer(tensors=[twenty_tensor, thirty_tensor], verbose=False, cache=True) neural_factory.clear_cache() evaluated_tensors = neural_factory.infer(tensors=[new_ten_tensor], verbose=False, cache=True) with self.assertRaisesRegex(ValueError, "cache and use_cache were both set."): evaluated_tensors = neural_factory.infer( - tensors=[twenty_tensor, thirty_tensor], verbose=False, cache=True, use_cache=True, + tensors=[twenty_tensor, thirty_tensor], verbose=False, cache=True, use_cache=True ) self.assertEqual(evaluated_tensors[0][0].squeeze().data, 10) diff --git a/tests/test_neural_factory.py b/tests/test_neural_factory.py index 83db0f16e4c8..f8785380c723 100644 --- a/tests/test_neural_factory.py +++ b/tests/test_neural_factory.py @@ -23,17 +23,17 @@ class TestNeuralFactory(NeMoUnitTest): def test_creation(self): 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 ) instance = neural_factory.get_module(name="TaylorNet", collection="toys", params={"dim": 4}) self.assertTrue(isinstance(instance, nemo.backends.pytorch.tutorials.TaylorNet)) def test_simple_example(self): neural_factory = nemo.core.neural_factory.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 ) dl = neural_factory.get_module( - name="RealFunctionDataLayer", collection="toys", params={"n": 10000, "batch_size": 128}, + name="RealFunctionDataLayer", collection="toys", params={"n": 10000, "batch_size": 128} ) fx = neural_factory.get_module(name="TaylorNet", collection="toys", params={"dim": 4}) loss = neural_factory.get_module(name="MSELoss", collection="toys", params={}) @@ -43,6 +43,4 @@ def test_simple_example(self): loss_tensor = loss(predictions=y_pred, target=y) optimizer = neural_factory.get_trainer() - optimizer.train( - [loss_tensor], optimizer="sgd", optimization_params={"lr": 1e-3, "num_epochs": 1}, - ) + optimizer.train([loss_tensor], optimizer="sgd", optimization_params={"lr": 1e-3, "num_epochs": 1}) diff --git a/tests/test_neural_types.py b/tests/test_neural_types.py index efcfff2065f7..361e60b02ae1 100644 --- a/tests/test_neural_types.py +++ b/tests/test_neural_types.py @@ -42,13 +42,13 @@ def setUp(self) -> None: print("ASR data found in: {0}".format(data_folder + "asr")) def test_same(self): - btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}) - btc2 = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}) + btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}) + btc2 = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}) self.assertEqual(btc2.compare(btc), NeuralTypeComparisonResult.SAME) def test_transpose_same(self): - btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}) - tbc = NeuralType(axis2type={1: AxisType(BatchTag), 0: AxisType(TimeTag), 2: AxisType(ChannelTag),}) + btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}) + tbc = NeuralType(axis2type={1: AxisType(BatchTag), 0: AxisType(TimeTag), 2: AxisType(ChannelTag)}) self.assertEqual(btc.compare(tbc), NeuralTypeComparisonResult.TRANSPOSE_SAME) self.assertEqual(tbc.compare(btc), NeuralTypeComparisonResult.TRANSPOSE_SAME) @@ -73,9 +73,9 @@ def test_dim_incompatible(self): self.assertEqual(nchw1.compare(nchw2), NeuralTypeComparisonResult.DIM_INCOMPATIBLE) def test_rank_incompatible(self): - btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}) + btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}) nchw = NeuralType( - axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag),} + axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag)} ) self.assertEqual(nchw.compare(btc), NeuralTypeComparisonResult.INCOMPATIBLE) @@ -90,10 +90,10 @@ def test_axis_type(self): def test_semantic_incompatible(self): nchw = NeuralType( - axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag),} + axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag)} ) badd = NeuralType( - axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(ChannelTag), 3: AxisType(WidthTag),} + axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(ChannelTag), 3: AxisType(WidthTag)} ) self.assertEqual(nchw.compare(badd), NeuralTypeComparisonResult.INCOMPATIBLE) self.assertEqual(badd.compare(nchw), NeuralTypeComparisonResult.INCOMPATIBLE) @@ -101,9 +101,9 @@ def test_semantic_incompatible(self): def test_root(self): root = NeuralType({}) non_tensor = NeuralType(None) - btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}) + btc = NeuralType(axis2type={0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}) nchw = NeuralType( - axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag),} + axis2type={0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(HeightTag), 3: AxisType(WidthTag)} ) self.assertEqual(root.compare(btc), NeuralTypeComparisonResult.SAME) self.assertEqual(root.compare(nchw), NeuralTypeComparisonResult.SAME) @@ -116,10 +116,10 @@ def test_root(self): def test_combiner_type_infer(self): combiner = nemo.backends.pytorch.common.SimpleCombiner(mode="add") x_tg = nemo.core.NmTensor( - producer=None, producer_args=None, name=None, ntype=NeuralType({0: AxisType(BatchTag),}), + producer=None, producer_args=None, name=None, ntype=NeuralType({0: AxisType(BatchTag)}) ) y_tg = nemo.core.NmTensor( - producer=None, producer_args=None, name=None, ntype=NeuralType({0: AxisType(BatchTag),}), + producer=None, producer_args=None, name=None, ntype=NeuralType({0: AxisType(BatchTag)}) ) res = combiner(x1=y_tg, x2=x_tg) self.assertEqual(res.compare(x_tg), NeuralTypeComparisonResult.SAME) @@ -156,7 +156,7 @@ def test_optional_input_no_input(self): optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) def test_optional_input_no_with_input(self): @@ -168,7 +168,7 @@ def test_optional_input_no_with_input(self): loss_tensor = loss(predictions=y_pred, target=y) optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) def test_optional_input_no_with_wrong_input(self): @@ -187,9 +187,7 @@ def wrong_fn(): loss_tensor = loss(predictions=y_pred, target=y) optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], - optimizer="sgd", - optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) self.assertRaises(NeuralPortNmTensorMismatchError, wrong_fn) @@ -201,7 +199,7 @@ def test_simple_dags(self): labels = jasper_model_definition['labels'] data_layer = nemo_asr.AudioToTextDataLayer( - manifest_filepath=self.manifest_filepath, labels=labels, batch_size=4, + manifest_filepath=self.manifest_filepath, labels=labels, batch_size=4 ) data_preprocessor = nemo_asr.AudioToMelSpectrogramPreprocessor( **jasper_model_definition['AudioToMelSpectrogramPreprocessor'] @@ -215,7 +213,7 @@ def test_simple_dags(self): greedy_decoder = nemo_asr.GreedyCTCDecoder() # DAG definition - (audio_signal, audio_signal_len, transcript, transcript_len,) = data_layer() + (audio_signal, audio_signal_len, transcript, transcript_len) = data_layer() processed_signal, processed_signal_len = data_preprocessor(input_signal=audio_signal, length=audio_signal_len) spec_augment = nemo_asr.SpectrogramAugmentation(rect_masks=5) @@ -225,7 +223,7 @@ def test_simple_dags(self): log_probs = jasper_decoder(encoder_output=encoded) predictions = greedy_decoder(log_probs=log_probs) 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 ) def wrong(): @@ -234,7 +232,7 @@ def wrong(): labels = jasper_config['labels'] data_layer = nemo_asr.AudioToTextDataLayer( - manifest_filepath=self.manifest_filepath, labels=labels, batch_size=4, + manifest_filepath=self.manifest_filepath, labels=labels, batch_size=4 ) data_preprocessor = nemo_asr.AudioToMelSpectrogramPreprocessor( **jasper_config['AudioToMelSpectrogramPreprocessor'] @@ -245,7 +243,7 @@ def wrong(): ) jasper_decoder = nemo_asr.JasperDecoderForCTC(feat_in=1024, num_classes=len(labels)) # DAG definition - (audio_signal, audio_signal_len, transcript, transcript_len,) = data_layer() + (audio_signal, audio_signal_len, transcript, transcript_len) = data_layer() processed_signal, processed_signal_len = data_preprocessor( input_signal=audio_signal, length=audio_signal_len ) diff --git a/tests/test_pytorch_trainers.py b/tests/test_pytorch_trainers.py index 9638b3f3ab15..cf85169c267f 100644 --- a/tests/test_pytorch_trainers.py +++ b/tests/test_pytorch_trainers.py @@ -32,27 +32,25 @@ def test_simple_train(self): optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) def test_simple_train_named_output(self): print('Simplest train test with using named output.') - data_source = nemo.backends.pytorch.tutorials.RealFunctionDataLayer(n=10000, batch_size=128,) + data_source = nemo.backends.pytorch.tutorials.RealFunctionDataLayer(n=10000, batch_size=128) trainable_module = nemo.backends.pytorch.tutorials.TaylorNet(dim=4) loss = nemo.backends.pytorch.tutorials.MSELoss() data = data_source() self.assertEqual( - first=type(data).__name__, - second='RealFunctionDataLayerOutput', - msg='Check output class naming coherence.', + first=type(data).__name__, second='RealFunctionDataLayerOutput', msg='Check output class naming coherence.' ) y_pred = trainable_module(x=data.x) loss_tensor = loss(predictions=y_pred, target=data.y) optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) def test_simple_chained_train(self): @@ -70,5 +68,5 @@ def test_simple_chained_train(self): optimizer = nemo.backends.pytorch.actions.PtActions() optimizer.train( - tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1}, + tensors_to_optimize=[loss_tensor], optimizer="sgd", optimization_params={"lr": 0.0003, "num_epochs": 1} ) diff --git a/tests/tts/test_tts.py b/tests/tts/test_tts.py index f867cce001ab..b76c39a6754a 100644 --- a/tests/tts/test_tts.py +++ b/tests/tts/test_tts.py @@ -72,7 +72,7 @@ def setUp(self) -> None: def test_tacotron2_training(self): data_layer = nemo_asr.AudioToTextDataLayer( - manifest_filepath=self.manifest_filepath, labels=self.labels, batch_size=4, + manifest_filepath=self.manifest_filepath, labels=self.labels, batch_size=4 ) preprocessing = nemo_asr.AudioToMelSpectrogramPreprocessor( window_size=None, @@ -86,7 +86,7 @@ def test_tacotron2_training(self): pad_value=-11.52, ) text_embedding = nemo_tts.TextEmbedding(len(self.labels), 256) - t2_enc = nemo_tts.Tacotron2Encoder(encoder_n_convolutions=2, encoder_kernel_size=5, encoder_embedding_dim=256,) + t2_enc = nemo_tts.Tacotron2Encoder(encoder_n_convolutions=2, encoder_kernel_size=5, encoder_embedding_dim=256) t2_dec = nemo_tts.Tacotron2Decoder( n_mel_channels=64, n_frames_per_step=1, @@ -103,7 +103,7 @@ def test_tacotron2_training(self): attention_location_kernel_size=15, ) t2_postnet = nemo_tts.Tacotron2Postnet( - n_mel_channels=64, postnet_embedding_dim=256, postnet_kernel_size=5, postnet_n_convolutions=3, + n_mel_channels=64, postnet_embedding_dim=256, postnet_kernel_size=5, postnet_n_convolutions=3 ) t2_loss = nemo_tts.Tacotron2Loss() makegatetarget = nemo_tts.MakeGate() @@ -113,9 +113,9 @@ def test_tacotron2_training(self): spec_target, spec_target_len = preprocessing(input_signal=audio, length=audio_len) transcript_embedded = text_embedding(char_phone=transcript) - transcript_encoded = t2_enc(char_phone_embeddings=transcript_embedded, embedding_length=transcript_len,) + transcript_encoded = t2_enc(char_phone_embeddings=transcript_embedded, embedding_length=transcript_len) mel_decoder, gate, _ = t2_dec( - char_phone_encoded=transcript_encoded, encoded_length=transcript_len, mel_target=spec_target, + char_phone_encoded=transcript_encoded, encoded_length=transcript_len, mel_target=spec_target ) mel_postnet = t2_postnet(mel_input=mel_decoder) gate_target = makegatetarget(mel_target=spec_target, target_len=spec_target_len) @@ -130,19 +130,19 @@ def test_tacotron2_training(self): ) callback = nemo.core.SimpleLossLoggerCallback( - tensors=[loss_t], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'), + tensors=[loss_t], 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_t], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}, + [loss_t], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003} ) def test_waveglow_training(self): - data_layer = nemo_tts.AudioDataLayer(manifest_filepath=self.manifest_filepath, n_segments=4000, batch_size=4,) + data_layer = nemo_tts.AudioDataLayer(manifest_filepath=self.manifest_filepath, n_segments=4000, batch_size=4) preprocessing = nemo_asr.AudioToMelSpectrogramPreprocessor( window_size=None, window_stride=None, @@ -174,13 +174,13 @@ def test_waveglow_training(self): loss_t = waveglow_loss(z=z, log_s_list=log_s_list, log_det_W_list=log_det_W_list) callback = nemo.core.SimpleLossLoggerCallback( - tensors=[loss_t], print_func=lambda x: print(f'Train Loss: {str(x[0].item())}'), + tensors=[loss_t], 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_t], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003}, + [loss_t], callbacks=[callback], optimizer="sgd", optimization_params={"num_epochs": 10, "lr": 0.0003} )