



'''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


UpperCamelCase__ :			List[str]												=				logging.getLogger(__name__)

require_version('''pytorch_lightning>=1.0.4''')

UpperCamelCase__ :			Tuple												=				{
    '''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
UpperCamelCase__ :			int												=				{
    '''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
}
UpperCamelCase__ :			Tuple												=				sorted(arg_to_scheduler.keys())
UpperCamelCase__ :			List[str]												=				'''{''' + ''', '''.join(arg_to_scheduler_choices) + '''}'''






class 		_UpperCamelCase						(							pl.LightningModule					):


			'''simple docstring'''

			def __init__(							self  :				Union[str, Any]							,  lowerCAmelCase__  :				argparse.Namespace							,  lowerCAmelCase__  :				Optional[Any]=None							,  lowerCAmelCase__  :				int="base"							,  lowerCAmelCase__  :				Optional[Any]=None							,  lowerCAmelCase__  :				List[Any]=None							,  lowerCAmelCase__  :				Union[str, Any]=None							,  **lowerCAmelCase__  :				Any							,  ):





					"""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(lowerCAmelCase__		)
					__SCREAMING_SNAKE_CASE :	Any					 =	0
					__SCREAMING_SNAKE_CASE :	List[str]					 =	Path(self.hparams.output_dir		)
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	self.hparams.cache_dir if self.hparams.cache_dir else None
					if config is None:
							__SCREAMING_SNAKE_CASE :	List[Any]					 =	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=lowerCAmelCase__							,  **lowerCAmelCase__							,  )
					else:
							__SCREAMING_SNAKE_CASE :	PretrainedConfig					 =	config

					__SCREAMING_SNAKE_CASE :	List[str]					 =	("""encoder_layerdrop""", """decoder_layerdrop""", """dropout""", """attention_dropout""")
					for p in extra_model_params:
							if getattr(self.hparams							,  lowerCAmelCase__							,  lowerCAmelCase__		):
									assert hasattr(self.config							,  lowerCAmelCase__		), F"model config doesn't have a `{p}` attribute"
									setattr(self.config							,  lowerCAmelCase__							,  getattr(self.hparams							,  lowerCAmelCase__		)		)

					if tokenizer is None:
							__SCREAMING_SNAKE_CASE :	Tuple					 =	AutoTokenizer.from_pretrained(
							    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path							,  cache_dir=lowerCAmelCase__							,  )
					else:
							__SCREAMING_SNAKE_CASE :	PreTrainedTokenizer					 =	tokenizer
					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	MODEL_MODES[mode]
					if model is None:
							__SCREAMING_SNAKE_CASE :	Optional[int]					 =	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=lowerCAmelCase__							,  )
					else:
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	model

			def UpperCamelCase__      (							self  :				int							,  *lowerCAmelCase__  :				int							,  **lowerCAmelCase__  :				List[Any]		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Dict					 =	self.model_type.from_pretrained(*lowerCAmelCase__							,  **lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				Tuple		):





					"""simple docstring"""






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

			def UpperCamelCase__      (							self  :				Any		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	int					 =	self.model
					__SCREAMING_SNAKE_CASE :	List[str]					 =	["""bias""", """LayerNorm.weight"""]
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	[
					    {
					        """params""": [
					            p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay		)
					        ],  # check this named paramters
					        """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:
							__SCREAMING_SNAKE_CASE :	List[str]					 =	Adafactor(
							    lowerCAmelCase__							,  lr=self.hparams.learning_rate							,  scale_parameter=lowerCAmelCase__							,  relative_step=lowerCAmelCase__		)

					else:
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	AdamW(
							    lowerCAmelCase__							,  lr=self.hparams.learning_rate							,  eps=self.hparams.adam_epsilon		)
					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	optimizer

					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	self.get_lr_scheduler()

					return [optimizer], [scheduler]

			def UpperCamelCase__      (							self  :				Tuple							,  lowerCAmelCase__  :				List[Any]							,  lowerCAmelCase__  :				Optional[int]		):





					"""simple docstring"""






					return self.validation_step(lowerCAmelCase__							,  lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				Dict							,  lowerCAmelCase__  :				Dict		):





					"""simple docstring"""






					return self.validation_end(lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				Union[str, Any]		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	str					 =	max(1							,  self.hparams.gpus		)  # TODO: consider num_tpu_cores
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
					return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs

			def UpperCamelCase__      (							self  :				List[str]							,  lowerCAmelCase__  :				Optional[int]		):





					"""simple docstring"""






					if stage == "test":
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	len(self.test_dataloader().dataset		)
					else:
							__SCREAMING_SNAKE_CASE :	str					 =	self.get_dataloader("""train"""							,  self.hparams.train_batch_size							,  shuffle=lowerCAmelCase__		)
							__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	len(self.train_dataloader().dataset		)

			def UpperCamelCase__      (							self  :				Optional[int]							,  lowerCAmelCase__  :				str							,  lowerCAmelCase__  :				int							,  lowerCAmelCase__  :				bool = False		):





					"""simple docstring"""






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

			def UpperCamelCase__      (							self  :				int		):





					"""simple docstring"""






					return self.train_loader

			def UpperCamelCase__      (							self  :				Dict		):





					"""simple docstring"""






					return self.get_dataloader("""dev"""							,  self.hparams.eval_batch_size							,  shuffle=lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				Optional[int]		):





					"""simple docstring"""






					return self.get_dataloader("""test"""							,  self.hparams.eval_batch_size							,  shuffle=lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				int							,  lowerCAmelCase__  :				Optional[Any]		):





					"""simple docstring"""






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

			@pl.utilities.rank_zero_only
			def UpperCamelCase__      (							self  :				Tuple							,  lowerCAmelCase__  :				Dict[str, Any]		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Any					 =	self.output_dir.joinpath("""best_tfmr"""		)
					__SCREAMING_SNAKE_CASE :	Dict					 =	self.step_count
					self.model.save_pretrained(lowerCAmelCase__		)
					self.tokenizer.save_pretrained(lowerCAmelCase__		)



			@staticmethod
			def UpperCamelCase__      (							lowerCAmelCase__  :				str							,  lowerCAmelCase__  :				Union[str, Any]		):





					"""simple docstring"""






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






class 		_UpperCamelCase						(							pl.Callback					):


			'''simple docstring'''

			def UpperCamelCase__      (							self  :				List[Any]							,  lowerCAmelCase__  :				int							,  lowerCAmelCase__  :				Optional[int]		):





					"""simple docstring"""






					if (
					    trainer.is_global_zero and trainer.global_rank == 0
					):  # we initialize the retriever only on master worker with RAY. In new pytorch-lightning accelorators are removed.
							pl_module.model.rag.retriever.init_retrieval()  # better to use hook functions.






class 		_UpperCamelCase						(							pl.Callback					):


			'''simple docstring'''

			def UpperCamelCase__      (							self  :				Optional[int]							,  lowerCAmelCase__  :				Tuple							,  lowerCAmelCase__  :				List[str]		):





					"""simple docstring"""






					for name, param in pl_module.model.rag.named_parameters():
							if param.grad is None:
									print(lowerCAmelCase__		)






class 		_UpperCamelCase						(							pl.Callback					):


			'''simple docstring'''

			def UpperCamelCase__      (							self  :				Optional[int]							,  lowerCAmelCase__  :				List[str]							,  lowerCAmelCase__  :				Dict		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	trainer.lr_schedulers[0]["""scheduler"""]
					__SCREAMING_SNAKE_CASE :	Dict					 =	{F"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr()		)}
					pl_module.logger.log_metrics(lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				List[Any]							,  lowerCAmelCase__  :				pl.Trainer							,  lowerCAmelCase__  :				pl.LightningModule		):





					"""simple docstring"""






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



			def UpperCamelCase__      (							self  :				str							,  lowerCAmelCase__  :				pl.Trainer							,  lowerCAmelCase__  :				pl.LightningModule		):





					"""simple docstring"""






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






def        lowerCAmelCase_     (			_lowerCamelCase:     List[Any] ,   _lowerCamelCase:     int      ):
		#  To allow all pl args uncomment the following line
		#  parser = pl.Trainer.add_argparse_args(parser)
		parser.add_argument(
		    """--output_dir""" ,   default=str(Path(_lowerCamelCase      ).parent / """test_run""" / """model_checkpoints"""      ) ,   type=_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=str(Path(_lowerCamelCase      ).parent / """test_run""" / """dummy-train-data"""      ) ,   type=_lowerCamelCase ,   help="""The input data dir. Should contain the training files for the CoNLL-2003 NER task.""" ,   )






def        lowerCAmelCase_     (			_lowerCamelCase:     BaseTransformer ,   _lowerCamelCase:     argparse.Namespace ,   _lowerCamelCase:     Optional[int]=None ,   _lowerCamelCase:     Union[str, Any]=True ,   _lowerCamelCase:     Union[str, Any]=[] ,   _lowerCamelCase:     List[Any]=None ,   _lowerCamelCase:     List[str]=None ,   **_lowerCamelCase:     Optional[Any] ,   ):
		pl.seed_everything(args.seed      )

		# init model
		__SCREAMING_SNAKE_CASE :	str					 =	Path(model.hparams.output_dir      )
		odir.mkdir(exist_ok=_lowerCamelCase      )

		# add custom checkpoints
		if checkpoint_callback is None:
				__SCREAMING_SNAKE_CASE :	List[str]					 =	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:
				__SCREAMING_SNAKE_CASE :	str					 =	LoggingCallback()

		__SCREAMING_SNAKE_CASE :	Dict					 =	{}

		if args.fpaa:
				__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	16

		if args.gpus > 1:
				__SCREAMING_SNAKE_CASE :	Any					 =	"""auto"""
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	"""ddp"""

		__SCREAMING_SNAKE_CASE :	List[str]					 =	args.accumulate_grad_batches
		__SCREAMING_SNAKE_CASE :	str					 =	None
		__SCREAMING_SNAKE_CASE :	List[str]					 =	"""auto"""

		__SCREAMING_SNAKE_CASE :	Dict					 =	pl.Trainer.from_argparse_args(
		    _lowerCamelCase ,   weights_summary=_lowerCamelCase ,   callbacks=[logging_callback] + extra_callbacks + [InitCallback()] + [checkpoint_callback] ,   logger=_lowerCamelCase ,   val_check_interval=1 ,   num_sanity_val_steps=2 ,   **_lowerCamelCase ,   )

		if args.do_train:
				trainer.fit(_lowerCamelCase      )

		else:
				print("""RAG modeling tests with new set functions successfuly executed!"""      )
		return trainer




'''simple docstring'''




import qiskit


def        lowerCAmelCase_     (			_lowerCamelCase:     int = 2      ):
		__SCREAMING_SNAKE_CASE :	Dict					 =	qubits

		# Using Aer's simulator
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	qiskit.Aer.get_backend("""aer_simulator"""      )

		# Creating a Quantum Circuit acting on the q register
		__SCREAMING_SNAKE_CASE :	str					 =	qiskit.QuantumCircuit(_lowerCamelCase ,   _lowerCamelCase      )

		# Adding a H gate on qubit 0 (now q0 in superposition)
		circuit.h(0      )

		for i in range(1 ,   _lowerCamelCase      ):
				# Adding CX (CNOT) gate
				circuit.cx(i - 1 ,   _lowerCamelCase      )

		# Mapping the quantum measurement to the classical bits
		circuit.measure(list(range(_lowerCamelCase      )      ) ,   list(range(_lowerCamelCase      )      )      )

		# Now measuring any one qubit would affect other qubits to collapse
		# their super position and have same state as the measured one.

		# Executing the circuit on the simulator
		__SCREAMING_SNAKE_CASE :	str					 =	qiskit.execute(_lowerCamelCase ,   _lowerCamelCase ,   shots=10_00      )

		return job.result().get_counts(_lowerCamelCase      )


if __name__ == "__main__":
						print(f"Total count for various states are: {quantum_entanglement(3)}")