





import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


UpperCAmelCase_      							=     logging.getLogger(__name__)





def 						lowerCamelCase__     (     UpperCamelCase__			:       int       ,    UpperCamelCase__			:       List[str]						)			-> Tuple:



					'''simple docstring'''




					return (preds == labels).mean()
@dataclass
class 			UpperCamelCase_		:
					lowerCAmelCase_							=	field(
					    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}					)
					lowerCAmelCase_							=	field(
					    default=_UpperCAmelCase							,  metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}					)
					lowerCAmelCase_							=	field(
					    default=_UpperCAmelCase							,  metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}					)
					lowerCAmelCase_							=	field(
					    default=_UpperCAmelCase							,  metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}							,  )





@dataclass
class 			UpperCamelCase_		:
					lowerCAmelCase_							=	field(metadata={'''help''': '''The name of the task to train on: ''' + ''', '''.join(processors.keys()					)}					)
					lowerCAmelCase_							=	field(metadata={'''help''': '''Should contain the data files for the task.'''}					)
					lowerCAmelCase_							=	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.'''
					        )
					    }							,  )
					lowerCAmelCase_							=	field(
					    default=_UpperCAmelCase							,  metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}					)





def 						lowerCamelCase__     (     )			-> Union[str, Any]:



					'''simple docstring'''




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

					if (
					    os.path.exists(training_args.output_dir						)
					    and os.listdir(training_args.output_dir						)
					    and training_args.do_train
					    and not training_args.overwrite_output_dir
					):
										raise ValueError(
										    F'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
										    ' --overwrite_output_dir to overcome.'						)

					# Setup logging
					logging.basicConfig(
					    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'       ,    datefmt='%m/%d/%Y %H:%M:%S'       ,    level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN       ,    )
					logger.warning(
					    'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'       ,    training_args.local_rank       ,    training_args.device       ,    training_args.n_gpu       ,    bool(training_args.local_rank != -1						)       ,    training_args.fpaa       ,    )
					# Set the verbosity to info of the Transformers logger (on main process only):
					if is_main_process(training_args.local_rank						):
										transformers.utils.logging.set_verbosity_info()
										transformers.utils.logging.enable_default_handler()
										transformers.utils.logging.enable_explicit_format()
					logger.info('Training/evaluation parameters %s'       ,    SCREAMING_SNAKE_CASE_						)

					# Set seed
					set_seed(training_args.seed						)

					try:
										_snake_case									=				processors[data_args.task_name]()
										_snake_case									=				processor.get_labels()
										_snake_case									=				len(SCREAMING_SNAKE_CASE_						)
					except KeyError:
										raise ValueError('Task not found: %s' % (data_args.task_name)						)

					# Load pretrained model and tokenizer
					#
					# Distributed training:
					# The .from_pretrained methods guarantee that only one local process can concurrently
					# download model & vocab.

					_snake_case									=				AutoConfig.from_pretrained(
					    model_args.config_name if model_args.config_name else model_args.model_name_or_path       ,    num_labels=SCREAMING_SNAKE_CASE_       ,    finetuning_task=data_args.task_name       ,    cache_dir=model_args.cache_dir       ,    )
					_snake_case									=				AutoTokenizer.from_pretrained(
					    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path       ,    cache_dir=model_args.cache_dir       ,    )
					_snake_case									=				AutoModelForMultipleChoice.from_pretrained(
					    model_args.model_name_or_path       ,    from_tf=bool('.ckpt' in model_args.model_name_or_path						)       ,    config=SCREAMING_SNAKE_CASE_       ,    cache_dir=model_args.cache_dir       ,    )

					# Get datasets
					_snake_case									=				(
					    MultipleChoiceDataset(
					        data_dir=data_args.data_dir       ,    tokenizer=SCREAMING_SNAKE_CASE_       ,    task=data_args.task_name       ,    max_seq_length=data_args.max_seq_length       ,    overwrite_cache=data_args.overwrite_cache       ,    mode=Split.train       ,    )
					    if training_args.do_train
					    else None
					)
					_snake_case									=				(
					    MultipleChoiceDataset(
					        data_dir=data_args.data_dir       ,    tokenizer=SCREAMING_SNAKE_CASE_       ,    task=data_args.task_name       ,    max_seq_length=data_args.max_seq_length       ,    overwrite_cache=data_args.overwrite_cache       ,    mode=Split.dev       ,    )
					    if training_args.do_eval
					    else None
					)

					def compute_metrics(UpperCamelCase__			:       EvalPrediction						) -> Dict:
										_snake_case									=				np.argmax(p.predictions       ,    axis=1						)
										return {"acc": simple_accuracy(SCREAMING_SNAKE_CASE_       ,    p.label_ids						)}

					# Data collator
					_snake_case									=				DataCollatorWithPadding(SCREAMING_SNAKE_CASE_       ,    pad_to_multiple_of=8						) if training_args.fpaa else None

					# Initialize our Trainer
					_snake_case									=				Trainer(
					    model=SCREAMING_SNAKE_CASE_       ,    args=SCREAMING_SNAKE_CASE_       ,    train_dataset=SCREAMING_SNAKE_CASE_       ,    eval_dataset=SCREAMING_SNAKE_CASE_       ,    compute_metrics=SCREAMING_SNAKE_CASE_       ,    data_collator=SCREAMING_SNAKE_CASE_       ,    )

					# Training
					if training_args.do_train:
										trainer.train(
										    model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path						) else None						)
										trainer.save_model()
										# For convenience, we also re-save the tokenizer to the same directory,
										# so that you can share your model easily on huggingface.co/models =)
										if trainer.is_world_master():
															tokenizer.save_pretrained(training_args.output_dir						)

    # Evaluation
					_snake_case									=				{}
					if training_args.do_eval:
										logger.info('*** Evaluate ***'						)

										_snake_case									=				trainer.evaluate()

										_snake_case									=				os.path.join(training_args.output_dir       ,    'eval_results.txt'						)
										if trainer.is_world_master():
															with open(SCREAMING_SNAKE_CASE_       ,    'w'						) as writer:
																				logger.info('***** Eval results *****'						)
																				for key, value in result.items():
																									logger.info('  %s = %s'       ,    SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_						)
																									writer.write('%s = %s\n' % (key, value)						)

																				results.update(SCREAMING_SNAKE_CASE_						)

					return results





def 						lowerCamelCase__     (     UpperCamelCase__			:       int						)			-> Dict:



					'''simple docstring'''




					main()


if __name__ == "__main__":
					main()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase_      							=     {"""configuration_swin""": ["""SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SwinConfig""", """SwinOnnxConfig"""]}


try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase_      							=     [
					    """SWIN_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """SwinForImageClassification""",
					    """SwinForMaskedImageModeling""",
					    """SwinModel""",
					    """SwinPreTrainedModel""",
					    """SwinBackbone""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase_      							=     [
					    """TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFSwinForImageClassification""",
					    """TFSwinForMaskedImageModeling""",
					    """TFSwinModel""",
					    """TFSwinPreTrainedModel""",
					]

if TYPE_CHECKING:
					from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_swin import (
										    SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
										    SwinBackbone,
										    SwinForImageClassification,
										    SwinForMaskedImageModeling,
										    SwinModel,
										    SwinPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_swin import (
										    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFSwinForImageClassification,
										    TFSwinForMaskedImageModeling,
										    TFSwinModel,
										    TFSwinPreTrainedModel,
										)

else:
					import sys

					UpperCAmelCase_      							=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



