





import argparse
import logging
import pickle
import random
import time

import numpy as np

from transformers import BertTokenizer, GPTaTokenizer, RobertaTokenizer


logging.basicConfig(
    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''', datefmt='''%m/%d/%Y %H:%M:%S''', level=logging.INFO
)
_lowerCamelCase :    List[str]  							= logging.getLogger(__name__)




def _a (  )	->    str:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      int     =						argparse.ArgumentParser(
							    description="Preprocess the data to avoid re-doing it several times by (tokenization + token_to_ids)."       )
							parser.add_argument("--file_path"			,				type=SCREAMING_SNAKE_CASE__			,				default="data/dump.txt"			,				help="The path to the data."       )
							parser.add_argument("--tokenizer_type"			,				type=SCREAMING_SNAKE_CASE__			,				default="bert"			,				choices=["bert", "roberta", "gpt2"]       )
							parser.add_argument("--tokenizer_name"			,				type=SCREAMING_SNAKE_CASE__			,				default="bert-base-uncased"			,				help="The tokenizer to use."       )
							parser.add_argument("--dump_file"			,				type=SCREAMING_SNAKE_CASE__			,				default="data/dump"			,				help="The dump file prefix."       )
							SCREAMING_SNAKE_CASE__       :      List[str]     =						parser.parse_args()

							logger.info(f'''Loading Tokenizer ({args.tokenizer_name})'''       )
							if args.tokenizer_type == "bert":
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						BertTokenizer.from_pretrained(args.tokenizer_name       )
														SCREAMING_SNAKE_CASE__       :      Any     =						tokenizer.special_tokens_map["cls_token"]  # `[CLS]`
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						tokenizer.special_tokens_map["sep_token"]  # `[SEP]`
							elif args.tokenizer_type == "roberta":
														SCREAMING_SNAKE_CASE__       :      int     =						RobertaTokenizer.from_pretrained(args.tokenizer_name       )
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						tokenizer.special_tokens_map["cls_token"]  # `<s>`
														SCREAMING_SNAKE_CASE__       :      Any     =						tokenizer.special_tokens_map["sep_token"]  # `</s>`
							elif args.tokenizer_type == "gpt2":
														SCREAMING_SNAKE_CASE__       :      str     =						GPTaTokenizer.from_pretrained(args.tokenizer_name       )
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						tokenizer.special_tokens_map["bos_token"]  # `<|endoftext|>`
														SCREAMING_SNAKE_CASE__       :      Tuple     =						tokenizer.special_tokens_map["eos_token"]  # `<|endoftext|>`

							logger.info(f'''Loading text from {args.file_path}'''       )
							with open(args.file_path			,				"r"			,				encoding="utf8"       ) as fp:
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						fp.readlines()

							logger.info("Start encoding"       )
							logger.info(f'''{len(SCREAMING_SNAKE_CASE__       )} examples to process.'''       )

							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						[]
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						0
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						1_00_00
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						time.time()
							for text in data:
														SCREAMING_SNAKE_CASE__       :      Any     =						f'''{bos} {text.strip()} {sep}'''
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						tokenizer.encode(SCREAMING_SNAKE_CASE__			,				add_special_tokens=SCREAMING_SNAKE_CASE__       )
														rslt.append(SCREAMING_SNAKE_CASE__       )

														iter += 1
														if iter % interval == 0:
																					SCREAMING_SNAKE_CASE__       :      str     =						time.time()
																					logger.info(f'''{iter} examples processed. - {(end-start):.2f}s/{interval}expl'''       )
																					SCREAMING_SNAKE_CASE__       :      Any     =						time.time()
							logger.info("Finished binarization"       )
							logger.info(f'''{len(SCREAMING_SNAKE_CASE__       )} examples processed.'''       )

							SCREAMING_SNAKE_CASE__       :      List[str]     =						f'''{args.dump_file}.{args.tokenizer_name}.pickle'''
							SCREAMING_SNAKE_CASE__       :      str     =						tokenizer.vocab_size
							if vocab_size < (1 << 16):
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						[np.uintaa(SCREAMING_SNAKE_CASE__       ) for d in rslt]
							else:
														SCREAMING_SNAKE_CASE__       :      Tuple     =						[np.intaa(SCREAMING_SNAKE_CASE__       ) for d in rslt]
							random.shuffle(rslt_       )
							logger.info(f'''Dump to {dp_file}'''       )
							with open(SCREAMING_SNAKE_CASE__			,				"wb"       ) as handle:
														pickle.dump(rslt_			,				SCREAMING_SNAKE_CASE__			,				protocol=pickle.HIGHEST_PROTOCOL       )


if __name__ == "__main__":
		main()













import qiskit




def _a (  SCREAMING_SNAKE_CASE__      :  int			,				SCREAMING_SNAKE_CASE__      :  int       )	->    qiskit.result.counts.Counts:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						qiskit.Aer.get_backend("aer_simulator"       )

							# Create a Quantum Circuit acting on the q register
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )

							# Apply X (NOT) Gate to Qubits 0 & 1
							circuit.x(0       )
							circuit.x(1       )

							# Map the quantum measurement to the classical bits
							circuit.measure([0, 1]			,				[0, 1]       )

							# Execute the circuit on the qasm simulator
							SCREAMING_SNAKE_CASE__       :      int     =						qiskit.execute(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				shots=10_00       )

							# Return the histogram data of the results of the experiment.
							return job.result().get_counts(SCREAMING_SNAKE_CASE__       )


if __name__ == "__main__":
		_lowerCamelCase :    List[str]  							= single_qubit_measure(2, 2)
		print(f"Total count for various states are: {counts}")






