"""simple docstring"""



import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


__magic_name__    				=					logging.getLogger(__name__)

require_version("pytorch_lightning>=1.0.4")

__magic_name__    				=					{
    '''base''': AutoModel,
    '''sequence-classification''': AutoModelForSequenceClassification,
    '''question-answering''': AutoModelForQuestionAnswering,
    '''pretraining''': AutoModelForPreTraining,
    '''token-classification''': AutoModelForTokenClassification,
    '''language-modeling''': AutoModelWithLMHead,
    '''summarization''': AutoModelForSeqaSeqLM,
    '''translation''': AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
__magic_name__    				=					{
    '''linear''': get_linear_schedule_with_warmup,
    '''cosine''': get_cosine_schedule_with_warmup,
    '''cosine_w_restarts''': get_cosine_with_hard_restarts_schedule_with_warmup,
    '''polynomial''': get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
__magic_name__    				=					sorted(arg_to_scheduler.keys())
__magic_name__    				=					'''{''' + ''', '''.join(arg_to_scheduler_choices) + '''}'''

class SCREAMING_SNAKE_CASE     (    pl.LightningModule	):







	"""simple docstring"""


	def __init__(   self		:      int					,   _snake_case		:      argparse.Namespace					,   _snake_case		:      str=None					,   _snake_case		:      Tuple="base"					,   _snake_case		:      Union[str, Any]=None					,   _snake_case		:      Union[str, Any]=None					,   _snake_case		:      Union[str, Any]=None					,   **_snake_case		:      Optional[int]					,   )				->			Dict:




				'''simple docstring'''






				super().__init__()
				# TODO: move to self.save_hyperparameters()
				# self.save_hyperparameters()
				# can also expand arguments into trainer signature for easier reading

				self.save_hyperparameters(_snake_case				)
				a__     				=		0
				a__     				=		Path(self.hparams.output_dir				)
				a__     				=		self.hparams.cache_dir if self.hparams.cache_dir else None
				if config is None:
							a__     				=		AutoConfig.from_pretrained(
							    self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path					,   **({'num_labels': num_labels} if num_labels is not None else {})					,   cache_dir=_snake_case					,   **_snake_case					,   )
				else:
							a__     				=		config

				a__     				=		("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
				for p in extra_model_params:
							if getattr(self.hparams					,   _snake_case					,   _snake_case				):
										assert hasattr(self.config					,   _snake_case				), F'''model config doesn\'t have a `{p}` attribute'''
										setattr(self.config					,   _snake_case					,   getattr(self.hparams					,   _snake_case				)				)

				if tokenizer is None:
							a__     				=		AutoTokenizer.from_pretrained(
							    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path					,   cache_dir=_snake_case					,   )
				else:
							a__     				=		tokenizer
				a__     				=		MODEL_MODES[mode]
				if model is None:
							a__     				=		self.model_type.from_pretrained(
							    self.hparams.model_name_or_path					,   from_tf=bool('.ckpt' in self.hparams.model_name_or_path				)					,   config=self.config					,   cache_dir=_snake_case					,   )
				else:
							a__     				=		model


	def        _lowerCAmelCase				(   self		:      int					,   *_snake_case		:      Tuple					,   **_snake_case		:      Any				)				->			List[str]:




				'''simple docstring'''






				a__     				=		self.model_type.from_pretrained(*_snake_case					,   **_snake_case				)


	def        _lowerCAmelCase				(   self		:      Tuple				)				->			Tuple:




				'''simple docstring'''






				a__     				=		arg_to_scheduler[self.hparams.lr_scheduler]
				a__     				=		get_schedule_func(
				    self.opt					,   num_warmup_steps=self.hparams.warmup_steps					,   num_training_steps=self.total_steps()				)
				a__     				=		{"scheduler": scheduler, "interval": "step", "frequency": 1}
				return scheduler


	def        _lowerCAmelCase				(   self		:      Any				)				->			Optional[Any]:




				'''simple docstring'''






				a__     				=		self.model
				a__     				=		["bias", "LayerNorm.weight"]
				a__     				=		[
				    {
				        "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay				)],
				        "weight_decay": self.hparams.weight_decay,
				    },
				    {
				        "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay				)],
				        "weight_decay": 0.0,
				    },
				]
				if self.hparams.adafactor:
							a__     				=		Adafactor(
							    _snake_case					,   lr=self.hparams.learning_rate					,   scale_parameter=_snake_case					,   relative_step=_snake_case				)

				else:
							a__     				=		AdamW(
							    _snake_case					,   lr=self.hparams.learning_rate					,   eps=self.hparams.adam_epsilon				)
				a__     				=		optimizer

				a__     				=		self.get_lr_scheduler()

				return [optimizer], [scheduler]


	def        _lowerCAmelCase				(   self		:      List[str]					,   _snake_case		:      Optional[int]					,   _snake_case		:      Union[str, Any]				)				->			str:




				'''simple docstring'''






				return self.validation_step(_snake_case					,   _snake_case				)


	def        _lowerCAmelCase				(   self		:      Optional[Any]					,   _snake_case		:      Tuple				)				->			List[str]:




				'''simple docstring'''






				return self.validation_end(_snake_case				)


	def        _lowerCAmelCase				(   self		:      int				)				->			str:




				'''simple docstring'''






				a__     				=		max(1					,   self.hparams.gpus				)  # TODO: consider num_tpu_cores
				a__     				=		self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
				return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs


	def        _lowerCAmelCase				(   self		:      Union[str, Any]					,   _snake_case		:      Optional[int]				)				->			List[str]:




				'''simple docstring'''






				if mode == "test":
							a__     				=		len(self.test_dataloader().dataset				)
				else:
							a__     				=		self.get_dataloader('train'					,   self.hparams.train_batch_size					,   shuffle=_snake_case				)
							a__     				=		len(self.train_dataloader().dataset				)


	def        _lowerCAmelCase				(   self		:      List[Any]					,   _snake_case		:      str					,   _snake_case		:      int					,   _snake_case		:      bool = False				)				->			Tuple:




				'''simple docstring'''






				raise NotImplementedError('You must implement this for your task'				)


	def        _lowerCAmelCase				(   self		:      int				)				->			Union[str, Any]:




				'''simple docstring'''






				return self.train_loader


	def        _lowerCAmelCase				(   self		:      int				)				->			int:




				'''simple docstring'''






				return self.get_dataloader('dev'					,   self.hparams.eval_batch_size					,   shuffle=_snake_case				)


	def        _lowerCAmelCase				(   self		:      Dict				)				->			Dict:




				'''simple docstring'''






				return self.get_dataloader('test'					,   self.hparams.eval_batch_size					,   shuffle=_snake_case				)


	def        _lowerCAmelCase				(   self		:      Dict					,   _snake_case		:      List[str]				)				->			Dict:




				'''simple docstring'''






				return os.path.join(
				    self.hparams.data_dir					,   'cached_{}_{}_{}'.format(
				        _snake_case					,   list(filter(_snake_case					,   self.hparams.model_name_or_path.split('/'				)				)				).pop()					,   str(self.hparams.max_seq_length				)					,   )					,   )


	@pl.utilities.rank_zero_only
	def        _lowerCAmelCase				(   self		:      int					,   _snake_case		:      Dict[str, Any]				)				->			List[str]:




				'''simple docstring'''






				a__     				=		self.output_dir.joinpath('best_tfmr'				)
				a__     				=		self.step_count
				self.model.save_pretrained(_snake_case				)
				self.tokenizer.save_pretrained(_snake_case				)



	@staticmethod
	def        _lowerCAmelCase				(   _snake_case		:      Optional[int]					,   _snake_case		:      List[str]				)				->			Tuple:




				'''simple docstring'''






				parser.add_argument(
				    '--model_name_or_path'					,   default=_snake_case					,   type=_snake_case					,   required=_snake_case					,   help='Path to pretrained model or model identifier from huggingface.co/models'					,   )
				parser.add_argument(
				    '--config_name'					,   default=''					,   type=_snake_case					,   help='Pretrained config name or path if not the same as model_name'				)
				parser.add_argument(
				    '--tokenizer_name'					,   default=_snake_case					,   type=_snake_case					,   help='Pretrained tokenizer name or path if not the same as model_name'					,   )
				parser.add_argument(
				    '--cache_dir'					,   default=''					,   type=_snake_case					,   help='Where do you want to store the pre-trained models downloaded from huggingface.co'					,   )
				parser.add_argument(
				    '--encoder_layerdrop'					,   type=_snake_case					,   help='Encoder layer dropout probability (Optional). Goes into model.config'					,   )
				parser.add_argument(
				    '--decoder_layerdrop'					,   type=_snake_case					,   help='Decoder layer dropout probability (Optional). Goes into model.config'					,   )
				parser.add_argument(
				    '--dropout'					,   type=_snake_case					,   help='Dropout probability (Optional). Goes into model.config'					,   )
				parser.add_argument(
				    '--attention_dropout'					,   type=_snake_case					,   help='Attention dropout probability (Optional). Goes into model.config'					,   )
				parser.add_argument('--learning_rate'					,   default=5E-5					,   type=_snake_case					,   help='The initial learning rate for Adam.'				)
				parser.add_argument(
				    '--lr_scheduler'					,   default='linear'					,   choices=_snake_case					,   metavar=_snake_case					,   type=_snake_case					,   help='Learning rate scheduler'					,   )
				parser.add_argument('--weight_decay'					,   default=0.0					,   type=_snake_case					,   help='Weight decay if we apply some.'				)
				parser.add_argument('--adam_epsilon'					,   default=1E-8					,   type=_snake_case					,   help='Epsilon for Adam optimizer.'				)
				parser.add_argument('--warmup_steps'					,   default=0					,   type=_snake_case					,   help='Linear warmup over warmup_steps.'				)
				parser.add_argument('--num_workers'					,   default=4					,   type=_snake_case					,   help='kwarg passed to DataLoader'				)
				parser.add_argument('--num_train_epochs'					,   dest='max_epochs'					,   default=3					,   type=_snake_case				)
				parser.add_argument('--train_batch_size'					,   default=32					,   type=_snake_case				)
				parser.add_argument('--eval_batch_size'					,   default=32					,   type=_snake_case				)
				parser.add_argument('--adafactor'					,   action='store_true'				)

class SCREAMING_SNAKE_CASE     (    pl.Callback	):







	"""simple docstring"""


	def        _lowerCAmelCase				(   self		:      Optional[int]					,   _snake_case		:      List[Any]					,   _snake_case		:      Any				)				->			Any:




				'''simple docstring'''






				a__     				=		trainer.lr_schedulers[0]["scheduler"]
				a__     				=		{F'''lr_group_{i}''': lr for i, lr in enumerate(lr_scheduler.get_lr()				)}
				pl_module.logger.log_metrics(_snake_case				)


	def        _lowerCAmelCase				(   self		:      Optional[Any]					,   _snake_case		:      pl.Trainer					,   _snake_case		:      pl.LightningModule				)				->			Tuple:




				'''simple docstring'''






				rank_zero_info('***** Validation results *****'				)
				a__     				=		trainer.callback_metrics
				# Log results
				for key in sorted(_snake_case				):
							if key not in ["log", "progress_bar"]:
										rank_zero_info('{} = {}\n'.format(_snake_case					,   str(metrics[key]				)				)				)



	def        _lowerCAmelCase				(   self		:      Dict					,   _snake_case		:      pl.Trainer					,   _snake_case		:      pl.LightningModule				)				->			Any:




				'''simple docstring'''






				rank_zero_info('***** Test results *****'				)
				a__     				=		trainer.callback_metrics
				# Log and save results to file
				a__     				=		os.path.join(pl_module.hparams.output_dir					,   'test_results.txt'				)
				with open(_snake_case					,   'w'				) as writer:
							for key in sorted(_snake_case				):
										if key not in ["log", "progress_bar"]:
													rank_zero_info('{} = {}\n'.format(_snake_case					,   str(metrics[key]				)				)				)
													writer.write('{} = {}\n'.format(_snake_case					,   str(metrics[key]				)				)				)





def   _lowerCamelCase ( UpperCAmelCase__,UpperCAmelCase__					)							->     None:


			'''simple docstring'''


			parser.add_argument(
			    '--output_dir',default=__lowerCAmelCase,type=__lowerCAmelCase,required=__lowerCAmelCase,help='The output directory where the model predictions and checkpoints will be written.',)
			parser.add_argument(
			    '--fp16',action='store_true',help='Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit',)

			parser.add_argument(
			    '--fp16_opt_level',type=__lowerCAmelCase,default='O2',help=(
			        'For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].'
			        'See details at https://nvidia.github.io/apex/amp.html'
			    ),)
			parser.add_argument('--n_tpu_cores',dest='tpu_cores',type=__lowerCAmelCase					)
			parser.add_argument('--max_grad_norm',dest='gradient_clip_val',default=1.0,type=__lowerCAmelCase,help='Max gradient norm'					)
			parser.add_argument('--do_train',action='store_true',help='Whether to run training.'					)
			parser.add_argument('--do_predict',action='store_true',help='Whether to run predictions on the test set.'					)
			parser.add_argument(
			    '--gradient_accumulation_steps',dest='accumulate_grad_batches',type=__lowerCAmelCase,default=1,help='Number of updates steps to accumulate before performing a backward/update pass.',)
			parser.add_argument('--seed',type=__lowerCAmelCase,default=42,help='random seed for initialization'					)
			parser.add_argument(
			    '--data_dir',default=__lowerCAmelCase,type=__lowerCAmelCase,required=__lowerCAmelCase,help='The input data dir. Should contain the training files for the CoNLL-2003 NER task.',)





def   _lowerCamelCase ( UpperCAmelCase__,UpperCAmelCase__,UpperCAmelCase__=None,UpperCAmelCase__=True,UpperCAmelCase__=[],UpperCAmelCase__=None,UpperCAmelCase__=None,**UpperCAmelCase__,)							->     Dict:


			'''simple docstring'''


			pl.seed_everything(args.seed					)

			# init model
			a__     				=		Path(model.hparams.output_dir					)
			odir.mkdir(exist_ok=__lowerCAmelCase					)

			# add custom checkpoints
			if checkpoint_callback is None:
						a__     				=		pl.callbacks.ModelCheckpoint(
						    filepath=args.output_dir,prefix='checkpoint',monitor='val_loss',mode='min',save_top_k=1					)
			if early_stopping_callback:
						extra_callbacks.append(__lowerCAmelCase					)
			if logging_callback is None:
						a__     				=		LoggingCallback()

			a__     				=		{}

			# TODO: remove with PyTorch 1.6 since pl uses native amp
			if args.fpaa:
						a__     				=		16
						a__     				=		args.fpaa_opt_level

			if args.gpus > 1:
						a__     				=		"ddp"

			a__     				=		args.accumulate_grad_batches
			a__     				=		extra_train_kwargs.get('accelerator',__lowerCAmelCase					)
			a__     				=		extra_train_kwargs.get('profiler',__lowerCAmelCase					)

			a__     				=		pl.Trainer.from_argparse_args(
			    __lowerCAmelCase,weights_summary=__lowerCAmelCase,callbacks=[logging_callback] + extra_callbacks,logger=__lowerCAmelCase,checkpoint_callback=__lowerCAmelCase,**__lowerCAmelCase,)

			if args.do_train:
						trainer.fit(__lowerCAmelCase					)

			return trainer



"""simple docstring"""



import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata





def   _lowerCamelCase ( UpperCAmelCase__					)							->     str:


   '''simple docstring'''


   a__     				=		min(re.search('^ +',UpperCAmelCase__					).end() if t.startswith(' '					) else 0 for t in string.splitlines()					)
   return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(UpperCAmelCase__					)]					)


__magic_name__    				=					"\\n---\nlanguage:\n- zh\n- en\ntask_ids:\n- sentiment-classification\n---\n# Begin of markdown\n\nSome cool dataset card\n"

__magic_name__    				=					"\\n---\n---\n# Begin of markdown\n\nSome cool dataset card\n"


__magic_name__    				=					"\\n# Begin of markdown\n\nSome cool dataset card\n"




class SCREAMING_SNAKE_CASE     (    unittest.TestCase	):







 """simple docstring"""


 def        _lowerCAmelCase				(   self		:      Tuple				)				->			Dict:




    '''simple docstring'''






    with tempfile.TemporaryDirectory() as tmp_dir:
       a__     				=		Path(_snake_case				) / 'README.md'
       with open(_snake_case					,   'w+'				) as readme_file:
          readme_file.write(_snake_case				)
       a__     				=		DatasetMetadata.from_readme(_snake_case				)
       self.assertDictEqual(_snake_case					,   {'language': ['zh', 'en'], 'task_ids': ['sentiment-classification']}				)

       with open(_snake_case					,   'w+'				) as readme_file:
          readme_file.write(_snake_case				)
       a__     				=		DatasetMetadata.from_readme(_snake_case				)
       self.assertDictEqual(_snake_case					,   {}				)

       with open(_snake_case					,   'w+'				) as readme_file:
          readme_file.write(_snake_case				)
       a__     				=		DatasetMetadata.from_readme(_snake_case				)
       self.assertEqual(_snake_case					,   {}				)



 def        _lowerCAmelCase				(   self		:      List[Any]				)				->			List[Any]:




    '''simple docstring'''






    a__     				=		_dedent(
        '\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            '				)
    assert DatasetMetadata.from_yaml_string(_snake_case				)

    a__     				=		_dedent(
        '\\n            annotations_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            task_ids:\n            - open-domain-qa\n            '				)
    with self.assertRaises(_snake_case				):
       DatasetMetadata.from_yaml_string(_snake_case				)

    a__     				=		_dedent(
        '\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - text-classification\n            task_ids:\n            - multi-class-classification\n            paperswithcode_id:\n            - squad\n            configs:\n            - en\n            train-eval-index:\n            - config: en\n              task: text-classification\n              task_id: multi_class_classification\n              splits:\n                train_split: train\n                eval_split: test\n              col_mapping:\n                text: text\n                label: target\n              metrics:\n                - type: accuracy\n                  name: Accuracy\n            extra_gated_prompt: |\n              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:\n              [RESEARCHER_FULLNAME] (the "Researcher") has requested permission to use the ImageNet database (the "Database") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:\n              1. Researcher shall use the Database only for non-commercial research and educational purposes.\n            extra_gated_fields:\n              Company: text\n              Country: text\n              I agree to use this model for non-commerical use ONLY: checkbox\n            '				)
    assert DatasetMetadata.from_yaml_string(_snake_case				)


