


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 _a (      self   )  ->	Optional[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.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():
              __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 _a (      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.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():
              __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   )   )









from __future__ import annotations

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int    ):
     if b == 0:
          return (1, 0)
     ((__UpperCamelCase)							,				(__UpperCamelCase))   							=extended_euclid(SCREAMING_SNAKE_CASE__      ,					a % b    )
     __UpperCamelCase   							=a // b
     return (y, x - k * y)

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int    ):
     ((__UpperCamelCase)							,				(__UpperCamelCase))   							=extended_euclid(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=na * na
     __UpperCamelCase   							=ra * x * na + ra * y * na
     return (n % m + m) % m

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int    ):
     ((__UpperCamelCase)							,				(__UpperCamelCase))   							=extended_euclid(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
     if b < 0:
          __UpperCamelCase   							=(b % n + n) % n
     return b

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : int    ):
     __UpperCamelCase							,				__UpperCamelCase   							=invert_modulo(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    ), invert_modulo(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=na * na
     __UpperCamelCase   							=ra * x * na + ra * y * na
     return (n % m + m) % m


if __name__ == "__main__":
   from doctest import testmod

   testmod(name='chinese_remainder_theorem', verbose=True)
   testmod(name='chinese_remainder_theorem2', verbose=True)
   testmod(name='invert_modulo', verbose=True)
   testmod(name='extended_euclid', verbose=True)





