def __init__(self, cfg: DictConfig, trainer: Trainer = None): # Get global rank and total number of GPU workers for IterableDataset partitioning, if applicable self.global_rank = 0 self.world_size = 1 self.local_rank = 0 if trainer is not None: self.global_rank = (trainer.node_rank * trainer.num_gpus) + trainer.local_rank self.world_size = trainer.num_nodes * trainer.num_gpus self.local_rank = trainer.local_rank super().__init__(cfg=cfg, trainer=trainer) self._update_decoder_config(self._cfg.decoder) self.preprocessor = EncDecClassificationModel.from_config_dict(self._cfg.preprocessor) self.encoder = EncDecClassificationModel.from_config_dict(self._cfg.encoder) self.decoder = EncDecClassificationModel.from_config_dict(self._cfg.decoder) self.loss = CrossEntropyLoss() if hasattr(self._cfg, 'spec_augment') and self._cfg.spec_augment is not None: self.spec_augmentation = EncDecClassificationModel.from_config_dict(self._cfg.spec_augment) else: self.spec_augmentation = None if hasattr(self._cfg, 'crop_or_pad_augment') and self._cfg.crop_or_pad_augment is not None: self.crop_or_pad = EncDecClassificationModel.from_config_dict(self._cfg.crop_or_pad_augment) else: self.crop_or_pad = None # Setup metric objects self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True)
def __init__(self, cfg: DictConfig, trainer: Trainer = None): super().__init__(cfg=cfg, trainer=trainer) self._update_decoder_config(self.cfg.decoder) self.preprocessor = EncDecClassificationModel.from_config_dict( self._cfg.preprocessor) self.encoder = EncDecClassificationModel.from_config_dict( self._cfg.encoder) self.decoder = EncDecClassificationModel.from_config_dict( self._cfg.decoder) self.loss = CrossEntropyLoss() if hasattr(self._cfg, 'spec_augment') and self._cfg.spec_augment is not None: self.spec_augmentation = EncDecClassificationModel.from_config_dict( self._cfg.spec_augment) else: self.spec_augmentation = None if hasattr(self._cfg, 'crop_or_pad_augment' ) and self._cfg.crop_or_pad_augment is not None: self.crop_or_pad = EncDecClassificationModel.from_config_dict( self._cfg.crop_or_pad_augment) else: self.crop_or_pad = None # Setup metric objects self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True)
def __init__(self, cfg: DictConfig, trainer: Trainer = None): self.world_size = 1 if trainer is not None: self.world_size = trainer.num_nodes * trainer.num_devices super().__init__(cfg=cfg, trainer=trainer) self.preprocessor = EncDecSpeakerLabelModel.from_config_dict(cfg.preprocessor) self.encoder = EncDecSpeakerLabelModel.from_config_dict(cfg.encoder) self.decoder = EncDecSpeakerLabelModel.from_config_dict(cfg.decoder) if 'angular' in cfg.decoder and cfg.decoder['angular']: logging.info("loss is Angular Softmax") scale = cfg.loss.scale margin = cfg.loss.margin self.loss = AngularSoftmaxLoss(scale=scale, margin=margin) else: logging.info("loss is Softmax-CrossEntropy") self.loss = CELoss() self.task = None self._accuracy = TopKClassificationAccuracy(top_k=[1]) self.labels = None if hasattr(self._cfg, 'spec_augment') and self._cfg.spec_augment is not None: self.spec_augmentation = EncDecSpeakerLabelModel.from_config_dict(self._cfg.spec_augment) else: self.spec_augmentation = None
def __init__(self, cfg: DictConfig, trainer: Trainer = None): super().__init__(cfg=cfg, trainer=trainer) self.preprocessor = EncDecSpeakerLabelModel.from_config_dict(cfg.preprocessor) self.encoder = EncDecSpeakerLabelModel.from_config_dict(cfg.encoder) self.decoder = EncDecSpeakerLabelModel.from_config_dict(cfg.decoder) if 'angular' in cfg.decoder and cfg.decoder['angular']: logging.info("Training with Angular Softmax Loss") scale = cfg.loss.scale margin = cfg.loss.margin self.loss = AngularSoftmaxLoss(scale=scale, margin=margin) else: logging.info("Training with Softmax-CrossEntropy loss") self.loss = CELoss() self.task = None self._accuracy = TopKClassificationAccuracy(top_k=[1])
class EncDecClassificationModel(ASRModel, Exportable): """Encoder decoder CTC-based models.""" def __init__(self, cfg: DictConfig, trainer: Trainer = None): super().__init__(cfg=cfg, trainer=trainer) self._update_decoder_config(self.cfg.decoder) self.preprocessor = EncDecClassificationModel.from_config_dict( self._cfg.preprocessor) self.encoder = EncDecClassificationModel.from_config_dict( self._cfg.encoder) self.decoder = EncDecClassificationModel.from_config_dict( self._cfg.decoder) self.loss = CrossEntropyLoss() if hasattr(self._cfg, 'spec_augment') and self._cfg.spec_augment is not None: self.spec_augmentation = EncDecClassificationModel.from_config_dict( self._cfg.spec_augment) else: self.spec_augmentation = None if hasattr(self._cfg, 'crop_or_pad_augment' ) and self._cfg.crop_or_pad_augment is not None: self.crop_or_pad = EncDecClassificationModel.from_config_dict( self._cfg.crop_or_pad_augment) else: self.crop_or_pad = None # Setup metric objects self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True) def transcribe(self, paths2audio_files: str) -> str: raise NotImplementedError( "Classification models do not transcribe audio.") def _setup_dataloader_from_config(self, config: Optional[Dict]): if config.get('manifest_filepath') is None: return if 'augmentor' in config: augmentor = process_augmentations(config['augmentor']) else: augmentor = None featurizer = WaveformFeaturizer(sample_rate=config['sample_rate'], int_values=config.get( 'int_values', False), augmentor=augmentor) dataset = AudioLabelDataset( manifest_filepath=config['manifest_filepath'], labels=config['labels'], featurizer=featurizer, max_duration=config.get('max_duration', None), min_duration=config.get('min_duration', None), trim=config.get('trim_silence', True), load_audio=config.get('load_audio', True), ) return torch.utils.data.DataLoader( dataset=dataset, batch_size=config['batch_size'], collate_fn=dataset.collate_fn, drop_last=config.get('drop_last', False), shuffle=config['shuffle'], num_workers=config.get('num_workers', 0), pin_memory=config.get('pin_memory', False), ) def setup_training_data(self, train_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in train_data_config: train_data_config['shuffle'] = True self._train_dl = self._setup_dataloader_from_config( config=train_data_config) def setup_validation_data(self, val_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in val_data_config: val_data_config['shuffle'] = False self._validation_dl = self._setup_dataloader_from_config( config=val_data_config) def setup_test_data(self, test_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in test_data_config: test_data_config['shuffle'] = False self._test_dl = self._setup_dataloader_from_config( config=test_data_config) def test_dataloader(self): if self._test_dl is not None: return self._test_dl @classmethod def list_available_models(cls) -> Optional[List[PretrainedModelInfo]]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ result = [] model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v1", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v1.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v1, 30 classes) which obtains 97.32% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x2x64-v1", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x2x64-v1.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v1, 30 classes) which obtains 97.68% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v2, 35 classes) which obtains 97.12% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v2, 30 classes) which obtains 97.29% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2-subset-task", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2-subset-task.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v2, 10+2 classes) which obtains 98.2% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x2x64-v2-subset-task", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x2x64-v2-subset-task.nemo", description= "MatchboxNet model trained on Google Speech Commands dataset (v2, 10+2 classes) which obtains 98.4% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-VAD-3x2", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet_VAD_3x2.nemo", description= "Voice Activity Detection MatchboxNet model trained on google speech command (v2) and freesound background data, which obtains 0.992 accuracy on testset from same source and 0.852 TPR for FPR=0.315 on testset (ALL) of AVA movie data", ) result.append(model) return result @property def input_types(self) -> Optional[Dict[str, NeuralType]]: if hasattr(self.preprocessor, '_sample_rate'): audio_eltype = AudioSignal(freq=self.preprocessor._sample_rate) else: audio_eltype = AudioSignal() return { "input_signal": NeuralType(('B', 'T'), audio_eltype), "input_signal_length": NeuralType(tuple('B'), LengthsType()), } @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return {"outputs": NeuralType(('B', 'D'), LogitsType())} @typecheck() def forward(self, input_signal, input_signal_length): processed_signal, processed_signal_len = self.preprocessor( input_signal=input_signal, length=input_signal_length, ) # Crop or pad is always applied if self.crop_or_pad is not None: processed_signal, processed_signal_len = self.crop_or_pad( input_signal=processed_signal, length=processed_signal_len) # Spec augment is not applied during evaluation/testing if self.spec_augmentation is not None and self.training: processed_signal = self.spec_augmentation( input_spec=processed_signal) encoded, encoded_len = self.encoder(audio_signal=processed_signal, length=processed_signal_len) logits = self.decoder(encoder_output=encoded) return logits # PTL-specific methods def training_step(self, batch, batch_nb): self.training_step_end() audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) tensorboard_logs = { 'train_loss': loss_value, 'learning_rate': self._optimizer.param_groups[0]['lr'], } self._accuracy(logits=logits, labels=labels) top_k = self._accuracy.compute() for i, top_i in enumerate(top_k): tensorboard_logs[f'training_batch_accuracy_top@{i}'] = top_i return {'loss': loss_value, 'log': tensorboard_logs} def validation_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc': acc, } def test_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc': acc, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['val_correct_counts'] for x in outputs]) total_counts = torch.stack([x['val_total_counts'] for x in outputs]) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() tensorboard_log = {'val_loss': val_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['val_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['test_correct_counts'].unsqueeze(0) for x in outputs]) total_counts = torch.stack( [x['test_total_counts'].unsqueeze(0) for x in outputs]) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() tensorboard_log = {'test_loss': test_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['test_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} def change_labels(self, new_labels: List[str]): """ Changes labels used by the decoder model. Use this method when fine-tuning on from pre-trained model. This method changes only decoder and leaves encoder and pre-processing modules unchanged. For example, you would use it if you want to use pretrained encoder when fine-tuning on a data in another dataset. If new_labels == self.decoder.vocabulary then nothing will be changed. Args: new_labels: list with new labels. Must contain at least 2 elements. Typically, \ this is set of labels for the dataset. Returns: None """ if new_labels is not None and not isinstance(new_labels, ListConfig): new_labels = ListConfig(new_labels) if self._cfg.labels == new_labels: logging.warning( f"Old labels ({self._cfg.labels}) and new labels ({new_labels}) match. Not changing anything" ) else: if new_labels is None or len(new_labels) == 0: raise ValueError( f'New labels must be non-empty list of labels. But I got: {new_labels}' ) # Update config self._cfg.labels = new_labels decoder_config = self.decoder.to_config_dict() new_decoder_config = copy.deepcopy(decoder_config) self._update_decoder_config(new_decoder_config) del self.decoder self.decoder = EncDecClassificationModel.from_config_dict( new_decoder_config) OmegaConf.set_struct(self._cfg.decoder, False) self._cfg.decoder = new_decoder_config OmegaConf.set_struct(self._cfg.decoder, True) if 'train_ds' in self._cfg and self._cfg.train_ds is not None: self._cfg.train_ds.labels = new_labels if 'validation_ds' in self._cfg and self._cfg.validation_ds is not None: self._cfg.validation_ds.labels = new_labels if 'test_ds' in self._cfg and self._cfg.test_ds is not None: self._cfg.test_ds.labels = new_labels logging.info( f"Changed decoder output to {self.decoder.num_classes} labels." ) def _update_decoder_config(self, cfg): """ Update the number of classes in the decoder based on labels provided. Args: cfg: The config of the decoder which will be updated. """ OmegaConf.set_struct(cfg, False) labels = self.cfg.labels if 'params' in cfg: cfg.params.num_classes = len(labels) else: cfg.num_classes = len(labels) OmegaConf.set_struct(cfg, True) def export( self, output: str, input_example=None, output_example=None, verbose=False, export_params=True, do_constant_folding=True, keep_initializers_as_inputs=False, onnx_opset_version: int = 12, try_script: bool = False, set_eval: bool = True, check_trace: bool = True, use_dynamic_axes: bool = True, ): if input_example is not None or output_example is not None: logging.warning( "Passed input and output examples will be ignored and recomputed since" " EncDecClassificationModel consists of two separate models (encoder and decoder) with different" " inputs and outputs.") encoder_onnx = self.encoder.export( os.path.join(os.path.dirname(output), 'encoder_' + os.path.basename(output)), None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) decoder_onnx = self.decoder.export( os.path.join(os.path.dirname(output), 'decoder_' + os.path.basename(output)), None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) output_model = attach_onnx_to_onnx(encoder_onnx, decoder_onnx, "EDC") onnx.save(output_model, output)
def _setup_metrics(self): self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True)
class EncDecClassificationModel(_EncDecBaseModel): """Encoder decoder Classification models.""" def __init__(self, cfg: DictConfig, trainer: Trainer = None): if cfg.get("is_regression_task", False): raise ValueError( f"EndDecClassificationModel requires the flag is_regression_task to be set as false" ) super().__init__(cfg=cfg, trainer=trainer) def _setup_preprocessor(self): return EncDecClassificationModel.from_config_dict( self._cfg.preprocessor) def _setup_encoder(self): return EncDecClassificationModel.from_config_dict(self._cfg.encoder) def _setup_decoder(self): return EncDecClassificationModel.from_config_dict(self._cfg.decoder) def _setup_loss(self): return CrossEntropyLoss() def _setup_metrics(self): self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True) @classmethod def list_available_models(cls) -> Optional[List[PretrainedModelInfo]]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ results = [] model = PretrainedModelInfo( pretrained_model_name="vad_telephony_marblenet", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:vad_telephony_marblenet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/vad_telephony_marblenet/versions/1.0.0rc1/files/vad_telephony_marblenet.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name="vad_marblenet", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:vad_marblenet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/vad_marblenet/versions/1.0.0rc1/files/vad_marblenet.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name="commandrecognition_en_matchboxnet3x1x64_v1", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x1x64_v1", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x1x64_v1/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x1x64_v1.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name="commandrecognition_en_matchboxnet3x2x64_v1", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x2x64_v1", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x2x64_v1/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x2x64_v1.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name="commandrecognition_en_matchboxnet3x1x64_v2", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x1x64_v2", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x1x64_v2/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x1x64_v2.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name="commandrecognition_en_matchboxnet3x2x64_v2", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x2x64_v2", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x2x64_v2/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x2x64_v2.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name= "commandrecognition_en_matchboxnet3x1x64_v2_subset_task", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x1x64_v2_subset_task", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x1x64_v2_subset_task/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x1x64_v2_subset_task.nemo", ) results.append(model) model = PretrainedModelInfo( pretrained_model_name= "commandrecognition_en_matchboxnet3x2x64_v2_subset_task", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:commandrecognition_en_matchboxnet3x2x64_v2_subset_task", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/commandrecognition_en_matchboxnet3x2x64_v2_subset_task/versions/1.0.0rc1/files/commandrecognition_en_matchboxnet3x2x64_v2_subset_task.nemo", ) results.append(model) return results @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return {"outputs": NeuralType(('B', 'D'), LogitsType())} # PTL-specific methods def training_step(self, batch, batch_nb): self.training_step_end() audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) self.log('train_loss', loss_value) self.log('learning_rate', self._optimizer.param_groups[0]['lr']) self._accuracy(logits=logits, labels=labels) topk_scores = self._accuracy.compute() self._accuracy.reset() for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('training_batch_accuracy_top@{}'.format(top_k), score) return { 'loss': loss_value, } def validation_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc': acc, } def test_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc': acc, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['val_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['val_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() self._accuracy.reset() tensorboard_log = {'val_loss': val_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['val_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack([ x['test_correct_counts'].unsqueeze(0) for x in outputs ]).sum(axis=0) total_counts = torch.stack( [x['test_total_counts'].unsqueeze(0) for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() self._accuracy.reset() tensorboard_log = {'test_loss': test_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['test_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} @typecheck() def forward(self, input_signal, input_signal_length): logits = super().forward(input_signal=input_signal, input_signal_length=input_signal_length) return logits def change_labels(self, new_labels: List[str]): """ Changes labels used by the decoder model. Use this method when fine-tuning on from pre-trained model. This method changes only decoder and leaves encoder and pre-processing modules unchanged. For example, you would use it if you want to use pretrained encoder when fine-tuning on a data in another dataset. If new_labels == self.decoder.vocabulary then nothing will be changed. Args: new_labels: list with new labels. Must contain at least 2 elements. Typically, \ this is set of labels for the dataset. Returns: None """ if new_labels is not None and not isinstance(new_labels, ListConfig): new_labels = ListConfig(new_labels) if self._cfg.labels == new_labels: logging.warning( f"Old labels ({self._cfg.labels}) and new labels ({new_labels}) match. Not changing anything" ) else: if new_labels is None or len(new_labels) == 0: raise ValueError( f'New labels must be non-empty list of labels. But I got: {new_labels}' ) # Update config self._cfg.labels = new_labels decoder_config = self.decoder.to_config_dict() new_decoder_config = copy.deepcopy(decoder_config) self._update_decoder_config(new_labels, new_decoder_config) del self.decoder self.decoder = EncDecClassificationModel.from_config_dict( new_decoder_config) OmegaConf.set_struct(self._cfg.decoder, False) self._cfg.decoder = new_decoder_config OmegaConf.set_struct(self._cfg.decoder, True) if 'train_ds' in self._cfg and self._cfg.train_ds is not None: self._cfg.train_ds.labels = new_labels if 'validation_ds' in self._cfg and self._cfg.validation_ds is not None: self._cfg.validation_ds.labels = new_labels if 'test_ds' in self._cfg and self._cfg.test_ds is not None: self._cfg.test_ds.labels = new_labels logging.info( f"Changed decoder output to {self.decoder.num_classes} labels." ) def _update_decoder_config(self, labels, cfg): """ Update the number of classes in the decoder based on labels provided. Args: labels: The current labels of the model cfg: The config of the decoder which will be updated. """ OmegaConf.set_struct(cfg, False) if 'params' in cfg: cfg.params.num_classes = len(labels) else: cfg.num_classes = len(labels) OmegaConf.set_struct(cfg, True)
class EncDecSpeakerLabelModel(ModelPT, ExportableEncDecModel): """Encoder decoder class for speaker label models. Model class creates training, validation methods for setting up data performing model forward pass. Expects config dict for * preprocessor * Jasper/Quartznet Encoder * Speaker Decoder """ @classmethod def list_available_models(cls) -> List[PretrainedModelInfo]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ result = [] model = PretrainedModelInfo( pretrained_model_name="speakerrecognition_speakernet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/speakerrecognition_speakernet/versions/1.0.0rc1/files/speakerrecognition_speakernet.nemo", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:speakerrecognition_speakernet", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="speakerverification_speakernet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/speakerverification_speakernet/versions/1.0.0rc1/files/speakerverification_speakernet.nemo", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:speakerverification_speakernet", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="speakerdiarization_speakernet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/speakerdiarization_speakernet/versions/1.0.0rc1/files/speakerdiarization_speakernet.nemo", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:speakerdiarization_speakernet", ) result.append(model) return result def __init__(self, cfg: DictConfig, trainer: Trainer = None): super().__init__(cfg=cfg, trainer=trainer) self.preprocessor = EncDecSpeakerLabelModel.from_config_dict( cfg.preprocessor) self.encoder = EncDecSpeakerLabelModel.from_config_dict(cfg.encoder) self.decoder = EncDecSpeakerLabelModel.from_config_dict(cfg.decoder) if 'angular' in cfg.decoder and cfg.decoder['angular']: logging.info("Training with Angular Softmax Loss") scale = cfg.loss.scale margin = cfg.loss.margin self.loss = AngularSoftmaxLoss(scale=scale, margin=margin) else: logging.info("Training with Softmax-CrossEntropy loss") self.loss = CELoss() self.task = None self._accuracy = TopKClassificationAccuracy(top_k=[1]) def __setup_dataloader_from_config(self, config: Optional[Dict]): if 'augmentor' in config: augmentor = process_augmentations(config['augmentor']) else: augmentor = None featurizer = WaveformFeaturizer(sample_rate=config['sample_rate'], int_values=config.get( 'int_values', False), augmentor=augmentor) self.dataset = AudioToSpeechLabelDataset( manifest_filepath=config['manifest_filepath'], labels=config['labels'], featurizer=featurizer, max_duration=config.get('max_duration', None), min_duration=config.get('min_duration', None), trim=False, time_length=config.get('time_length', 8), shift_length=config.get('shift_length', 0.75), ) if self.task == 'diarization': logging.info("Setting up diarization parameters") _collate_func = self.dataset.sliced_seq_collate_fn batch_size = 1 shuffle = False else: logging.info("Setting up identification parameters") _collate_func = self.dataset.fixed_seq_collate_fn batch_size = config['batch_size'] shuffle = config.get('shuffle', False) return torch.utils.data.DataLoader( dataset=self.dataset, batch_size=batch_size, collate_fn=_collate_func, drop_last=config.get('drop_last', False), shuffle=shuffle, num_workers=config.get('num_workers', 0), pin_memory=config.get('pin_memory', False), ) def setup_training_data(self, train_data_layer_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in train_data_layer_config: train_data_layer_config['shuffle'] = True self.task = 'identification' self._train_dl = self.__setup_dataloader_from_config( config=train_data_layer_config) def setup_validation_data(self, val_data_layer_config: Optional[Union[DictConfig, Dict]]): val_data_layer_config['labels'] = self.dataset.labels self.task = 'identification' self._validation_dl = self.__setup_dataloader_from_config( config=val_data_layer_config) def setup_test_data(self, test_data_layer_params: Optional[Union[DictConfig, Dict]]): if hasattr(self, 'dataset'): test_data_layer_params['labels'] = self.dataset.labels if 'task' in test_data_layer_params and test_data_layer_params['task']: self.task = test_data_layer_params['task'].lower() self.time_length = test_data_layer_params.get('time_length', 1.5) self.shift_length = test_data_layer_params.get( 'shift_length', 0.75) else: self.task = 'identification' self.embedding_dir = test_data_layer_params.get('embedding_dir', './') self._test_dl = self.__setup_dataloader_from_config( config=test_data_layer_params) self.test_manifest = test_data_layer_params.get( 'manifest_filepath', None) def test_dataloader(self): if self._test_dl is not None: return self._test_dl @property def input_types(self) -> Optional[Dict[str, NeuralType]]: if hasattr(self.preprocessor, '_sample_rate'): audio_eltype = AudioSignal(freq=self.preprocessor._sample_rate) else: audio_eltype = AudioSignal() return { "input_signal": NeuralType(('B', 'T'), audio_eltype), "input_signal_length": NeuralType(tuple('B'), LengthsType()), } @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return { "logits": NeuralType(('B', 'D'), LogitsType()), "embs": NeuralType(('B', 'D'), AcousticEncodedRepresentation()), } @typecheck() def forward(self, input_signal, input_signal_length): processed_signal, processed_signal_len = self.preprocessor( input_signal=input_signal, length=input_signal_length, ) encoded, _ = self.encoder(audio_signal=processed_signal, length=processed_signal_len) logits, embs = self.decoder(encoder_output=encoded) return logits, embs # PTL-specific methods def training_step(self, batch, batch_idx): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss = self.loss(logits=logits, labels=labels) self.log('loss', loss) self.log('learning_rate', self._optimizer.param_groups[0]['lr']) self._accuracy(logits=logits, labels=labels) top_k = self._accuracy.compute() for i, top_i in enumerate(top_k): self.log(f'training_batch_accuracy_top@{i}', top_i) return {'loss': loss} def validation_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc_top_k': acc_top_k, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['val_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['val_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() logging.info("val_loss: {:.3f}".format(val_loss_mean)) self.log('val_loss', val_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('val_epoch_accuracy_top@{}'.format(top_k), score) return { 'val_loss': val_loss_mean, 'val_acc_top_k': topk_scores, } def test_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc_top_k': acc_top_k, } def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['test_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['test_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() logging.info("test_loss: {:.3f}".format(test_loss_mean)) self.log('test_loss', test_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('test_epoch_accuracy_top@{}'.format(top_k), score) return { 'test_loss': test_loss_mean, 'test_acc_top_k': topk_scores, } def setup_finetune_model(self, model_config: DictConfig): """ setup_finetune_model method sets up training data, validation data and test data with new provided config, this checks for the previous labels set up during training from scratch, if None, it sets up labels for provided finetune data from manifest files Args: model_config: cfg which has train_ds, optional validation_ds, optional test_ds and mandatory encoder and decoder model params make sure you set num_classes correctly for finetune data Returns: None """ if hasattr(self, 'dataset'): scratch_labels = self.dataset.labels else: scratch_labels = None logging.info( "Setting up data loaders with manifests provided from model_config" ) if 'train_ds' in model_config and model_config.train_ds is not None: self.setup_training_data(model_config.train_ds) else: raise KeyError( "train_ds is not found in model_config but you need it for fine tuning" ) if self.dataset.labels is None or len(self.dataset.labels) == 0: raise ValueError( f'New labels must be non-empty list of labels. But I got: {self.dataset.labels}' ) if 'validation_ds' in model_config and model_config.validation_ds is not None: self.setup_multiple_validation_data(model_config.validation_ds) if 'test_ds' in model_config and model_config.test_ds is not None: self.setup_multiple_test_data(model_config.test_ds) if scratch_labels == self.dataset.labels: # checking for new finetune dataset labels logging.warning( "Trained dataset labels are same as finetune dataset labels -- continuing change of decoder parameters" ) elif scratch_labels is None: logging.warning( "Either you provided a dummy manifest file during training from scratch or you restored from a pretrained nemo file" ) decoder_config = model_config.decoder new_decoder_config = copy.deepcopy(decoder_config) if new_decoder_config['num_classes'] != len(self.dataset.labels): raise ValueError( "number of classes provided {} is not same as number of different labels in finetuning data: {}" .format(new_decoder_config['num_classes'], len(self.dataset.labels))) del self.decoder self.decoder = EncDecSpeakerLabelModel.from_config_dict( new_decoder_config) with open_dict(self._cfg.decoder): self._cfg.decoder = new_decoder_config logging.info( f"Changed decoder output to # {self.decoder._num_classes} classes." )
class EncDecSpeakerLabelModel(ModelPT, Exportable): """Encoder decoder class for speaker label models. Model class creates training, validation methods for setting up data performing model forward pass. Expects config dict for * preprocessor * Jasper/Quartznet Encoder * Speaker Decoder """ @classmethod def list_available_models(cls) -> List[PretrainedModelInfo]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ result = [] model = PretrainedModelInfo( pretrained_model_name="SpeakerNet_recognition", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/SpeakerNet_recognition.nemo", description= "SpeakerNet_recognition model trained end-to-end for speaker recognition purposes with cross_entropy loss. It was trained on voxceleb 1, voxceleb 2 dev datasets and augmented with musan music and noise. Speaker Recognition model achieves 2.65% EER on voxceleb-O cleaned trial file", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="SpeakerNet_verification", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/SpeakerNet_verification.nemo", description= "SpeakerNet_verification model trained end-to-end for speaker verification purposes with arcface angular softmax loss. It was trained on voxceleb 1, voxceleb 2 dev datasets and augmented with musan music and noise. Speaker Verification model achieves 2.12% EER on voxceleb-O cleaned trial file", ) result.append(model) return result def __init__(self, cfg: DictConfig, trainer: Trainer = None): super().__init__(cfg=cfg, trainer=trainer) self.preprocessor = EncDecSpeakerLabelModel.from_config_dict( cfg.preprocessor) self.encoder = EncDecSpeakerLabelModel.from_config_dict(cfg.encoder) self.decoder = EncDecSpeakerLabelModel.from_config_dict(cfg.decoder) if 'angular' in cfg.decoder and cfg.decoder['angular']: logging.info("Training with Angular Softmax Loss") scale = cfg.loss.scale margin = cfg.loss.margin self.loss = AngularSoftmaxLoss(scale=scale, margin=margin) else: logging.info("Training with Softmax-CrossEntropy loss") self.loss = CELoss() self._accuracy = TopKClassificationAccuracy(top_k=[1], dist_sync_on_step=True) def __setup_dataloader_from_config(self, config: Optional[Dict]): if 'augmentor' in config: augmentor = process_augmentations(config['augmentor']) else: augmentor = None featurizer = WaveformFeaturizer(sample_rate=config['sample_rate'], int_values=config.get( 'int_values', False), augmentor=augmentor) self.dataset = AudioToSpeechLabelDataSet( manifest_filepath=config['manifest_filepath'], labels=config['labels'], featurizer=featurizer, max_duration=config.get('max_duration', None), min_duration=config.get('min_duration', None), trim=config.get('trim_silence', True), load_audio=config.get('load_audio', True), time_length=config.get('time_length', 8), ) return torch.utils.data.DataLoader( dataset=self.dataset, batch_size=config['batch_size'], collate_fn=self.dataset.fixed_seq_collate_fn, drop_last=config.get('drop_last', False), shuffle=config['shuffle'], num_workers=config.get('num_workers', 2), pin_memory=config.get('pin_memory', False), ) def setup_training_data(self, train_data_layer_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in train_data_layer_config: train_data_layer_config['shuffle'] = True self._train_dl = self.__setup_dataloader_from_config( config=train_data_layer_config) def setup_validation_data(self, val_data_layer_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in val_data_layer_config: val_data_layer_config['shuffle'] = False val_data_layer_config['labels'] = self.dataset.labels self._validation_dl = self.__setup_dataloader_from_config( config=val_data_layer_config) def setup_test_data(self, test_data_layer_params: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in test_data_layer_params: test_data_layer_params['shuffle'] = False if hasattr(self, 'dataset'): test_data_layer_params['labels'] = self.dataset.labels self.embedding_dir = test_data_layer_params.get('embedding_dir', './') self.test_manifest = test_data_layer_params.get( 'manifest_filepath', None) self._test_dl = self.__setup_dataloader_from_config( config=test_data_layer_params) @property def input_types(self) -> Optional[Dict[str, NeuralType]]: if hasattr(self.preprocessor, '_sample_rate'): audio_eltype = AudioSignal(freq=self.preprocessor._sample_rate) else: audio_eltype = AudioSignal() return { "input_signal": NeuralType(('B', 'T'), audio_eltype), "input_signal_length": NeuralType(tuple('B'), LengthsType()), } @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return { "logits": NeuralType(('B', 'D'), LogitsType()), "embs": NeuralType(('B', 'D'), AcousticEncodedRepresentation()), } @typecheck() def forward(self, input_signal, input_signal_length): processed_signal, processed_signal_len = self.preprocessor( input_signal=input_signal, length=input_signal_length, ) encoded, _ = self.encoder(audio_signal=processed_signal, length=processed_signal_len) logits, embs = self.decoder(encoder_output=encoded) return logits, embs # PTL-specific methods def training_step(self, batch, batch_idx): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss = self.loss(logits=logits, labels=labels) self.log('loss', loss) self.log('learning_rate', self._optimizer.param_groups[0]['lr']) self._accuracy(logits=logits, labels=labels) top_k = self._accuracy.compute() for i, top_i in enumerate(top_k): self.log(f'training_batch_accuracy_top@{i}', top_i) return {'loss': loss} def validation_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc_top_k': acc_top_k, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['val_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['val_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() logging.info("val_loss: {:.3f}".format(val_loss_mean)) self.log('val_loss', val_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('val_epoch_accuracy_top@{}'.format(top_k), score) return { 'val_loss': val_loss_mean, 'val_acc_top_k': topk_scores, } def test_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc_top_k': acc_top_k, } def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['test_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['test_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() logging.info("test_loss: {:.3f}".format(test_loss_mean)) self.log('test_loss', test_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('test_epoch_accuracy_top@{}'.format(top_k), score) return { 'test_loss': test_loss_mean, 'test_acc_top_k': topk_scores, } def setup_finetune_model(self, model_config: DictConfig): """ setup_finetune_model method sets up training data, validation data and test data with new provided config, this checks for the previous labels set up during training from scratch, if None, it sets up labels for provided finetune data from manifest files Args: model_config: cfg which has train_ds, optional validation_ds, optional test_ds and mandatory encoder and decoder model params make sure you set num_classes correctly for finetune data Returns: None """ if hasattr(self, 'dataset'): scratch_labels = self.dataset.labels else: scratch_labels = None logging.info( "Setting up data loaders with manifests provided from model_config" ) if 'train_ds' in model_config and model_config.train_ds is not None: self.setup_training_data(model_config.train_ds) else: raise KeyError( "train_ds is not found in model_config but you need it for fine tuning" ) if self.dataset.labels is None or len(self.dataset.labels) == 0: raise ValueError( f'New labels must be non-empty list of labels. But I got: {self.dataset.labels}' ) if 'validation_ds' in model_config and model_config.validation_ds is not None: self.setup_multiple_validation_data(model_config.validation_ds) if 'test_ds' in model_config and model_config.test_ds is not None: self.setup_multiple_test_data(model_config.test_ds) if scratch_labels == self.dataset.labels: # checking for new finetune dataset labels logging.warning( "Trained dataset labels are same as finetune dataset labels -- continuing change of decoder parameters" ) elif scratch_labels is None: logging.warning( "Either you provided a dummy manifest file during training from scratch or you restored from a pretrained nemo file" ) decoder_config = model_config.decoder new_decoder_config = copy.deepcopy(decoder_config) if new_decoder_config['num_classes'] != len(self.dataset.labels): raise ValueError( "number of classes provided {} is not same as number of different labels in finetuning data: {}" .format(new_decoder_config['num_classes'], len(self.dataset.labels))) del self.decoder self.decoder = EncDecSpeakerLabelModel.from_config_dict( new_decoder_config) with open_dict(self._cfg.decoder): self._cfg.decoder = new_decoder_config logging.info( f"Changed decoder output to # {self.decoder._num_classes} classes." ) def export( self, output: str, input_example=None, output_example=None, verbose=False, export_params=True, do_constant_folding=True, keep_initializers_as_inputs=False, onnx_opset_version: int = 12, try_script: bool = False, set_eval: bool = True, check_trace: bool = True, use_dynamic_axes: bool = True, ): if input_example is not None or output_example is not None: logging.warning( "Passed input and output examples will be ignored and recomputed since" " EncDecSpeakerModel consists of two separate models (encoder and decoder) with different" " inputs and outputs.") qual_name = self.__module__ + '.' + self.__class__.__qualname__ output1 = os.path.join(os.path.dirname(output), 'encoder_' + os.path.basename(output)) output1_descr = qual_name + ' Encoder exported to ONNX' encoder_onnx = self.encoder.export( output1, None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) output2 = os.path.join(os.path.dirname(output), 'decoder_' + os.path.basename(output)) output2_descr = qual_name + ' Decoder exported to ONNX' decoder_onnx = self.decoder.export( output2, None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) output_model = attach_onnx_to_onnx(encoder_onnx, decoder_onnx, "SL") output_descr = qual_name + ' Encoder+Decoder exported to ONNX' onnx.save(output_model, output) return ([output, output1, output2], [output_descr, output1_descr, output2_descr])
class EncDecClassificationModel(ASRModel, Exportable): """Encoder decoder Classification models.""" def __init__(self, cfg: DictConfig, trainer: Trainer = None): # Get global rank and total number of GPU workers for IterableDataset partitioning, if applicable self.global_rank = 0 self.world_size = 1 self.local_rank = 0 if trainer is not None: self.global_rank = (trainer.node_rank * trainer.num_gpus) + trainer.local_rank self.world_size = trainer.num_nodes * trainer.num_gpus self.local_rank = trainer.local_rank super().__init__(cfg=cfg, trainer=trainer) self._update_decoder_config(self._cfg.decoder) self.preprocessor = EncDecClassificationModel.from_config_dict(self._cfg.preprocessor) self.encoder = EncDecClassificationModel.from_config_dict(self._cfg.encoder) self.decoder = EncDecClassificationModel.from_config_dict(self._cfg.decoder) self.loss = CrossEntropyLoss() if hasattr(self._cfg, 'spec_augment') and self._cfg.spec_augment is not None: self.spec_augmentation = EncDecClassificationModel.from_config_dict(self._cfg.spec_augment) else: self.spec_augmentation = None if hasattr(self._cfg, 'crop_or_pad_augment') and self._cfg.crop_or_pad_augment is not None: self.crop_or_pad = EncDecClassificationModel.from_config_dict(self._cfg.crop_or_pad_augment) else: self.crop_or_pad = None # Setup metric objects self._accuracy = TopKClassificationAccuracy(dist_sync_on_step=True) @torch.no_grad() def transcribe(self, paths2audio_files: List[str], batch_size: int = 4, logprobs=False) -> List[str]: """ Generate class labels for provided audio files. Use this method for debugging and prototyping. Args: paths2audio_files: (a list) of paths to audio files. \ Recommended length per file is approximately 1 second. batch_size: (int) batch size to use during inference. \ Bigger will result in better throughput performance but would use more memory. logprobs: (bool) pass True to get log probabilities instead of class labels. Returns: A list of transcriptions (or raw log probabilities if logprobs is True) in the same order as paths2audio_files """ if paths2audio_files is None or len(paths2audio_files) == 0: return {} # We will store transcriptions here labels = [] # Model's mode and device mode = self.training device = next(self.parameters()).device dither_value = self.preprocessor.featurizer.dither pad_to_value = self.preprocessor.featurizer.pad_to try: self.preprocessor.featurizer.dither = 0.0 self.preprocessor.featurizer.pad_to = 0 # Switch model to evaluation mode self.eval() logging_level = logging.get_verbosity() logging.set_verbosity(logging.WARNING) # Work in tmp directory - will store manifest file there with tempfile.TemporaryDirectory() as tmpdir: with open(os.path.join(tmpdir, 'manifest.json'), 'w') as fp: for audio_file in paths2audio_files: entry = {'audio_filepath': audio_file, 'duration': 100000.0, 'label': self.cfg.labels[0]} fp.write(json.dumps(entry) + '\n') config = {'paths2audio_files': paths2audio_files, 'batch_size': batch_size, 'temp_dir': tmpdir} temporary_datalayer = self._setup_transcribe_dataloader(config) for test_batch in temporary_datalayer: logits = self.forward( input_signal=test_batch[0].to(device), input_signal_length=test_batch[1].to(device) ) if logprobs: # dump log probs per file for idx in range(logits.shape[0]): labels.append(logits[idx]) else: labels_k = [] top_ks = self._accuracy.top_k for top_k_i in top_ks: # replace top k value with current top k self._accuracy.top_k = top_k_i labels_k_i = self._accuracy.top_k_predicted_labels(logits) labels_k.append(labels_k_i) # convenience: if only one top_k, pop out the nested list if len(top_ks) == 1: labels_k = labels_k[0] labels += labels_k # reset top k to orignal value self._accuracy.top_k = top_ks del test_batch finally: # set mode back to its original value self.train(mode=mode) self.preprocessor.featurizer.dither = dither_value self.preprocessor.featurizer.pad_to = pad_to_value logging.set_verbosity(logging_level) return labels def _setup_dataloader_from_config(self, config: Optional[Dict]): if 'augmentor' in config: augmentor = process_augmentations(config['augmentor']) else: augmentor = None featurizer = WaveformFeaturizer( sample_rate=config['sample_rate'], int_values=config.get('int_values', False), augmentor=augmentor ) shuffle = config['shuffle'] # Instantiate tarred dataset loader or normal dataset loader if config.get('is_tarred', False): if ('tarred_audio_filepaths' in config and config['tarred_audio_filepaths'] is None) or ( 'manifest_filepath' in config and config['manifest_filepath'] is None ): logging.warning( "Could not load dataset as `manifest_filepath` is None or " f"`tarred_audio_filepaths` is None. Provided config : {config}" ) return None if 'vad_stream' in config and config['vad_stream']: logging.warning("VAD inference does not support tarred dataset now") return None shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0 dataset = audio_to_label_dataset.get_tarred_classification_label_dataset( featurizer=featurizer, config=config, shuffle_n=shuffle_n, global_rank=self.global_rank, world_size=self.world_size, ) shuffle = False batch_size = config['batch_size'] collate_func = dataset.collate_fn else: if 'manifest_filepath' in config and config['manifest_filepath'] is None: logging.warning(f"Could not load dataset as `manifest_filepath` is None. Provided config : {config}") return None if 'vad_stream' in config and config['vad_stream']: logging.info("Perform streaming frame-level VAD") dataset = audio_to_label_dataset.get_speech_label_dataset(featurizer=featurizer, config=config) batch_size = 1 collate_func = dataset.vad_frame_seq_collate_fn else: dataset = audio_to_label_dataset.get_classification_label_dataset(featurizer=featurizer, config=config) batch_size = config['batch_size'] collate_func = dataset.collate_fn return torch.utils.data.DataLoader( dataset=dataset, batch_size=batch_size, collate_fn=collate_func, drop_last=config.get('drop_last', False), shuffle=shuffle, num_workers=config.get('num_workers', 0), pin_memory=config.get('pin_memory', False), ) def setup_training_data(self, train_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in train_data_config: train_data_config['shuffle'] = True # preserve config self._update_dataset_config(dataset_name='train', config=train_data_config) self._train_dl = self._setup_dataloader_from_config(config=train_data_config) # Need to set this because if using an IterableDataset, the length of the dataloader is the total number # of samples rather than the number of batches, and this messes up the tqdm progress bar. # So we set the number of steps manually (to the correct number) to fix this. if 'is_tarred' in train_data_config and train_data_config['is_tarred']: # We also need to check if limit_train_batches is already set. # If it's an int, we assume that the user has set it to something sane, i.e. <= # training batches, # and don't change it. Otherwise, adjust batches accordingly if it's a float (including 1.0). if isinstance(self._trainer.limit_train_batches, float): self._trainer.limit_train_batches = int( self._trainer.limit_train_batches * ceil((len(self._train_dl.dataset) / self.world_size) / train_data_config['batch_size']) ) def setup_validation_data(self, val_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in val_data_config: val_data_config['shuffle'] = False # preserve config self._update_dataset_config(dataset_name='validation', config=val_data_config) self._validation_dl = self._setup_dataloader_from_config(config=val_data_config) def setup_test_data(self, test_data_config: Optional[Union[DictConfig, Dict]]): if 'shuffle' not in test_data_config: test_data_config['shuffle'] = False # preserve config self._update_dataset_config(dataset_name='test', config=test_data_config) self._test_dl = self._setup_dataloader_from_config(config=test_data_config) def test_dataloader(self): if self._test_dl is not None: return self._test_dl @classmethod def list_available_models(cls) -> Optional[List[PretrainedModelInfo]]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ result = [] model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v1", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v1.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v1, 30 classes) which obtains 97.32% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x2x64-v1", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x2x64-v1.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v1, 30 classes) which obtains 97.68% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v2, 35 classes) which obtains 97.12% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v2, 30 classes) which obtains 97.29% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x1x64-v2-subset-task", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x1x64-v2-subset-task.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v2, 10+2 classes) which obtains 98.2% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-3x2x64-v2-subset-task", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet-3x2x64-v2-subset-task.nemo", description="MatchboxNet model trained on Google Speech Commands dataset (v2, 10+2 classes) which obtains 98.4% accuracy on test set.", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="MatchboxNet-VAD-3x2", location="https://api.ngc.nvidia.com/v2/models/nvidia/nemospeechmodels/versions/1.0.0a5/files/MatchboxNet_VAD_3x2.nemo", description="Voice Activity Detection MatchboxNet model trained on google speech command (v2) and freesound background data, which obtains 0.992 accuracy on testset from same source and 0.852 TPR for FPR=0.315 on testset (ALL) of AVA movie data", ) result.append(model) return result @property def input_types(self) -> Optional[Dict[str, NeuralType]]: if hasattr(self.preprocessor, '_sample_rate'): audio_eltype = AudioSignal(freq=self.preprocessor._sample_rate) else: audio_eltype = AudioSignal() return { "input_signal": NeuralType(('B', 'T'), audio_eltype), "input_signal_length": NeuralType(tuple('B'), LengthsType()), } @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return {"outputs": NeuralType(('B', 'D'), LogitsType())} @typecheck() def forward(self, input_signal, input_signal_length): processed_signal, processed_signal_len = self.preprocessor( input_signal=input_signal, length=input_signal_length, ) # Crop or pad is always applied if self.crop_or_pad is not None: processed_signal, processed_signal_len = self.crop_or_pad( input_signal=processed_signal, length=processed_signal_len ) # Spec augment is not applied during evaluation/testing if self.spec_augmentation is not None and self.training: processed_signal = self.spec_augmentation(input_spec=processed_signal) encoded, encoded_len = self.encoder(audio_signal=processed_signal, length=processed_signal_len) logits = self.decoder(encoder_output=encoded) return logits # PTL-specific methods def training_step(self, batch, batch_nb): self.training_step_end() audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) tensorboard_logs = { 'train_loss': loss_value, 'learning_rate': self._optimizer.param_groups[0]['lr'], } self._accuracy(logits=logits, labels=labels) top_k = self._accuracy.compute() for i, top_i in enumerate(top_k): tensorboard_logs[f'training_batch_accuracy_top@{i}'] = top_i return {'loss': loss_value, 'log': tensorboard_logs} def validation_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc': acc, } def test_step(self, batch, batch_idx, dataloader_idx=0): audio_signal, audio_signal_len, labels, labels_len = batch logits = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc': acc, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack([x['val_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['val_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() tensorboard_log = {'val_loss': val_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['val_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack([x['test_correct_counts'].unsqueeze(0) for x in outputs]).sum(axis=0) total_counts = torch.stack([x['test_total_counts'].unsqueeze(0) for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() tensorboard_log = {'test_loss': test_loss_mean} for top_k, score in zip(self._accuracy.top_k, topk_scores): tensorboard_log['test_epoch_top@{}'.format(top_k)] = score return {'log': tensorboard_log} def change_labels(self, new_labels: List[str]): """ Changes labels used by the decoder model. Use this method when fine-tuning on from pre-trained model. This method changes only decoder and leaves encoder and pre-processing modules unchanged. For example, you would use it if you want to use pretrained encoder when fine-tuning on a data in another dataset. If new_labels == self.decoder.vocabulary then nothing will be changed. Args: new_labels: list with new labels. Must contain at least 2 elements. Typically, \ this is set of labels for the dataset. Returns: None """ if new_labels is not None and not isinstance(new_labels, ListConfig): new_labels = ListConfig(new_labels) if self._cfg.labels == new_labels: logging.warning( f"Old labels ({self._cfg.labels}) and new labels ({new_labels}) match. Not changing anything" ) else: if new_labels is None or len(new_labels) == 0: raise ValueError(f'New labels must be non-empty list of labels. But I got: {new_labels}') # Update config self._cfg.labels = new_labels decoder_config = self.decoder.to_config_dict() new_decoder_config = copy.deepcopy(decoder_config) self._update_decoder_config(new_decoder_config) del self.decoder self.decoder = EncDecClassificationModel.from_config_dict(new_decoder_config) OmegaConf.set_struct(self._cfg.decoder, False) self._cfg.decoder = new_decoder_config OmegaConf.set_struct(self._cfg.decoder, True) if 'train_ds' in self._cfg and self._cfg.train_ds is not None: self._cfg.train_ds.labels = new_labels if 'validation_ds' in self._cfg and self._cfg.validation_ds is not None: self._cfg.validation_ds.labels = new_labels if 'test_ds' in self._cfg and self._cfg.test_ds is not None: self._cfg.test_ds.labels = new_labels logging.info(f"Changed decoder output to {self.decoder.num_classes} labels.") def _update_decoder_config(self, cfg): """ Update the number of classes in the decoder based on labels provided. Args: cfg: The config of the decoder which will be updated. """ OmegaConf.set_struct(cfg, False) labels = self.cfg.labels if 'params' in cfg: cfg.params.num_classes = len(labels) else: cfg.num_classes = len(labels) OmegaConf.set_struct(cfg, True) def _setup_transcribe_dataloader(self, config: Dict) -> 'torch.utils.data.DataLoader': """ Setup function for a temporary data loader which wraps the provided audio file. Args: config: A python dictionary which contains the following keys: paths2audio_files: (a list) of paths to audio files. The files should be relatively short fragments. \ Recommended length per file is between 5 and 25 seconds. batch_size: (int) batch size to use during inference. \ Bigger will result in better throughput performance but would use more memory. temp_dir: (str) A temporary directory where the audio manifest is temporarily stored. Returns: A pytorch DataLoader for the given audio file(s). """ dl_config = { 'manifest_filepath': os.path.join(config['temp_dir'], 'manifest.json'), 'sample_rate': self.preprocessor._sample_rate, 'labels': self.cfg.labels, 'batch_size': min(config['batch_size'], len(config['paths2audio_files'])), 'trim_silence': False, 'shuffle': False, } temporary_datalayer = self._setup_dataloader_from_config(config=DictConfig(dl_config)) return temporary_datalayer def export( self, output: str, input_example=None, output_example=None, verbose=False, export_params=True, do_constant_folding=True, keep_initializers_as_inputs=False, onnx_opset_version: int = 12, try_script: bool = False, set_eval: bool = True, check_trace: bool = True, use_dynamic_axes: bool = True, ): if input_example is not None or output_example is not None: logging.warning( "Passed input and output examples will be ignored and recomputed since" " EncDecClassificationModel consists of two separate models (encoder and decoder) with different" " inputs and outputs." ) qual_name = self.__module__ + '.' + self.__class__.__qualname__ output1 = os.path.join(os.path.dirname(output), 'encoder_' + os.path.basename(output)) output1_descr = qual_name + ' Encoder exported to ONNX' encoder_onnx = self.encoder.export( output1, None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) output2 = os.path.join(os.path.dirname(output), 'decoder_' + os.path.basename(output)) output2_descr = qual_name + ' Decoder exported to ONNX' decoder_onnx = self.decoder.export( output2, None, # computed by input_example() None, verbose, export_params, do_constant_folding, keep_initializers_as_inputs, onnx_opset_version, try_script, set_eval, check_trace, use_dynamic_axes, ) output_model = attach_onnx_to_onnx(encoder_onnx, decoder_onnx, "EDC") output_descr = qual_name + ' Encoder+Decoder exported to ONNX' onnx.save(output_model, output) return ([output, output1, output2], [output_descr, output1_descr, output2_descr])
class EncDecSpeakerLabelModel(ModelPT, ExportableEncDecModel): """ Encoder decoder class for speaker label models. Model class creates training, validation methods for setting up data performing model forward pass. Expects config dict for * preprocessor * Jasper/Quartznet Encoder * Speaker Decoder """ @classmethod def list_available_models(cls) -> List[PretrainedModelInfo]: """ This method returns a list of pre-trained model which can be instantiated directly from NVIDIA's NGC cloud. Returns: List of available pre-trained models. """ result = [] model = PretrainedModelInfo( pretrained_model_name="speakerverification_speakernet", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/speakerverification_speakernet/versions/1.0.0rc1/files/speakerverification_speakernet.nemo", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:speakerverification_speakernet", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="ecapa_tdnn", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/ecapa_tdnn/versions/v1/files/ecapa_tdnn.nemo", description= "For details about this model, please visit https://ngc.nvidia.com/catalog/models/nvidia:nemo:ecapa_tdnn", ) result.append(model) model = PretrainedModelInfo( pretrained_model_name="titanet_large", location= "https://api.ngc.nvidia.com/v2/models/nvidia/nemo/titanet_large/versions/v0/files/titanet-l.nemo", description= "For details about this model, please visit https://catalog.ngc.nvidia.com/orgs/nvidia/teams/nemo/models/titanet_large", ) result.append(model) return result def __init__(self, cfg: DictConfig, trainer: Trainer = None): self.world_size = 1 if trainer is not None: self.world_size = trainer.num_nodes * trainer.num_gpus super().__init__(cfg=cfg, trainer=trainer) self.preprocessor = EncDecSpeakerLabelModel.from_config_dict( cfg.preprocessor) self.encoder = EncDecSpeakerLabelModel.from_config_dict(cfg.encoder) self.decoder = EncDecSpeakerLabelModel.from_config_dict(cfg.decoder) if 'angular' in cfg.decoder and cfg.decoder['angular']: logging.info("loss is Angular Softmax") scale = cfg.loss.scale margin = cfg.loss.margin self.loss = AngularSoftmaxLoss(scale=scale, margin=margin) else: logging.info("loss is Softmax-CrossEntropy") self.loss = CELoss() self.task = None self._accuracy = TopKClassificationAccuracy(top_k=[1]) self.labels = None @staticmethod def extract_labels(data_layer_config): labels = set() manifest_filepath = data_layer_config.get('manifest_filepath', None) if manifest_filepath is None: logging.warning( "No manifest_filepath was provided, no labels got extracted!") return None manifest_filepaths = convert_to_config_list( data_layer_config['manifest_filepath']) for manifest_filepath in itertools.chain.from_iterable( manifest_filepaths): collection = ASRSpeechLabel( manifests_files=manifest_filepath, min_duration=data_layer_config.get("min_duration", None), max_duration=data_layer_config.get("max_duration", None), index_by_file_id=False, ) labels.update(collection.uniq_labels) labels = list(sorted(labels)) logging.warning( f"Total number of {len(labels)} found in all the manifest files.") return labels def __setup_dataloader_from_config(self, config: Optional[Dict]): if 'augmentor' in config: augmentor = process_augmentations(config['augmentor']) else: augmentor = None featurizer = WaveformFeaturizer(sample_rate=config['sample_rate'], int_values=config.get( 'int_values', False), augmentor=augmentor) shuffle = config.get('shuffle', False) if config.get('is_tarred', False): if ('tarred_audio_filepaths' in config and config['tarred_audio_filepaths'] is None) or ( 'manifest_filepath' in config and config['manifest_filepath'] is None): logging.warning( "Could not load dataset as `manifest_filepath` was None or " f"`tarred_audio_filepaths` is None. Provided config : {config}" ) return None shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0 dataset = get_tarred_speech_label_dataset( featurizer=featurizer, config=config, shuffle_n=shuffle_n, global_rank=self.global_rank, world_size=self.world_size, ) shuffle = False else: if 'manifest_filepath' in config and config[ 'manifest_filepath'] is None: logging.warning( f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}" ) return None dataset = AudioToSpeechLabelDataset( manifest_filepath=config['manifest_filepath'], labels=config['labels'], featurizer=featurizer, max_duration=config.get('max_duration', None), min_duration=config.get('min_duration', None), trim=config.get('trim_silence', False), normalize_audio=config.get('normalize_audio', False), ) if hasattr(dataset, 'fixed_seq_collate_fn'): collate_fn = dataset.fixed_seq_collate_fn else: collate_fn = dataset.datasets[0].fixed_seq_collate_fn batch_size = config['batch_size'] return torch.utils.data.DataLoader( dataset=dataset, batch_size=batch_size, collate_fn=collate_fn, drop_last=config.get('drop_last', False), shuffle=shuffle, num_workers=config.get('num_workers', 0), pin_memory=config.get('pin_memory', False), ) def setup_training_data(self, train_data_layer_config: Optional[Union[DictConfig, Dict]]): self.labels = self.extract_labels(train_data_layer_config) train_data_layer_config['labels'] = self.labels if 'shuffle' not in train_data_layer_config: train_data_layer_config['shuffle'] = True self._train_dl = self.__setup_dataloader_from_config( config=train_data_layer_config) def setup_validation_data(self, val_data_layer_config: Optional[Union[DictConfig, Dict]]): val_data_layer_config['labels'] = self.labels self._validation_dl = self.__setup_dataloader_from_config( config=val_data_layer_config) def setup_test_data(self, test_data_layer_params: Optional[Union[DictConfig, Dict]]): if hasattr(self, 'dataset'): test_data_layer_params['labels'] = self.labels self.embedding_dir = test_data_layer_params.get('embedding_dir', './') self._test_dl = self.__setup_dataloader_from_config( config=test_data_layer_params) self.test_manifest = test_data_layer_params.get( 'manifest_filepath', None) def test_dataloader(self): if self._test_dl is not None: return self._test_dl @property def input_types(self) -> Optional[Dict[str, NeuralType]]: if hasattr(self.preprocessor, '_sample_rate'): audio_eltype = AudioSignal(freq=self.preprocessor._sample_rate) else: audio_eltype = AudioSignal() return { "input_signal": NeuralType(('B', 'T'), audio_eltype), "input_signal_length": NeuralType(tuple('B'), LengthsType()), } @property def output_types(self) -> Optional[Dict[str, NeuralType]]: return { "logits": NeuralType(('B', 'D'), LogitsType()), "embs": NeuralType(('B', 'D'), AcousticEncodedRepresentation()), } @typecheck() def forward(self, input_signal, input_signal_length): processed_signal, processed_signal_len = self.preprocessor( input_signal=input_signal, length=input_signal_length, ) encoded, length = self.encoder(audio_signal=processed_signal, length=processed_signal_len) logits, embs = self.decoder(encoder_output=encoded, length=length) return logits, embs # PTL-specific methods def training_step(self, batch, batch_idx): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss = self.loss(logits=logits, labels=labels) self.log('loss', loss) self.log('learning_rate', self._optimizer.param_groups[0]['lr']) self._accuracy(logits=logits, labels=labels) top_k = self._accuracy.compute() self._accuracy.reset() for i, top_i in enumerate(top_k): self.log(f'training_batch_accuracy_top@{i}', top_i) return {'loss': loss} def validation_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'val_loss': loss_value, 'val_correct_counts': correct_counts, 'val_total_counts': total_counts, 'val_acc_top_k': acc_top_k, } def multi_validation_epoch_end(self, outputs, dataloader_idx: int = 0): val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['val_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['val_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() self._accuracy.reset() logging.info("val_loss: {:.3f}".format(val_loss_mean)) self.log('val_loss', val_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('val_epoch_accuracy_top@{}'.format(top_k), score) return { 'val_loss': val_loss_mean, 'val_acc_top_k': topk_scores, } def test_step(self, batch, batch_idx, dataloader_idx: int = 0): audio_signal, audio_signal_len, labels, _ = batch logits, _ = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) loss_value = self.loss(logits=logits, labels=labels) acc_top_k = self._accuracy(logits=logits, labels=labels) correct_counts, total_counts = self._accuracy.correct_counts_k, self._accuracy.total_counts_k return { 'test_loss': loss_value, 'test_correct_counts': correct_counts, 'test_total_counts': total_counts, 'test_acc_top_k': acc_top_k, } def multi_test_epoch_end(self, outputs, dataloader_idx: int = 0): test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean() correct_counts = torch.stack( [x['test_correct_counts'] for x in outputs]).sum(axis=0) total_counts = torch.stack([x['test_total_counts'] for x in outputs]).sum(axis=0) self._accuracy.correct_counts_k = correct_counts self._accuracy.total_counts_k = total_counts topk_scores = self._accuracy.compute() self._accuracy.reset() logging.info("test_loss: {:.3f}".format(test_loss_mean)) self.log('test_loss', test_loss_mean) for top_k, score in zip(self._accuracy.top_k, topk_scores): self.log('test_epoch_accuracy_top@{}'.format(top_k), score) return { 'test_loss': test_loss_mean, 'test_acc_top_k': topk_scores, } def setup_finetune_model(self, model_config: DictConfig): """ setup_finetune_model method sets up training data, validation data and test data with new provided config, this checks for the previous labels set up during training from scratch, if None, it sets up labels for provided finetune data from manifest files Args: model_config: cfg which has train_ds, optional validation_ds, optional test_ds, mandatory encoder and decoder model params. Make sure you set num_classes correctly for finetune data. Returns: None """ logging.info( "Setting up data loaders with manifests provided from model_config" ) if 'train_ds' in model_config and model_config.train_ds is not None: self.setup_training_data(model_config.train_ds) else: raise KeyError( "train_ds is not found in model_config but you need it for fine tuning" ) if self.labels is None or len(self.labels) == 0: raise ValueError( f'New labels must be non-empty list of labels. But I got: {self.labels}' ) if 'validation_ds' in model_config and model_config.validation_ds is not None: self.setup_multiple_validation_data(model_config.validation_ds) if 'test_ds' in model_config and model_config.test_ds is not None: self.setup_multiple_test_data(model_config.test_ds) if self.labels is not None: # checking for new finetune dataset labels logging.warning( "Trained dataset labels are same as finetune dataset labels -- continuing change of decoder parameters" ) else: logging.warning( "Either you provided a dummy manifest file during training from scratch or you restored from a pretrained nemo file" ) decoder_config = model_config.decoder new_decoder_config = copy.deepcopy(decoder_config) if new_decoder_config['num_classes'] != len(self.labels): raise ValueError( "number of classes provided {} is not same as number of different labels in finetuning data: {}" .format(new_decoder_config['num_classes'], len(self.labels))) del self.decoder self.decoder = EncDecSpeakerLabelModel.from_config_dict( new_decoder_config) with open_dict(self._cfg.decoder): self._cfg.decoder = new_decoder_config logging.info( f"Changed decoder output to # {self.decoder._num_classes} classes." ) @torch.no_grad() def get_embedding(self, path2audio_file): """ Returns the speaker embeddings for a provided audio file. Args: path2audio_file: path to audio wav file Returns: embs: speaker embeddings """ audio, sr = librosa.load(path2audio_file, sr=None) target_sr = self._cfg.train_ds.get('sample_rate', 16000) if sr != target_sr: audio = librosa.core.resample(audio, sr, target_sr) audio_length = audio.shape[0] device = self.device audio = np.array(audio) audio_signal, audio_signal_len = ( torch.tensor([audio], device=device), torch.tensor([audio_length], device=device), ) mode = self.training self.freeze() _, embs = self.forward(input_signal=audio_signal, input_signal_length=audio_signal_len) self.train(mode=mode) if mode is True: self.unfreeze() del audio_signal, audio_signal_len return embs @torch.no_grad() def verify_speakers(self, path2audio_file1, path2audio_file2, threshold=0.7): """ Verify if two audio files are from the same speaker or not. Args: path2audio_file1: path to audio wav file of speaker 1 path2audio_file2: path to audio wav file of speaker 2 threshold: cosine similarity score used as a threshold to distinguish two embeddings (default = 0.7) Returns: True if both audio files are from same speaker, False otherwise """ embs1 = self.get_embedding(path2audio_file1).squeeze() embs2 = self.get_embedding(path2audio_file2).squeeze() # Length Normalize X = embs1 / torch.linalg.norm(embs1) Y = embs1 / torch.linalg.norm(embs2) # Score similarity_score = torch.dot(X, Y) / ( (torch.dot(X, X) * torch.dot(Y, Y))**0.5) similarity_score = (similarity_score + 1) / 2 # Decision if similarity_score >= threshold: logging.info(" two audio files are from same speaker") return True else: logging.info(" two audio files are from different speakers") return False