


'''simple docstring'''







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    :     str					=						True
       from torch.cuda.amp import autocast


lowerCAmelCase    :     int					=						logging.getLogger(__name__)
@dataclass
class 	UpperCamelCase__					:



     """simple docstring"""






     __magic_name__    			=    field(
         metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}	)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}    ,					)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "Whether to freeze the feature extractor layers of the model."}	)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "Whether to log verbose messages or not."}    ,					)
     __magic_name__    			=    field(
         default=2.0    ,					metadata={"help": "Maximum temperature for gumbel softmax."}	)
     __magic_name__    			=    field(
         default=0.5    ,					metadata={"help": "Minimum temperature for gumbel softmax."}	)
     __magic_name__    			=    field(
         default=0.999_995    ,					metadata={"help": "Decay of gumbel temperature during training."}	)






def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       logging.basicConfig(
           format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'   ,						datefmt='%m/%d/%Y %H:%M:%S'   ,						handlers=[logging.StreamHandler(sys.stdout					)]   ,						)
       _lowerCAmelCase    :							List[str]   			=       logging.WARNING
       if model_args.verbose_logging:
              _lowerCAmelCase    :							str   			=       logging.DEBUG
       elif trainer_utils.is_main_process(training_args.local_rank					):
              _lowerCAmelCase    :							List[str]   			=       logging.INFO
       logger.setLevel(_A					)
@dataclass
class 	UpperCamelCase__					:



     """simple docstring"""






     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "The name of the dataset to use (via the datasets library)."}	)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}	)
     __magic_name__    			=    field(
         default="train"    ,					metadata={
             "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
         }    ,					)
     __magic_name__    			=    field(
         default="validation"    ,					metadata={
             "help": (
                 "The name of the validation data set split to use (via the datasets library). Defaults to 'validation'"
             )
         }    ,					)
     __magic_name__    			=    field(
         default="file"    ,					metadata={"help": "Column in the dataset that contains speech file path. Defaults to 'file'"}    ,					)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "Overwrite the cached preprocessed datasets or not."}	)
     __magic_name__    			=    field(
         default=1    ,					metadata={
             "help": "The percentage of the train set used as validation set in case there's no validation split"
         }    ,					)
     __magic_name__    			=    field(
         default=SCREAMING_SNAKE_CASE_    ,					metadata={"help": "The number of processes to use for the preprocessing."}    ,					)
     __magic_name__    			=    field(
         default=20.0    ,					metadata={"help": "Filter audio files that are longer than `max_duration_in_seconds` seconds"}	)
@dataclass
class 	UpperCamelCase__					:



     """simple docstring"""






     __magic_name__    			=    42
     __magic_name__    			=    42
     __magic_name__    			=    "longest"
     __magic_name__    			=    None
     __magic_name__    			=    None







     def __call__( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       self.feature_extractor.pad(
                snake_case__      ,	max_length=self.max_length      ,	padding=self.padding      ,	pad_to_multiple_of=self.pad_to_multiple_of      ,	return_tensors='pt'      ,	)
            _lowerCAmelCase    :							int   			=       self.model._get_feat_extract_output_lengths(batch['input_values'].shape[-1]   )

            _lowerCAmelCase    :							int   			=       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
                   _lowerCAmelCase    :							str   			=       self.model._get_feat_extract_output_lengths(batch['attention_mask'].sum(-1   )   ).to(
                       torch.long   )

                   _lowerCAmelCase    :							Dict   			=       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
                   _lowerCAmelCase    :							Tuple   			=       1
                   _lowerCAmelCase    :							Union[str, Any]   			=       attention_mask.flip([-1]   ).cumsum(-1   ).flip([-1]   ).bool()

            # sample randomly masked indices
            _lowerCAmelCase    :							List[str]   			=       _compute_mask_indices(
                (batch_size, mask_indices_seq_length)      ,	self.model.config.mask_time_prob      ,	self.model.config.mask_time_length      ,	attention_mask=snake_case__      ,	min_masks=2      ,	)

            return batch
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def __init__( self      ,	*snake_case__      ,	snake_case__=1      ,	snake_case__=0      ,	snake_case__=1.0      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(*snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       0
            _lowerCAmelCase    :							Any   			=       max_gumbel_temp
            _lowerCAmelCase    :							Union[str, Any]   			=       min_gumbel_temp
            _lowerCAmelCase    :							List[str]   			=       gumbel_temp_decay







     def a	( self      ,	snake_case__      ,	snake_case__   ):

            '''simple docstring'''

            model.train()
            _lowerCAmelCase    :							Optional[Any]   			=       self._prepare_inputs(snake_case__   )

            if self.use_amp:
                   with autocast():
                          _lowerCAmelCase    :							str   			=       self.compute_loss(snake_case__      ,	snake_case__   )
            else:
                   _lowerCAmelCase    :							Dict   			=       self.compute_loss(snake_case__      ,	snake_case__   )

            if self.args.n_gpu > 1 or self.deepspeed:
                   if model.module.config.ctc_loss_reduction == "mean":
                          _lowerCAmelCase    :							List[str]   			=       loss.mean()
                   elif model.module.config.ctc_loss_reduction == "sum":
                          _lowerCAmelCase    :							int   			=       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:
                   _lowerCAmelCase    :							Union[str, Any]   			=       loss / self.args.gradient_accumulation_steps

            if self.use_amp:
                   self.scaler.scale(snake_case__   ).backward()
            elif self.use_apex:
                   with amp.scale_loss(snake_case__      ,	self.optimizer   ) as scaled_loss:
                          scaled_loss.backward()
            elif self.deepspeed:
                   self.deepspeed.backward(snake_case__   )
            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 			lowercase				():







       """simple docstring"""







       _lowerCAmelCase    :							str   			=       HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)					)

       _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase    :							Optional[Any]   			=       parser.parse_args_into_dataclasses()
       configure_logger(_A   ,						_A					)

       # Downloading and loading a dataset from the hub.
       _lowerCAmelCase    :							List[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"
              _lowerCAmelCase    :							Union[str, Any]   			=       DatasetDict()
              _lowerCAmelCase    :							Union[str, 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   ,						)
              _lowerCAmelCase    :							Union[str, 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   ,						)
       else:
              # make sure only "validation" and "train" keys remain"
              _lowerCAmelCase    :							List[Any]   			=       DatasetDict()
              _lowerCAmelCase    :							List[Any]   			=       load_dataset(
                  data_args.dataset_name   ,						data_args.dataset_config_name   ,						split='validation'   ,						cache_dir=model_args.cache_dir   ,						)
              _lowerCAmelCase    :							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
       _lowerCAmelCase    :							str   			=       WavaVecaFeatureExtractor.from_pretrained(
           model_args.model_name_or_path   ,						cache_dir=model_args.cache_dir   ,						do_normalize=_A					)

       def prepare_dataset(_A					):
              # check that all files have the correct sampling rate
              _lowerCAmelCase			,     _lowerCAmelCase    :							List[str]   			=       librosa.load(batch[data_args.speech_file_column]   ,						sr=feature_extractor.sampling_rate					)
              return batch

       # load audio files into numpy arrays
       _lowerCAmelCase    :							Union[str, Any]   			=       datasets.map(
           _A   ,						num_proc=data_args.preprocessing_num_workers   ,						remove_columns=datasets['train'].column_names					)

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

       def normalize(_A					):
              return feature_extractor(batch['speech']   ,						sampling_rate=feature_extractor.sampling_rate					)

       # normalize and transform to `BatchFeatures`
       _lowerCAmelCase    :							Union[str, Any]   			=       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
       _lowerCAmelCase    :							Optional[Any]   			=       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\''					)

       _lowerCAmelCase    :							Any   			=       WavaVecaForPreTraining(_A					)

       _lowerCAmelCase    :							Union[str, Any]   			=       DataCollatorForWavaVecaPretraining(model=_A   ,						feature_extractor=_A					)

       _lowerCAmelCase    :							Optional[int]   			=       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()





'''simple docstring'''







import math
from datetime import datetime, timedelta






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Optional[Any]   			=       year % 1_9
       _lowerCAmelCase    :							Any   			=       year % 4
       _lowerCAmelCase    :							Optional[int]   			=       year % 7
       _lowerCAmelCase    :							int   			=       math.floor(year / 1_0_0					)
       _lowerCAmelCase    :							Dict   			=       math.floor((1_3 + 8 * leap_day_inhibits) / 2_5					)
       _lowerCAmelCase    :							Optional[Any]   			=       leap_day_inhibits / 4
       _lowerCAmelCase    :							Dict   			=       (
           1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
       ) % 3_0
       _lowerCAmelCase    :							List[Any]   			=       (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

       # days to be added to March 21
       _lowerCAmelCase    :							Dict   			=       (1_9 * metonic_cycle + secular_moon_shift) % 3_0

       # PHM -> Paschal Full Moon
       _lowerCAmelCase    :							Union[str, Any]   			=       (
           2 * julian_leap_year
           + 4 * non_leap_year
           + 6 * days_to_add
           + century_starting_point
       ) % 7

       if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_9					)
       elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_8					)
       else:
              return datetime(_A   ,						3   ,						2_2					) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday					)					)


if __name__ == "__main__":
       for year in (19_94, 20_00, 20_10, 20_21, 20_23):
              lowerCAmelCase    :     List[str]					=						"""will be""" if year > datetime.now().year else """was"""
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

