





import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
	from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse('''1.6'''):
	lowerCamelCase : int						   =       True
	from torch.cuda.amp import autocast


lowerCamelCase : Optional[Any]						   =       logging.getLogger(__name__)

@dataclass
class 		lowerCAmelCase     :

					'''simple docstring'''

					_A						:			Optional[Any]									=      field(
					    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}			)
					_A						:			Union[str, Any]									=      field(
					    default=_A      ,       metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}      ,       )
					_A						:			List[str]									=      field(
					    default=_A      ,       metadata={'''help''': '''Whether to freeze the feature extractor layers of the model.'''}			)
					_A						:			Union[str, Any]									=      field(
					    default=_A      ,       metadata={'''help''': '''Whether to log verbose messages or not.'''}      ,       )
					_A						:			str									=      field(
					    default=2.0      ,       metadata={'''help''': '''Maximum temperature for gumbel softmax.'''}			)
					_A						:			Dict									=      field(
					    default=0.5      ,       metadata={'''help''': '''Minimum temperature for gumbel softmax.'''}			)
					_A						:			str									=      field(
					    default=0.9_9_9_9_9_5      ,       metadata={'''help''': '''Decay of gumbel temperature during training.'''}			)







def       snake_case_		(     lowerCAmelCase_       :						str       ,       lowerCAmelCase_       :						Dict      ):
							logging.basicConfig(
							    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""       ,       datefmt="""%m/%d/%Y %H:%M:%S"""       ,       handlers=[logging.StreamHandler(sys.stdout      )]       ,       )
							__lowercase      :							Optional[Any]				=     logging.WARNING
							if model_args.verbose_logging:
														__lowercase      :							int				=     logging.DEBUG
							elif trainer_utils.is_main_process(training_args.local_rank      ):
														__lowercase      :							Optional[int]				=     logging.INFO
							logger.setLevel(A_      )

@dataclass
class 		lowerCAmelCase     :

					'''simple docstring'''

					_A						:			Any									=      field(
					    default=_A      ,       metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''}			)
					_A						:			Optional[Any]									=      field(
					    default=_A      ,       metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''}			)
					_A						:			Optional[Any]									=      field(
					    default='''train'''      ,       metadata={
					        '''help''': '''The name of the training data set split to use (via the datasets library). Defaults to \'train\''''
					    }      ,       )
					_A						:			Any									=      field(
					    default='''validation'''      ,       metadata={
					        '''help''': (
					            '''The name of the validation data set split to use (via the datasets library). Defaults to \'validation\''''
					        )
					    }      ,       )
					_A						:			str									=      field(
					    default='''file'''      ,       metadata={'''help''': '''Column in the dataset that contains speech file path. Defaults to \'file\''''}      ,       )
					_A						:			int									=      field(
					    default=_A      ,       metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''}			)
					_A						:			str									=      field(
					    default=1      ,       metadata={
					        '''help''': '''The percentage of the train set used as validation set in case there\'s no validation split'''
					    }      ,       )
					_A						:			str									=      field(
					    default=_A      ,       metadata={'''help''': '''The number of processes to use for the preprocessing.'''}      ,       )
					_A						:			Tuple									=      field(
					    default=2_0.0      ,       metadata={'''help''': '''Filter audio files that are longer than `max_duration_in_seconds` seconds'''}			)







@dataclass
class 		lowerCAmelCase     :

					'''simple docstring'''

					_A						:			Optional[int]									=      42
					_A						:			Union[str, Any]									=      42
					_A						:			int									=      '''longest'''
					_A						:			Dict									=      None
					_A						:			Any									=      None



					def __call__(  self				:	int		,     __a				:	List[Dict[str, Union[List[int], torch.Tensor]]]							)			->  Dict[str, torch.Tensor]:


												"""simple docstring"""

												__lowercase      :							str				=     self.feature_extractor.pad(
												    UpperCamelCase__		,     max_length=self.max_length		,     padding=self.padding		,     pad_to_multiple_of=self.pad_to_multiple_of		,     return_tensors="""pt"""		,     )
												__lowercase      :							int				=     self.model._get_feat_extract_output_lengths(batch["""input_values"""].shape[-1]							)

												__lowercase      :							List[Any]				=     batch["""input_values"""].shape[0]

												# make sure that no loss is computed on padded inputs
												if batch["attention_mask"] is not None:
																			# compute real output lengths according to convolution formula
																			__lowercase      :							int				=     self.model._get_feat_extract_output_lengths(batch["""attention_mask"""].sum(-1							)							).to(
																			    torch.long							)

																			__lowercase      :							Optional[Any]				=     torch.zeros(
																			    (batch_size, mask_indices_seq_length)		,     dtype=torch.long		,     device=batch["""input_values"""].device							)

																			# these two operations makes sure that all values
																			# before the output lengths indices are attended to
																			__lowercase      :							Dict				=     1
																			__lowercase      :							Any				=     attention_mask.flip([-1]							).cumsum(-1							).flip([-1]							).bool()

												# sample randomly masked indices
												__lowercase      :							int				=     _compute_mask_indices(
												    (batch_size, mask_indices_seq_length)		,     self.model.config.mask_time_prob		,     self.model.config.mask_time_length		,     attention_mask=UpperCamelCase__		,     min_masks=2		,     )

												return batch







class 		lowerCAmelCase     ( _A			):

					'''simple docstring'''

					def __init__(  self				:	int		,     *__a				:	List[Any]		,     __a				:	Optional[int]=1		,     __a				:	Dict=0		,     __a				:	Union[str, Any]=1.0		,     **__a				:	Optional[int]							)			->  List[Any]:


												"""simple docstring"""

												super().__init__(*UpperCamelCase__		,     **UpperCamelCase__							)
												__lowercase      :							str				=     0
												__lowercase      :							List[Any]				=     max_gumbel_temp
												__lowercase      :							List[Any]				=     min_gumbel_temp
												__lowercase      :							List[Any]				=     gumbel_temp_decay



					def       lowerCAmelCase				(  self				:	Any		,     __a				:	nn.Module		,     __a				:	Dict[str, Union[torch.Tensor, Any]]							)			->  torch.Tensor:


												"""simple docstring"""

												model.train()
												__lowercase      :							Any				=     self._prepare_inputs(UpperCamelCase__							)

												if self.use_amp:
																			with autocast():
																										__lowercase      :							Tuple				=     self.compute_loss(UpperCamelCase__		,     UpperCamelCase__							)
												else:
																			__lowercase      :							List[str]				=     self.compute_loss(UpperCamelCase__		,     UpperCamelCase__							)

												if self.args.n_gpu > 1 or self.deepspeed:
																			if model.module.config.ctc_loss_reduction == "mean":
																										__lowercase      :							List[str]				=     loss.mean()
																			elif model.module.config.ctc_loss_reduction == "sum":
																										__lowercase      :							str				=     loss.sum() / (inputs["""mask_time_indices"""]).sum()
																			else:
																										raise ValueError(F"{model.config.ctc_loss_reduction} is not valid. Choose one of [\'mean\', \'sum\']"							)

												if self.args.gradient_accumulation_steps > 1:
																			__lowercase      :							Union[str, Any]				=     loss / self.args.gradient_accumulation_steps

												if self.use_amp:
																			self.scaler.scale(UpperCamelCase__							).backward()
												elif self.use_apex:
																			with amp.scale_loss(UpperCamelCase__		,     self.optimizer							) as scaled_loss:
																										scaled_loss.backward()
												elif self.deepspeed:
																			self.deepspeed.backward(UpperCamelCase__							)
												else:
																			loss.backward()

												self.num_update_step += 1
												# make sure gumbel softmax temperature is decayed
												if self.args.n_gpu > 1 or self.deepspeed:
																			model.module.set_gumbel_temperature(
																			    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step		,     self.min_gumbel_temp							)							)
												else:
																			model.set_gumbel_temperature(
																			    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step		,     self.min_gumbel_temp							)							)

												return loss.detach()







def       snake_case_		(     ):
							__lowercase      :							Optional[Any]				=     HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)      )

							__lowercase			,			__lowercase			,			__lowercase      :							Union[str, Any]				=     parser.parse_args_into_dataclasses()
							configure_logger(A_       ,       A_      )

							# Downloading and loading a dataset from the hub.
							__lowercase      :							Optional[Any]				=     load_dataset(data_args.dataset_name       ,       data_args.dataset_config_name       ,       cache_dir=model_args.cache_dir      )

							if "validation" not in datasets.keys():
														# make sure only "validation" and "train" keys remain"
														__lowercase      :							List[Any]				=     DatasetDict()
														__lowercase      :							Optional[Any]				=     load_dataset(
														    data_args.dataset_name       ,       data_args.dataset_config_name       ,       split=F"{data_args.train_split_name}[:{data_args.validation_split_percentage}%]"       ,       cache_dir=model_args.cache_dir       ,       )
														__lowercase      :							int				=     load_dataset(
														    data_args.dataset_name       ,       data_args.dataset_config_name       ,       split=F"{data_args.train_split_name}[{data_args.validation_split_percentage}%:]"       ,       cache_dir=model_args.cache_dir       ,       )
							else:
														# make sure only "validation" and "train" keys remain"
														__lowercase      :							List[str]				=     DatasetDict()
														__lowercase      :							List[str]				=     load_dataset(
														    data_args.dataset_name       ,       data_args.dataset_config_name       ,       split="""validation"""       ,       cache_dir=model_args.cache_dir       ,       )
														__lowercase      :							List[str]				=     load_dataset(
														    data_args.dataset_name       ,       data_args.dataset_config_name       ,       split=F"{data_args.train_split_name}"       ,       cache_dir=model_args.cache_dir       ,       )

							# only normalized-inputs-training is supported
							__lowercase      :							List[Any]				=     WavaVecaFeatureExtractor.from_pretrained(
							    model_args.model_name_or_path       ,       cache_dir=model_args.cache_dir       ,       do_normalize=A_      )

							def prepare_dataset(lowerCAmelCase_       :						Optional[Any]      ):
														# check that all files have the correct sampling rate
														__lowercase			,			__lowercase      :							int				=     librosa.load(batch[data_args.speech_file_column]       ,       sr=feature_extractor.sampling_rate      )
														return batch

							# load audio files into numpy arrays
							__lowercase      :							Optional[Any]				=     datasets.map(
							    A_       ,       num_proc=data_args.preprocessing_num_workers       ,       remove_columns=datasets["""train"""].column_names      )

							# filter audio files that are too long
							__lowercase      :							Union[str, Any]				=     vectorized_datasets.filter(
							    lambda lowerCAmelCase_      : len(data["""speech"""]      ) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate      )      )

							def normalize(lowerCAmelCase_       :						int      ):
														return feature_extractor(batch["""speech"""]       ,       sampling_rate=feature_extractor.sampling_rate      )

							# normalize and transform to `BatchFeatures`
							__lowercase      :							Dict				=     vectorized_datasets.map(
							    A_       ,       batched=A_       ,       num_proc=data_args.preprocessing_num_workers       ,       load_from_cache_file=not data_args.overwrite_cache       ,       remove_columns=vectorized_datasets["""train"""].column_names       ,       )

							# pretraining is only supported for "newer" stable layer norm architecture
							# apply_spec_augment has to be True, mask_feature_prob has to be 0.0
							__lowercase      :							int				=     WavaVecaConfig.from_pretrained(
							    model_args.model_name_or_path       ,       cache_dir=model_args.cache_dir       ,       gradient_checkpointing=training_args.gradient_checkpointing       ,       )

							if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
														raise ValueError(
														    """PreTraining is only supported for ``config.do_stable_layer_norm=True`` and"""
														    """ ``config.feat_extract_norm='layer'"""      )

							__lowercase      :							List[str]				=     WavaVecaForPreTraining(A_      )

							__lowercase      :							Any				=     DataCollatorForWavaVecaPretraining(model=A_       ,       feature_extractor=A_      )

							__lowercase      :							List[Any]				=     WavaVecaPreTrainer(
							    model=A_       ,       data_collator=A_       ,       args=A_       ,       train_dataset=vectorized_datasets["""train"""]       ,       eval_dataset=vectorized_datasets["""validation"""]       ,       tokenizer=A_       ,       max_gumbel_temp=model_args.max_gumbel_temperature       ,       min_gumbel_temp=model_args.min_gumbel_temperature       ,       gumbel_temp_decay=model_args.gumbel_temperature_decay       ,       )
							trainer.train()


if __name__ == "__main__":
	main()







def       snake_case_		(     lowerCAmelCase_       :						int       ,       lowerCAmelCase_       :						int      ):
							return int((input_a, input_a).count(1      ) != 0      )
def       snake_case_		(     ):
							assert or_gate(0       ,       0      ) == 0
							assert or_gate(0       ,       1      ) == 1
							assert or_gate(1       ,       0      ) == 1
							assert or_gate(1       ,       1      ) == 1


if __name__ == "__main__":
	print(or_gate(0, 1))
	print(or_gate(1, 0))
	print(or_gate(0, 0))
	print(or_gate(1, 1))