



'''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     UpperCAmelCase_       (       unittest.TestCase	):
    """simple docstring"""







    @slow
    def lowerCamelCase       (    self					:     str						):
          snake_case__  :    str    						=      XLMRobertaModel.from_pretrained("""xlm-roberta-base"""						)
          snake_case__  :    Union[str, Any]    						=      torch.tensor([[0, 581, 10_269, 83, 99_942, 136, 60_742, 23, 70, 80_583, 18_276, 2]]						)
          # The dog is cute and lives in the garden house

          snake_case__  :    List[Any]    						=      torch.Size((1, 12, 768)						)  # batch_size, sequence_length, embedding_vector_dim
          snake_case__  :    Dict    						=      torch.tensor(
              [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]]						)
          #  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():
                snake_case__  :    str    						=      model(snake_case_						)["""last_hidden_state"""].detach()
          self.assertEqual(output.shape ,     snake_case_						)
          # compare the actual values for a slice of last dim
          self.assertTrue(torch.allclose(output[:, :, -1] ,     snake_case_ ,     atol=1E-3						)						)




    @slow
    def lowerCamelCase       (    self					:     Union[str, Any]						):
          snake_case__  :    List[str]    						=      XLMRobertaModel.from_pretrained("""xlm-roberta-large"""						)
          snake_case__  :    Union[str, Any]    						=      torch.tensor([[0, 581, 10_269, 83, 99_942, 136, 60_742, 23, 70, 80_583, 18_276, 2]]						)
          # The dog is cute and lives in the garden house

          snake_case__  :    Optional[int]    						=      torch.Size((1, 12, 1_024)						)  # batch_size, sequence_length, embedding_vector_dim
          snake_case__  :    int    						=      torch.tensor(
              [[-0.0699, -0.0318, 0.0705, -0.1241, 0.0999, -0.0520, 0.1004, -0.1838, -0.4704, 0.1437, 0.0821, 0.0126]]						)
          #  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():
                snake_case__  :    List[Any]    						=      model(snake_case_						)["""last_hidden_state"""].detach()
          self.assertEqual(output.shape ,     snake_case_						)
          # compare the actual values for a slice of last dim
          self.assertTrue(torch.allclose(output[:, :, -1] ,     snake_case_ ,     atol=1E-3						)						)





'''simple docstring'''





# Function to print upper half of diamond (pyramid)





def 						__snake_case(				_lowerCAmelCase		)		-> Any:
      for i in range(0     ,   _lowerCAmelCase		):
            for _ in range(0     ,   n - i - 1		):  # printing spaces
                  print(""" """     ,   end=""""""		)
            for _ in range(0     ,   i + 1		):  # printing stars
                  print("""* """     ,   end=""""""		)
            print()





def 						__snake_case(				_lowerCAmelCase		)		-> List[str]:
      for i in range(_lowerCAmelCase     ,   0     ,   -1		):
            for _ in range(_lowerCAmelCase     ,   0     ,   -1		):  # printing stars
                  print("""* """     ,   end=""""""		)
            print()
            for _ in range(n - i + 1     ,   0     ,   -1		):  # printing spaces
                  print(""" """     ,   end=""""""		)





def 						__snake_case(				_lowerCAmelCase		)		-> List[Any]:
      if n <= 0:
            print("""       ...       ....        nothing printing :("""		)
            return
      floyd(_lowerCAmelCase		)  # upper half
      reverse_floyd(_lowerCAmelCase		)  # lower half


if __name__ == "__main__":
       print(R"| /\ | |- |  |-  |--| |\  /| |-")
       print(R"|/  \| |- |_ |_  |__| | \/ | |_")
       __a          =		1
       while K:
              __a          =		int(input("enter the number and , and see the magic : "))
              print()
              pretty_print(user_number)
              __a          =		int(input("press 0 to exit... and 1 to continue..."))

       print("Good Bye...")
