


'''simple docstring'''
import logging
from pathlib import Path

import numpy as np
import pytorch_lightning as pl
import torch
from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
from pytorch_lightning.utilities import rank_zero_only
from utils_rag import save_json


def     a   (    __a     )						->			str:



					'''simple docstring'''






					UpperCamelCase__     :List[Any]							      =				filter(lambda __a     : p.requires_grad				,      model.parameters()     )
					UpperCamelCase__     :Tuple							      =				sum([np.prod(p.size()     ) for p in model_parameters]     )
					return params


__snake_case							   =  logging.getLogger(__name__)


def     a   (    __a				,      __a     )						->			str:



					'''simple docstring'''






					if metric == "rouge2":
										UpperCamelCase__     :List[str]							      =				'''{val_avg_rouge2:.4f}-{step_count}'''
					elif metric == "bleu":
										UpperCamelCase__     :Tuple							      =				'''{val_avg_bleu:.4f}-{step_count}'''
					elif metric == "em":
										UpperCamelCase__     :Tuple							      =				'''{val_avg_em:.4f}-{step_count}'''
					else:
										raise NotImplementedError(
										    f'''seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this'''
										    ''' function.'''     )

					UpperCamelCase__     :Any							      =				ModelCheckpoint(
					    dirpath=__a				,      filename=__a				,      monitor=f'''val_{metric}'''				,      mode='''max'''				,      save_top_k=3				,      every_n_epochs=1				,      )
					return checkpoint_callback


def     a   (    __a				,      __a     )						->			int:



					'''simple docstring'''






					return EarlyStopping(
					    monitor=f'''val_{metric}'''				,      mode='''min''' if '''loss''' in metric else '''max'''				,      patience=__a				,      verbose=__a				,      )







class      lowercase			(							pl.Callback  ):

		"""simple docstring"""

		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :str							      =				{F'''lr_group_{i}''': param['''lr'''] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups							)}
							pl_module.logger.log_metrics(UpperCamelCase_							)




		@rank_zero_only
		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_					,     UpperCamelCase_					,     UpperCamelCase_=True							):

							'''simple docstring'''


							logger.info(F'''***** {type_path} results at step {trainer.global_step:05d} *****'''							)
							UpperCamelCase__     :List[Any]							      =				trainer.callback_metrics
							trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ['''log''', '''progress_bar''', '''preds''']}							)
							# Log results
							UpperCamelCase__     :Optional[Any]							      =				Path(pl_module.hparams.output_dir							)
							if type_path == "test":
												UpperCamelCase__     :Optional[int]							      =				od / '''test_results.txt'''
												UpperCamelCase__     :int							      =				od / '''test_generations.txt'''
							else:
												# this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json
												# If people want this it will be easy enough to add back.
												UpperCamelCase__     :Tuple							      =				od / F'''{type_path}_results/{trainer.global_step:05d}.txt'''
												UpperCamelCase__     :List[str]							      =				od / F'''{type_path}_generations/{trainer.global_step:05d}.txt'''
												results_file.parent.mkdir(exist_ok=UpperCamelCase_							)
												generations_file.parent.mkdir(exist_ok=UpperCamelCase_							)
							with open(UpperCamelCase_					,     '''a+'''							) as writer:
												for key in sorted(UpperCamelCase_							):
																	if key in ["log", "progress_bar", "preds"]:
																						continue
																	UpperCamelCase__     :int							      =				metrics[key]
																	if isinstance(UpperCamelCase_					,     torch.Tensor							):
																						UpperCamelCase__     :int							      =				val.item()
																	UpperCamelCase__     :Any							      =				F'''{key}: {val:.6f}\n'''
																	writer.write(UpperCamelCase_							)

							if not save_generations:
												return

							if "preds" in metrics:
												UpperCamelCase__     :List[Any]							      =				'''\n'''.join(metrics['''preds''']							)
												generations_file.open('''w+'''							).write(UpperCamelCase_							)




		@rank_zero_only
		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							try:
												UpperCamelCase__     :Any							      =				pl_module.model.model.num_parameters()
							except AttributeError:
												UpperCamelCase__     :Optional[Any]							      =				pl_module.model.num_parameters()

							UpperCamelCase__     :Optional[int]							      =				count_trainable_parameters(UpperCamelCase_							)
							# mp stands for million parameters
							trainer.logger.log_metrics({'''n_params''': npars, '''mp''': npars / 1e6, '''grad_mp''': n_trainable_pars / 1e6}							)




		@rank_zero_only
		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							save_json(pl_module.metrics					,     pl_module.metrics_save_path							)
							return self._write_logs(UpperCamelCase_					,     UpperCamelCase_					,     '''test'''							)




		@rank_zero_only
		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							save_json(pl_module.metrics					,     pl_module.metrics_save_path							)
							# Uncommenting this will save val generations
							# return self._write_logs(trainer, pl_module, "valid")



'''simple docstring'''
import qiskit


def     a   (    __a				,      __a     )						->			qiskit.result.counts.Counts:



					'''simple docstring'''






					UpperCamelCase__     :int							      =				qiskit.Aer.get_backend('''aer_simulator'''     )

					# Create a Quantum Circuit acting on the q register
					UpperCamelCase__     :Any							      =				qiskit.QuantumCircuit(__a				,      __a     )

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

					# Execute the circuit on the simulator
					UpperCamelCase__     :Optional[int]							      =				qiskit.execute(__a				,      __a				,      shots=1000     )

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


if __name__ == "__main__":
		print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")