


import logging
import os
from dataclasses import dataclass, field
from importlib import import_module
from typing import Dict, List, Optional, Tuple

import numpy as np
from seqeval.metrics import classification_report, fa_score, precision_score, recall_score
from utils_ner import Split, TFTokenClassificationDataset, TokenClassificationTask

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    TFAutoModelForTokenClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()


__UpperCamelCase      						=    logging.getLogger(__name__)







@dataclass
class     lowerCamelCase__		:






			"""simple docstring"""






			_UpperCamelCase						:   str					=						field(
			    metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
			_UpperCamelCase						:   Optional[str]					=						field(
			    default=UpperCAmelCase   ,		metadata={'help': 'Pretrained config name or path if not the same as model_name'} )
			_UpperCamelCase						:   Optional[str]					=						field(
			    default='NER'   ,		metadata={'help': 'Task type to fine tune in training (e.g. NER, POS, etc)'} )
			_UpperCamelCase						:   Optional[str]					=						field(
			    default=UpperCAmelCase   ,		metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} )
			_UpperCamelCase						:   bool					=						field(default=UpperCAmelCase   ,		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=UpperCAmelCase   ,		metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}   ,		)







@dataclass
class     lowerCamelCase__		:






			"""simple docstring"""






			_UpperCamelCase						:   str					=						field(
			    metadata={'help': 'The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task.'} )
			_UpperCamelCase						:   Optional[str]					=						field(
			    metadata={'help': 'Path to a file containing all labels. If not specified, CoNLL-2003 labels are used.'} )
			_UpperCamelCase						:   int					=						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						:   bool					=						field(
			    default=UpperCAmelCase   ,		metadata={'help': 'Overwrite the cached training and evaluation sets'} )



def     UpperCamelCase_(			)->						Union[str, Any]:
			UpperCamelCase__   =    HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)					)
			UpperCamelCase__   =    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."					)

			UpperCamelCase__   =    import_module("tasks"					)

			try:
						UpperCamelCase__   =    getattr(SCREAMING_SNAKE_CASE_			,       model_args.task_type					)
						UpperCamelCase__   =    token_classification_task_clazz()
			except AttributeError:
						raise ValueError(
						    F'''Task {model_args.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
						    F'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''					)

			# Setup logging
			logging.basicConfig(
			    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"			,       datefmt="%m/%d/%Y %H:%M:%S"			,       level=logging.INFO			,       )
			logger.info(
			    "n_replicas: %s, distributed training: %s, 16-bits training: %s"			,       training_args.n_replicas			,       bool(training_args.n_replicas > 1					)			,       training_args.fpaa			,       )
			logger.info("Training/evaluation parameters %s"			,       SCREAMING_SNAKE_CASE_					)

			# Prepare Token Classification task
			UpperCamelCase__   =    token_classification_task.get_labels(data_args.labels					)
			UpperCamelCase__   =    dict(enumerate(SCREAMING_SNAKE_CASE_					)					)
			UpperCamelCase__   =    len(SCREAMING_SNAKE_CASE_					)

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

			UpperCamelCase__   =    AutoConfig.from_pretrained(
			    model_args.config_name if model_args.config_name else model_args.model_name_or_path			,       num_labels=SCREAMING_SNAKE_CASE_			,       idalabel=SCREAMING_SNAKE_CASE_			,       labelaid={label: i for i, label in enumerate(SCREAMING_SNAKE_CASE_					)}			,       cache_dir=model_args.cache_dir			,       )
			UpperCamelCase__   =    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=model_args.use_fast			,       )

			with training_args.strategy.scope():
						UpperCamelCase__   =    TFAutoModelForTokenClassification.from_pretrained(
						    model_args.model_name_or_path			,       from_pt=bool(".bin" in model_args.model_name_or_path					)			,       config=SCREAMING_SNAKE_CASE_			,       cache_dir=model_args.cache_dir			,       )

			# Get datasets
			UpperCamelCase__   =    (
			    TFTokenClassificationDataset(
			        token_classification_task=SCREAMING_SNAKE_CASE_			,       data_dir=data_args.data_dir			,       tokenizer=SCREAMING_SNAKE_CASE_			,       labels=SCREAMING_SNAKE_CASE_			,       model_type=config.model_type			,       max_seq_length=data_args.max_seq_length			,       overwrite_cache=data_args.overwrite_cache			,       mode=Split.train			,       )
			    if training_args.do_train
			    else None
			)
			UpperCamelCase__   =    (
			    TFTokenClassificationDataset(
			        token_classification_task=SCREAMING_SNAKE_CASE_			,       data_dir=data_args.data_dir			,       tokenizer=SCREAMING_SNAKE_CASE_			,       labels=SCREAMING_SNAKE_CASE_			,       model_type=config.model_type			,       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 align_predictions(_A				:Tuple			,       _A				:Optional[Any]					) -> Tuple[List[int], List[int]]:
						UpperCamelCase__   =    np.argmax(SCREAMING_SNAKE_CASE_			,       axis=2					)
						UpperCamelCase__   =    preds.shape
						UpperCamelCase__   =    [[] for _ in range(SCREAMING_SNAKE_CASE_					)]
						UpperCamelCase__   =    [[] for _ in range(SCREAMING_SNAKE_CASE_					)]

						for i in range(SCREAMING_SNAKE_CASE_					):
									for j in range(SCREAMING_SNAKE_CASE_					):
												if label_ids[i, j] != -1_00:
															out_label_list[i].append(label_map[label_ids[i][j]]					)
															preds_list[i].append(label_map[preds[i][j]]					)

						return preds_list, out_label_list

			def compute_metrics(_A				:int					) -> Dict:
						UpperCamelCase__   =    align_predictions(p.predictions			,       p.label_ids					)

						return {
						    "precision": precision_score(SCREAMING_SNAKE_CASE_			,       SCREAMING_SNAKE_CASE_					),
						    "recall": recall_score(SCREAMING_SNAKE_CASE_			,       SCREAMING_SNAKE_CASE_					),
						    "f1": fa_score(SCREAMING_SNAKE_CASE_			,       SCREAMING_SNAKE_CASE_					),
						}

			# Initialize our Trainer
			UpperCamelCase__   =    TFTrainer(
			    model=SCREAMING_SNAKE_CASE_			,       args=SCREAMING_SNAKE_CASE_			,       train_dataset=train_dataset.get_dataset() if train_dataset else None			,       eval_dataset=eval_dataset.get_dataset() if eval_dataset else None			,       compute_metrics=SCREAMING_SNAKE_CASE_			,       )

			# Training
			if training_args.do_train:
						trainer.train()
						trainer.save_model()
						tokenizer.save_pretrained(training_args.output_dir					)

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

						UpperCamelCase__   =    trainer.evaluate()
						UpperCamelCase__   =    os.path.join(training_args.output_dir			,       "eval_results.txt"					)

						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_					)

						# Predict
			if training_args.do_predict:
						UpperCamelCase__   =    TFTokenClassificationDataset(
						    token_classification_task=SCREAMING_SNAKE_CASE_			,       data_dir=data_args.data_dir			,       tokenizer=SCREAMING_SNAKE_CASE_			,       labels=SCREAMING_SNAKE_CASE_			,       model_type=config.model_type			,       max_seq_length=data_args.max_seq_length			,       overwrite_cache=data_args.overwrite_cache			,       mode=Split.test			,       )

						UpperCamelCase__   =    trainer.predict(test_dataset.get_dataset()					)
						UpperCamelCase__   =    align_predictions(SCREAMING_SNAKE_CASE_			,       SCREAMING_SNAKE_CASE_					)
						UpperCamelCase__   =    classification_report(SCREAMING_SNAKE_CASE_			,       SCREAMING_SNAKE_CASE_					)

						logger.info("\n%s"			,       SCREAMING_SNAKE_CASE_					)

						UpperCamelCase__   =    os.path.join(training_args.output_dir			,       "test_results.txt"					)

						with open(SCREAMING_SNAKE_CASE_			,       "w"					) as writer:
									writer.write("%s\n" % report					)

						# Save predictions
						UpperCamelCase__   =    os.path.join(training_args.output_dir			,       "test_predictions.txt"					)

						with open(SCREAMING_SNAKE_CASE_			,       "w"					) as writer:
									with open(os.path.join(data_args.data_dir			,       "test.txt"					)			,       "r"					) as f:
												UpperCamelCase__   =    0

												for line in f:
															if line.startswith("-DOCSTART-"					) or line == "" or line == "\n":
																		writer.write(SCREAMING_SNAKE_CASE_					)

																		if not preds_list[example_id]:
																					example_id += 1
															elif preds_list[example_id]:
																		UpperCamelCase__   =    line.split()[0] + " " + preds_list[example_id].pop(0					) + "\n"

																		writer.write(SCREAMING_SNAKE_CASE_					)
															else:
																		logger.warning("Maximum sequence length exceeded: No prediction for '%s'."			,       line.split()[0]					)

			return results


if __name__ == "__main__":
						main()






import qiskit
from qiskit.providers import Backend
def     UpperCamelCase_(			_A				:int			,       _A				:int					)->						tuple[qiskit.QuantumCircuit, str, str]:
			UpperCamelCase__, UpperCamelCase__   =    bin(_A					)[2:], bin(_A					)[2:]  # Remove leading '0b'

			# Ensure that both strings are of the same length
			if len(_A					) > len(_A					):
						UpperCamelCase__   =    y.zfill(len(_A					)					)
			else:
						UpperCamelCase__   =    x.zfill(len(_A					)					)

			# We need (3 * number of bits in the larger number)+1 qBits
			# The second parameter is the number of classical registers, to measure the result
			UpperCamelCase__   =    qiskit.QuantumCircuit((len(_A					) * 3) + 1			,       len(_A					) + 1					)

			# We are essentially "not-ing" the bits that are 1
			# Reversed because it's easier to perform ops on more significant bits
			for i in range(len(_A					)					):
						if x[::-1][i] == "1":
									circuit.x(_A					)
			for j in range(len(_A					)					):
						if y[::-1][j] == "1":
									circuit.x(len(_A					) + j					)

			return circuit, x, y
def     UpperCamelCase_(			_A				:qiskit.QuantumCircuit			,       _A				:int			,       _A				:int			,       _A				:int			,       _A				:int			,       )->						Union[str, Any]:
			circuit.ccx(_A			,       _A			,       _A					)
			circuit.cx(_A			,       _A					)
			circuit.ccx(_A			,       _A			,       _A					)
			circuit.cx(_A			,       _A					)
			circuit.cx(_A			,       _A					)
def     UpperCamelCase_(			_A				:int			,       _A				:int			,       _A				:Backend = qiskit.Aer.get_backend("aer_simulator"					)			,       )->						int:

			if vala < 0 or vala < 0:
						raise ValueError("Both Integers must be positive!"					)

			# Store the Integers
			UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    store_two_classics(_A			,       _A					)
			for i in range(len(_A					)					):
						full_adder(_A			,       _A			,       len(_A					) + i			,       len(_A					) + len(_A					) + i			,       len(_A					) + len(_A					) + i + 1					)
						circuit.barrier()  # Optional, just for aesthetics

			# Measure the resultant qBits
			for i in range(len(_A					) + 1					):
						circuit.measure([(len(_A					) * 2) + i]			,       [i]					)

			UpperCamelCase__   =    qiskit.execute(_A			,       _A			,       shots=1					).result()

			# The result is in binary. Convert it back to int
			return int(list(res.get_counts()					)[0]			,       2					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()


