



import qiskit





def 		a__      (		_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=10_00				)

   # 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}")










import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         NystromformerForMaskedLM,
         NystromformerForMultipleChoice,
         NystromformerForQuestionAnswering,
         NystromformerForSequenceClassification,
         NystromformerForTokenClassification,
         NystromformerModel,
     )
     from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST







class 						_snake_case    :




 def __init__(						self   ,    _lowerCamelCase   ,    _lowerCamelCase=13   ,    _lowerCamelCase=7   ,    _lowerCamelCase=True   ,    _lowerCamelCase=True   ,    _lowerCamelCase=True   ,    _lowerCamelCase=True   ,    _lowerCamelCase=99   ,    _lowerCamelCase=32   ,    _lowerCamelCase=5   ,    _lowerCamelCase=4   ,    _lowerCamelCase=37   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=512   ,    _lowerCamelCase=16   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.02   ,    _lowerCamelCase=3   ,    _lowerCamelCase=4   ,    _lowerCamelCase=None   ,    ):
       a		:int									=			parent
       a		:List[Any]									=			batch_size
       a		:Optional[int]									=			seq_length
       a		:List[Any]									=			is_training
       a		:Union[str, Any]									=			use_input_mask
       a		:Tuple									=			use_token_type_ids
       a		:Tuple									=			use_labels
       a		:int									=			vocab_size
       a		:int									=			hidden_size
       a		:Optional[Any]									=			num_hidden_layers
       a		:List[str]									=			num_attention_heads
       a		:str									=			intermediate_size
       a		:Union[str, Any]									=			hidden_act
       a		:Tuple									=			hidden_dropout_prob
       a		:Dict									=			attention_probs_dropout_prob
       a		:Tuple									=			max_position_embeddings
       a		:int									=			type_vocab_size
       a		:Union[str, Any]									=			type_sequence_label_size
       a		:List[Any]									=			initializer_range
       a		:Any									=			num_labels
       a		:int									=			num_choices
       a		:Optional[Any]									=			scope




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:str									=			ids_tensor([self.batch_size, self.seq_length]   ,    self.vocab_size       )

       a		:Dict									=			None
       if self.use_input_mask:
             a		:Optional[int]									=			random_attention_mask([self.batch_size, self.seq_length]       )

       a		:Dict									=			None
       if self.use_token_type_ids:
             a		:Dict									=			ids_tensor([self.batch_size, self.seq_length]   ,    self.type_vocab_size       )

       a		:Tuple									=			None
       a		:List[Any]									=			None
       a		:Any									=			None
       if self.use_labels:
             a		:Tuple									=			ids_tensor([self.batch_size]   ,    self.type_sequence_label_size       )
             a		:str									=			ids_tensor([self.batch_size, self.seq_length]   ,    self.num_labels       )
             a		:Any									=			ids_tensor([self.batch_size]   ,    self.num_choices       )

       a		:List[str]									=			self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       return NystromformerConfig(
           vocab_size=self.vocab_size   ,    hidden_size=self.hidden_size   ,    num_hidden_layers=self.num_hidden_layers   ,    num_attention_heads=self.num_attention_heads   ,    intermediate_size=self.intermediate_size   ,    hidden_act=self.hidden_act   ,    hidden_dropout_prob=self.hidden_dropout_prob   ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,    max_position_embeddings=self.max_position_embeddings   ,    type_vocab_size=self.type_vocab_size   ,    is_decoder=_lowerCamelCase   ,    initializer_range=self.initializer_range   ,    )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:List[Any]									=			NystromformerModel(config=_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:List[Any]									=			model(_lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase       )
       a		:Union[str, Any]									=			model(_lowerCamelCase   ,    token_type_ids=_lowerCamelCase       )
       a		:Any									=			model(_lowerCamelCase       )
       self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, self.seq_length, self.hidden_size)       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:Optional[int]									=			NystromformerForMaskedLM(config=_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:Tuple									=			model(_lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase   ,    labels=_lowerCamelCase       )
       self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.seq_length, self.vocab_size)       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:Dict									=			NystromformerForQuestionAnswering(config=_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:Optional[Any]									=			model(
           _lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase   ,    start_positions=_lowerCamelCase   ,    end_positions=_lowerCamelCase   ,    )
       self.parent.assertEqual(result.start_logits.shape   ,    (self.batch_size, self.seq_length)       )
       self.parent.assertEqual(result.end_logits.shape   ,    (self.batch_size, self.seq_length)       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:List[str]									=			self.num_labels
       a		:Any									=			NystromformerForSequenceClassification(_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:Optional[int]									=			model(_lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase   ,    labels=_lowerCamelCase       )
       self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.num_labels)       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:List[str]									=			self.num_labels
       a		:str									=			NystromformerForTokenClassification(config=_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:Union[str, Any]									=			model(_lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase   ,    labels=_lowerCamelCase       )
       self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.seq_length, self.num_labels)       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:Optional[Any]									=			self.num_choices
       a		:Optional[Any]									=			NystromformerForMultipleChoice(config=_lowerCamelCase       )
       model.to(_lowerCamelCase       )
       model.eval()
       a		:Optional[Any]									=			input_ids.unsqueeze(1       ).expand(-1   ,    self.num_choices   ,    -1       ).contiguous()
       a		:List[Any]									=			token_type_ids.unsqueeze(1       ).expand(-1   ,    self.num_choices   ,    -1       ).contiguous()
       a		:int									=			input_mask.unsqueeze(1       ).expand(-1   ,    self.num_choices   ,    -1       ).contiguous()
       a		:List[Any]									=			model(
           _lowerCamelCase   ,    attention_mask=_lowerCamelCase   ,    token_type_ids=_lowerCamelCase   ,    labels=_lowerCamelCase   ,    )
       self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.num_choices)       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:List[Any]									=			self.prepare_config_and_inputs()
       (
           (
           a
       )				,							(
           a
       )				,							(
           a
       )				,							(
           a
       )				,							(
           a
       )				,							(
           a
       )				,							(
           a
       )				,							
       )		:Any									=			config_and_inputs
       a		:Tuple									=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







@require_torch
class 						_snake_case    ( _snake_case		,       _snake_case		,       unittest.TestCase				):
 SCREAMING_SNAKE_CASE__ =			(
     (
         NystromformerModel,
         NystromformerForMaskedLM,
         NystromformerForMultipleChoice,
         NystromformerForQuestionAnswering,
         NystromformerForSequenceClassification,
         NystromformerForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 SCREAMING_SNAKE_CASE__ =			(
     {
         'feature-extraction': NystromformerModel,
         'fill-mask': NystromformerForMaskedLM,
         'question-answering': NystromformerForQuestionAnswering,
         'text-classification': NystromformerForSequenceClassification,
         'token-classification': NystromformerForTokenClassification,
         'zero-shot': NystromformerForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 SCREAMING_SNAKE_CASE__ =			False
 SCREAMING_SNAKE_CASE__ =			False




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Any									=			NystromformerModelTester(self       )
       a		:Tuple									=			ConfigTester(self   ,    config_class=_lowerCamelCase   ,    hidden_size=37       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       self.config_tester.run_common_tests()




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Tuple									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Dict									=			self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
             a		:Union[str, Any]									=			type
             self.model_tester.create_and_check_model(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Tuple									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:List[Any]									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Any									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Optional[int]									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Optional[Any]									=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase       )




 @slow
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a		:str									=			NystromformerModel.from_pretrained(_lowerCamelCase       )
             self.assertIsNotNone(_lowerCamelCase       )







@require_torch
class 						_snake_case    ( unittest.TestCase				):




 @slow
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Dict									=			NystromformerModel.from_pretrained('''uw-madison/nystromformer-512'''       )
       a		:Any									=			torch.tensor([[0, 1, 2, 3, 4, 5]]       )

       with torch.no_grad():
             a		:Optional[int]									=			model(_lowerCamelCase       )[0]

       a		:Optional[Any]									=			torch.Size((1, 6, 768)       )
       self.assertEqual(output.shape   ,    _lowerCamelCase       )

       a		:Dict									=			torch.tensor(
           [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]]       )

       self.assertTrue(torch.allclose(output[:, :3, :3]   ,    _lowerCamelCase   ,    atol=1e-4       )       )




 @slow
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Optional[int]									=			'''the [MASK] of Belgium is Brussels'''

       a		:Dict									=			AutoTokenizer.from_pretrained('''uw-madison/nystromformer-512'''       )
       a		:str									=			NystromformerForMaskedLM.from_pretrained('''uw-madison/nystromformer-512'''       )

       a		:Dict									=			tokenizer(_lowerCamelCase   ,    return_tensors='''pt'''       )

       with torch.no_grad():
             a		:Union[str, Any]									=			model(encoding.input_ids       ).logits

       a		:Optional[Any]									=			token_logits[:, 2, :].argmax(-1       )[0]

       self.assertEqual(tokenizer.decode(_lowerCamelCase       )   ,    '''capital'''       )





