





'''simple docstring'''


import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow


if is_torch_available():
    import torch

    from transformers import XLMRobertaModel






@require_sentencepiece
@require_tokenizers
@require_torch
class     lowerCAmelCase__ (				unittest.TestCase    ):

       '''simple docstring'''

       @slow
       def 			__snake_case      ( self					:				List[Any]						):
              UpperCAmelCase  =						XLMRobertaModel.from_pretrained('''xlm-roberta-base'''						)
              UpperCAmelCase  =						torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]						)
              # The dog is cute and lives in the garden house

              UpperCAmelCase  =						torch.Size((1, 12, 768)						)  # batch_size, sequence_length, embedding_vector_dim
              UpperCAmelCase  =						torch.tensor(
                  [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]]						)
              #  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')
              #  xlmr.eval()
              #  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
              with torch.no_grad():
                     UpperCAmelCase  =						model(a__						)['''last_hidden_state'''].detach()
              self.assertEqual(output.shape       ,     a__						)
              # compare the actual values for a slice of last dim
              self.assertTrue(torch.allclose(output[:, :, -1]       ,     a__       ,     atol=1e-3						)						)



       @slow
       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase  =						XLMRobertaModel.from_pretrained('''xlm-roberta-large'''						)
              UpperCAmelCase  =						torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]						)
              # The dog is cute and lives in the garden house

              UpperCAmelCase  =						torch.Size((1, 12, 1024)						)  # batch_size, sequence_length, embedding_vector_dim
              UpperCAmelCase  =						torch.tensor(
                  [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]]						)
              #  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large')
              #  xlmr.eval()
              #  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
              with torch.no_grad():
                     UpperCAmelCase  =						model(a__						)['''last_hidden_state'''].detach()
              self.assertEqual(output.shape       ,     a__						)
              # compare the actual values for a slice of last dim
              self.assertTrue(torch.allclose(output[:, :, -1]       ,     a__       ,     atol=1e-3						)						)




import qiskit


def      UpperCamelCase   (       __lowerCamelCase	:					int							,   __lowerCamelCase	:					int       ):
       snake_case			:  int     							= qiskit.Aer.get_backend("aer_simulator"       )

       # Create a Quantum Circuit acting on the q register
       snake_case			:  Dict     							= qiskit.QuantumCircuit(__lowerCamelCase							,   __lowerCamelCase       )

       # 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
       snake_case			:  Dict     							= qiskit.execute(__lowerCamelCase							,   __lowerCamelCase							,   shots=1000       )

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


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





