




import logging
import os
import random
import sys
from dataclasses import dataclass, field
from typing import Optional

import datasets
import evaluate
import numpy as np
from datasets import load_dataset

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version


# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.31.0")

require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")

__UpperCamelCase					:       Optional[int]    					=      logging.getLogger(__name__)

@dataclass
class 		__lowerCAmelCase	:
							UpperCamelCase__					     =  field(
							    default=128      ,       metadata={
							        '''help''': (
							            '''The maximum total input sequence length after tokenization. Sequences longer '''
							            '''than this will be truncated, sequences shorter will be padded.'''
							        )
							    }      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={
							        '''help''': (
							            '''Whether to pad all samples to `max_seq_length`. '''
							            '''If False, will pad the samples dynamically when batching to the maximum length in the batch.'''
							        )
							    }      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={
							        '''help''': (
							            '''For debugging purposes or quicker training, truncate the number of training examples to this '''
							            '''value if set.'''
							        )
							    }      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={
							        '''help''': (
							            '''For debugging purposes or quicker training, truncate the number of evaluation examples to this '''
							            '''value if set.'''
							        )
							    }      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={
							        '''help''': (
							            '''For debugging purposes or quicker training, truncate the number of prediction examples to this '''
							            '''value if set.'''
							        )
							    }      ,       )







@dataclass
class 		__lowerCAmelCase	:
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Evaluation language. Also train language if `train_language` is set to None.'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Train language if it is different from the evaluation language.'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''arg to indicate if tokenizer should do lower case in AutoTokenizer.from_pretrained()'''}      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''}      ,       )
							UpperCamelCase__					     =  field(
							    default='''main'''      ,       metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''}      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={
							        '''help''': (
							            '''Will use the token generated when running `huggingface-cli login` (necessary to use this script '''
							            '''with private models).'''
							        )
							    }      ,       )
							UpperCamelCase__					     =  field(
							    default=__magic_name__      ,       metadata={'''help''': '''Will enable to load a pretrained model whose head dimensions are different.'''}      ,       )







def 		__A		(	)      ->       Any:
	# See all possible arguments in src/transformers/training_args.py
	# or by passing the --help flag to this script.
	# We now keep distinct sets of args, for a cleaner separation of concerns.

	a										=							HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)    )
	a				, a				, a										=							parser.parse_args_into_dataclasses()

	# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
	# information sent is the one passed as arguments along with your Python/PyTorch versions.
	send_example_telemetry("""run_xnli"""							,			__lowerCamelCase    )

	# Setup logging
	logging.basicConfig(
	    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""							,			datefmt="""%m/%d/%Y %H:%M:%S"""							,			handlers=[logging.StreamHandler(sys.stdout    )]							,			)

	if training_args.should_log:
		# The default of training_args.log_level is passive, so we set log level at info here to have that default.
		transformers.utils.logging.set_verbosity_info()

	a										=							training_args.get_process_log_level()
	logger.setLevel(__lowerCamelCase    )
	datasets.utils.logging.set_verbosity(__lowerCamelCase    )
	transformers.utils.logging.set_verbosity(__lowerCamelCase    )
	transformers.utils.logging.enable_default_handler()
	transformers.utils.logging.enable_explicit_format()

	# Log on each process the small summary:
	logger.warning(
	    f'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
	    + f'distributed training: {bool(training_args.local_rank != -1    )}, 16-bits training: {training_args.fpaa}'    )
	logger.info(f'Training/evaluation parameters {training_args}'    )

	# Detecting last checkpoint.
	a										=							None
	if os.path.isdir(training_args.output_dir    ) and training_args.do_train and not training_args.overwrite_output_dir:
		a										=							get_last_checkpoint(training_args.output_dir    )
		if last_checkpoint is None and len(os.listdir(training_args.output_dir    )    ) > 0:
			raise ValueError(
			    f'Output directory ({training_args.output_dir}) already exists and is not empty. '
			    """Use --overwrite_output_dir to overcome."""    )
		elif last_checkpoint is not None:
			logger.info(
			    f'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
			    """the `--output_dir` or add `--overwrite_output_dir` to train from scratch."""    )

    # Set seed before initializing model.
	set_seed(training_args.seed    )

	# In distributed training, the load_dataset function guarantees that only one local process can concurrently
	# download the dataset.
	# Downloading and loading xnli dataset from the hub.
	if training_args.do_train:
		if model_args.train_language is None:
			a										=							load_dataset(
			    """xnli"""							,			model_args.language							,			split="""train"""							,			cache_dir=model_args.cache_dir							,			use_auth_token=True if model_args.use_auth_token else None							,			)
		else:
			a										=							load_dataset(
			    """xnli"""							,			model_args.train_language							,			split="""train"""							,			cache_dir=model_args.cache_dir							,			use_auth_token=True if model_args.use_auth_token else None							,			)
		a										=							train_dataset.features["""label"""].names

	if training_args.do_eval:
		a										=							load_dataset(
		    """xnli"""							,			model_args.language							,			split="""validation"""							,			cache_dir=model_args.cache_dir							,			use_auth_token=True if model_args.use_auth_token else None							,			)
		a										=							eval_dataset.features["""label"""].names

	if training_args.do_predict:
		a										=							load_dataset(
		    """xnli"""							,			model_args.language							,			split="""test"""							,			cache_dir=model_args.cache_dir							,			use_auth_token=True if model_args.use_auth_token else None							,			)
		a										=							predict_dataset.features["""label"""].names

	# Labels
	a										=							len(__lowerCamelCase    )

	# Load pretrained model and tokenizer
	# In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently
	# download model & vocab.
	a										=							AutoConfig.from_pretrained(
	    model_args.config_name if model_args.config_name else model_args.model_name_or_path							,			num_labels=__lowerCamelCase							,			idalabel={str(__lowerCamelCase    ): label for i, label in enumerate(__lowerCamelCase    )}							,			labelaid={label: i for i, label in enumerate(__lowerCamelCase    )}							,			finetuning_task="""xnli"""							,			cache_dir=model_args.cache_dir							,			revision=model_args.model_revision							,			use_auth_token=True if model_args.use_auth_token else None							,			)
	a										=							AutoTokenizer.from_pretrained(
	    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path							,			do_lower_case=model_args.do_lower_case							,			cache_dir=model_args.cache_dir							,			use_fast=model_args.use_fast_tokenizer							,			revision=model_args.model_revision							,			use_auth_token=True if model_args.use_auth_token else None							,			)
	a										=							AutoModelForSequenceClassification.from_pretrained(
	    model_args.model_name_or_path							,			from_tf=bool(""".ckpt""" in model_args.model_name_or_path    )							,			config=__lowerCamelCase							,			cache_dir=model_args.cache_dir							,			revision=model_args.model_revision							,			use_auth_token=True if model_args.use_auth_token else None							,			ignore_mismatched_sizes=model_args.ignore_mismatched_sizes							,			)

	# Preprocessing the datasets
	# Padding strategy
	if data_args.pad_to_max_length:
		a										=							"""max_length"""
	else:
		# We will pad later, dynamically at batch creation, to the max sequence length in each batch
		a										=							False

	def preprocess_function(__lowerCamelCase    ):
		# Tokenize the texts
		return tokenizer(
		    examples["""premise"""]							,			examples["""hypothesis"""]							,			padding=__lowerCamelCase							,			max_length=data_args.max_seq_length							,			truncation=__lowerCamelCase							,			)

	if training_args.do_train:
		if data_args.max_train_samples is not None:
			a										=							min(len(__lowerCamelCase    )							,			data_args.max_train_samples    )
			a										=							train_dataset.select(range(__lowerCamelCase    )    )
		with training_args.main_process_first(desc="""train dataset map pre-processing"""    ):
			a										=							train_dataset.map(
			    __lowerCamelCase							,			batched=__lowerCamelCase							,			load_from_cache_file=not data_args.overwrite_cache							,			desc="""Running tokenizer on train dataset"""							,			)
		# Log a few random samples from the training set:
		for index in random.sample(range(len(__lowerCamelCase    )    )							,			3    ):
			logger.info(f'Sample {index} of the training set: {train_dataset[index]}.'    )

	if training_args.do_eval:
		if data_args.max_eval_samples is not None:
			a										=							min(len(__lowerCamelCase    )							,			data_args.max_eval_samples    )
			a										=							eval_dataset.select(range(__lowerCamelCase    )    )
		with training_args.main_process_first(desc="""validation dataset map pre-processing"""    ):
			a										=							eval_dataset.map(
			    __lowerCamelCase							,			batched=__lowerCamelCase							,			load_from_cache_file=not data_args.overwrite_cache							,			desc="""Running tokenizer on validation dataset"""							,			)

	if training_args.do_predict:
		if data_args.max_predict_samples is not None:
			a										=							min(len(__lowerCamelCase    )							,			data_args.max_predict_samples    )
			a										=							predict_dataset.select(range(__lowerCamelCase    )    )
		with training_args.main_process_first(desc="""prediction dataset map pre-processing"""    ):
			a										=							predict_dataset.map(
			    __lowerCamelCase							,			batched=__lowerCamelCase							,			load_from_cache_file=not data_args.overwrite_cache							,			desc="""Running tokenizer on prediction dataset"""							,			)

    # Get the metric function
	a										=							evaluate.load("""xnli"""    )

	# You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a
	# predictions and label_ids field) and has to return a dictionary string to float.
	def compute_metrics(__lowerCamelCase    ):
		a										=							p.predictions[0] if isinstance(p.predictions							,			__lowerCamelCase    ) else p.predictions
		a										=							np.argmax(__lowerCamelCase							,			axis=1    )
		return metric.compute(predictions=__lowerCamelCase							,			references=p.label_ids    )

	# Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding.
	if data_args.pad_to_max_length:
		a										=							default_data_collator
	elif training_args.fpaa:
		a										=							DataCollatorWithPadding(__lowerCamelCase							,			pad_to_multiple_of=8    )
	else:
		a										=							None

	# Initialize our Trainer
	a										=							Trainer(
	    model=__lowerCamelCase							,			args=__lowerCamelCase							,			train_dataset=train_dataset if training_args.do_train else None							,			eval_dataset=eval_dataset if training_args.do_eval else None							,			compute_metrics=__lowerCamelCase							,			tokenizer=__lowerCamelCase							,			data_collator=__lowerCamelCase							,			)

	# Training
	if training_args.do_train:
		a										=							None
		if training_args.resume_from_checkpoint is not None:
			a										=							training_args.resume_from_checkpoint
		elif last_checkpoint is not None:
			a										=							last_checkpoint
		a										=							trainer.train(resume_from_checkpoint=__lowerCamelCase    )
		a										=							train_result.metrics
		a										=							(
		    data_args.max_train_samples if data_args.max_train_samples is not None else len(__lowerCamelCase    )
		)
		a										=							min(__lowerCamelCase							,			len(__lowerCamelCase    )    )

		trainer.save_model()  # Saves the tokenizer too for easy upload

		trainer.log_metrics("""train"""							,			__lowerCamelCase    )
		trainer.save_metrics("""train"""							,			__lowerCamelCase    )
		trainer.save_state()

	# Evaluation
	if training_args.do_eval:
		logger.info("""*** Evaluate ***"""    )
		a										=							trainer.evaluate(eval_dataset=__lowerCamelCase    )

		a										=							data_args.max_eval_samples if data_args.max_eval_samples is not None else len(__lowerCamelCase    )
		a										=							min(__lowerCamelCase							,			len(__lowerCamelCase    )    )

		trainer.log_metrics("""eval"""							,			__lowerCamelCase    )
		trainer.save_metrics("""eval"""							,			__lowerCamelCase    )

	# Prediction
	if training_args.do_predict:
		logger.info("""*** Predict ***"""    )
		a				, a				, a										=							trainer.predict(__lowerCamelCase							,			metric_key_prefix="""predict"""    )

		a										=							(
		    data_args.max_predict_samples if data_args.max_predict_samples is not None else len(__lowerCamelCase    )
		)
		a										=							min(__lowerCamelCase							,			len(__lowerCamelCase    )    )

		trainer.log_metrics("""predict"""							,			__lowerCamelCase    )
		trainer.save_metrics("""predict"""							,			__lowerCamelCase    )

		a										=							np.argmax(__lowerCamelCase							,			axis=1    )
		a										=							os.path.join(training_args.output_dir							,			"""predictions.txt"""    )
		if trainer.is_world_process_zero():
			with open(__lowerCamelCase							,			"""w"""    ) as writer:
				writer.write("""index\tprediction\n"""    )
				for index, item in enumerate(__lowerCamelCase    ):
					a										=							label_list[item]
					writer.write(f'{index}\t{item}\n'    )


if __name__ == "__main__":
		main()







import math
from datetime import datetime, timedelta





def 		__A		(	__lowerCamelCase    )      ->       datetime:
	a										=							year % 19
	a										=							year % 4
	a										=							year % 7
	a										=							math.floor(year / 100    )
	a										=							math.floor((13 + 8 * leap_day_inhibits) / 25    )
	a										=							leap_day_inhibits / 4
	a										=							(
	    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 30
	a										=							(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	a										=							(19 * metonic_cycle + secular_moon_shift) % 30

	# PHM -> Paschal Full Moon
	a										=							(
	    2 * julian_leap_year
	    + 4 * non_leap_year
	    + 6 * days_to_add
	    + century_starting_point
	) % 7

	if days_to_add == 29 and days_from_phm_to_sunday == 6:
		return datetime(__lowerCamelCase							,			4							,			19    )
	elif days_to_add == 28 and days_from_phm_to_sunday == 6:
		return datetime(__lowerCamelCase							,			4							,			18    )
	else:
		return datetime(__lowerCamelCase							,			3							,			22    ) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
		for year in (1_994, 2_000, 2_010, 2_021, 2_023):
				__UpperCamelCase					:       Tuple    					=      "will be" if year > datetime.now().year else "was"
				print(F'Easter in {year} {tense} {gauss_easter(year)}')

