


'''simple docstring'''

import qiskit





def __snake_case      (   UpperCAmelCase_		:		int      ,       UpperCAmelCase_		:		int	):
 lowerCamelCase_  				=						qiskit.Aer.get_backend("aer_simulator"	)

 # Create a Quantum Circuit acting on the q register
 lowerCamelCase_  				=						qiskit.QuantumCircuit(UpperCAmelCase_      ,       UpperCAmelCase_	)

 # 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
 lowerCamelCase_  				=						qiskit.execute(UpperCAmelCase_      ,       UpperCAmelCase_      ,       shots=1000	)

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


if __name__ == "__main__":
     a_      			=				single_qubit_measure(2, 2)
     print(f'''Total count for various states are: {counts}''')







'''simple docstring'''

import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
     import tensorflow as tf

     from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments





@require_tf
class   snake_case					(					unittest.TestCase    ):





  """simple docstring"""




  def 						snake_case	(					self    ,						UpperCamelCase  ):







   """simple docstring"""
   for model_result in results.values():
    for batch_size, sequence_length in zip(model_result["bs"]    ,						model_result["ss"]  ):
     lowerCamelCase_  				=						model_result["result"][batch_size][sequence_length]
     self.assertIsNotNone(UpperCamelCase  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sgugger/tiny-distilbert-classification"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						only_pretrain_model=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_train_result  )
   self.check_results_dict_not_empty(results.memory_train_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_train_result  )
   self.check_results_dict_not_empty(results.memory_train_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"patrickvonplaten/t5-tiny-random"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						configs=[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  @unittest.skipIf(is_tf_available() and len(tf.config.list_physical_devices("GPU"  )  ) == 0    ,						"Cannot do xla on CPU."  )
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						use_xla=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   with tempfile.TemporaryDirectory() as tmp_dir:
    lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
        models=[MODEL_ID]    ,						inference=UpperCamelCase    ,						save_to_csv=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						inference_time_csv_file=os.path.join(UpperCamelCase    ,						"inf_time.csv"  )    ,						inference_memory_csv_file=os.path.join(UpperCamelCase    ,						"inf_mem.csv"  )    ,						env_info_csv_file=os.path.join(UpperCamelCase    ,						"env.csv"  )    ,						multi_process=UpperCamelCase    ,						)
    lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
    benchmark.run()
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"inf_time.csv"  )  ).exists()  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"inf_mem.csv"  )  ).exists()  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"env.csv"  )  ).exists()  )







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"

   def _check_summary_is_not_empty(UpperCamelCase  ):
    self.assertTrue(hasattr(UpperCamelCase    ,						"sequential"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"cumulative"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"current"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"total"  )  )

   with tempfile.TemporaryDirectory() as tmp_dir:
    lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
        models=[MODEL_ID]    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						log_filename=os.path.join(UpperCamelCase    ,						"log.txt"  )    ,						log_print=UpperCamelCase    ,						trace_memory_line_by_line=UpperCamelCase    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
    lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
    lowerCamelCase_  				=						benchmark.run()
    _check_summary_is_not_empty(result.inference_summary  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"log.txt"  )  ).exists()  )



