
"""simple docstring"""




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

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


snake_case    =		logging.getLogger(__name__)




@dataclass
class      UpperCamelCase	:

				"""simple docstring"""



				UpperCAmelCase_				:      str						  =				field(
				    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}      )
				UpperCAmelCase_				:      Optional[str]						  =				field(
				    default=__magic_name__  ,      metadata={"help": "Pretrained config name or path if not the same as model_name"}      )
				UpperCAmelCase_				:      Optional[str]						  =				field(
				    default=__magic_name__  ,      metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}      )
				UpperCAmelCase_				:      bool						  =				field(default=__magic_name__  ,      metadata={"help": "Set this flag to use fast tokenization."}      )
				# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
				# or just modify its tokenizer_config.json.
				UpperCAmelCase_				:      Optional[str]						  =				field(
				    default=__magic_name__  ,      metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}  ,      )






def   UpperCamelCase_  (		):
					# 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.

					SCREAMING_SNAKE_CASE				=	HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)			)

					if len(sys.argv			) == 2 and sys.argv[1].endswith('.json'			):
										# If we pass only one argument to the script and it's the path to a json file,
										# let's parse it to get our arguments.
										SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]			)			)
					else:
										SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_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_			)

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

					SCREAMING_SNAKE_CASE				=	AutoConfig.from_pretrained(
					    model_args.config_name if model_args.config_name else model_args.model_name_or_path,     cache_dir=model_args.cache_dir,     )
					SCREAMING_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,     use_fast=SCREAMING_SNAKE_CASE_,     )
					SCREAMING_SNAKE_CASE				=	AutoModelForQuestionAnswering.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
					SCREAMING_SNAKE_CASE				=	hasattr(model.config,     'lang2id'			)
					SCREAMING_SNAKE_CASE				=	(
					    SquadDataset(
					        SCREAMING_SNAKE_CASE_,     tokenizer=SCREAMING_SNAKE_CASE_,     is_language_sensitive=SCREAMING_SNAKE_CASE_,     cache_dir=model_args.cache_dir			)
					    if training_args.do_train
					    else None
					)
					SCREAMING_SNAKE_CASE				=	(
					    SquadDataset(
					        SCREAMING_SNAKE_CASE_,     tokenizer=SCREAMING_SNAKE_CASE_,     mode='dev',     is_language_sensitive=SCREAMING_SNAKE_CASE_,     cache_dir=model_args.cache_dir,     )
					    if training_args.do_eval
					    else None
					)

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

					# Initialize our Trainer
					SCREAMING_SNAKE_CASE				=	Trainer(
					    model=SCREAMING_SNAKE_CASE_,     args=SCREAMING_SNAKE_CASE_,     train_dataset=SCREAMING_SNAKE_CASE_,     eval_dataset=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			)

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_			):
					# For xla_spawn (TPUs)
					main()


if __name__ == "__main__":
	main()






import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						int = 1       ,     __UpperCamelCase			:						int = 1      )  ->							qiskit.result.counts.Counts:
    if isinstance(__UpperCamelCase       ,     __UpperCamelCase      ) or isinstance(__UpperCamelCase       ,     __UpperCamelCase      ):
        raise TypeError('''inputs must be integers.'''      )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError('''inputs must be positive.'''      )
    if (math.floor(__UpperCamelCase      ) != bit_a) or (math.floor(__UpperCamelCase      ) != bit_a):
        raise ValueError('''inputs must be exact integers.'''      )
    if (bit_a > 1) or (bit_a > 1):
        raise ValueError('''inputs must be less or equal to 1.'''      )

    # build registers
    UpperCAmelCase_							 =     QuantumRegister(2       ,     '''qr'''      )
    UpperCAmelCase_							 =     ClassicalRegister(2       ,     '''cr'''      )

    UpperCAmelCase_							 =     QuantumCircuit(__UpperCamelCase       ,     __UpperCamelCase      )

    # entanglement the qubits
    quantum_circuit.h(1      )
    quantum_circuit.cx(1       ,     0      )

    # send the information
    UpperCAmelCase_							 =     str(__UpperCamelCase      ) + str(__UpperCamelCase      )

    if c_information == "11":
        quantum_circuit.x(1      )
        quantum_circuit.z(1      )
    elif c_information == "10":
        quantum_circuit.z(1      )
    elif c_information == "01":
        quantum_circuit.x(1      )
    else:
        quantum_circuit.i(1      )

    # unentangled the circuit
    quantum_circuit.cx(1       ,     0      )
    quantum_circuit.h(1      )

    # measure the circuit
    quantum_circuit.measure(__UpperCamelCase       ,     __UpperCamelCase      )

    UpperCAmelCase_							 =     Aer.get_backend('''aer_simulator'''      )
    UpperCAmelCase_							 =     execute(__UpperCamelCase       ,     __UpperCamelCase       ,     shots=1000      )

    return job.result().get_counts(__UpperCamelCase      )


if __name__ == "__main__":
 print(F"Counts for classical state send: {superdense_coding(1,1)}")





