
"""simple docstring"""


import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class   __a  (      unittest.TestCase	):






       def 	_SCREAMING_SNAKE_CASE       (  self :							Optional[Any]			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		["a", "b", "c"]

              # Defaults to last layer if both are None
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [2]			)

              # Out indices set to match out features
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(["a", "c"]       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [0, 2]			)

              # Out features set to match out indices
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      [0, 2]       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [0, 2]			)

              # Out features selected from negative indices
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      [-3, -1]       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [-3, -1]			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							int			)->  Union[str, Any]:







              """simple docstring"""
              # Stage names must be set
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 1)       ,      UpperCAmelCase_			)

              # Out features must be a list
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(("a", "b")       ,      (0, 1)       ,      ["a", "b"]			)

              # Out features must be a subset of stage names
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 1)       ,      ["a"]			)

              # Out indices must be a list or tuple
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(UpperCAmelCase_       ,      0       ,      ["a", "b"]			)

              # Out indices must be a subset of stage names
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(UpperCAmelCase_       ,      (0, 1)       ,      ["a"]			)

              # Out features and out indices must be the same length
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0,)       ,      ["a", "b", "c"]			)

              # Out features should match out indices
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 2)       ,      ["a", "b", "c"]			)

              # Out features and out indices should be in order
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["b", "a"]       ,      (0, 1)       ,      ["a", "b"]			)

              # Check passes with valid inputs
              verify_out_features_out_indices(["a", "b", "d"]       ,      (0, 1, -1)       ,      ["a", "b", "c", "d"]			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict			)->  List[Any]:







              """simple docstring"""
              UpperCamelCase					 =		BackboneMixin()

              UpperCamelCase					 =		["a", "b", "c"]
              UpperCamelCase					 =		["a", "c"]
              UpperCamelCase					 =		[0, 2]

              # Check that the output features and indices are set correctly
              self.assertEqual(backbone.out_features       ,      ["a", "c"]			)
              self.assertEqual(backbone.out_indices       ,      [0, 2]			)

              # Check out features and indices are updated correctly
              UpperCamelCase					 =		["a", "b"]
              self.assertEqual(backbone.out_features       ,      ["a", "b"]			)
              self.assertEqual(backbone.out_indices       ,      [0, 1]			)

              UpperCamelCase					 =		[-3, -1]
              self.assertEqual(backbone.out_features       ,      ["a", "c"]			)
              self.assertEqual(backbone.out_indices       ,      [-3, -1]			)







"""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   __a  (      unittest.TestCase	):






       @slow
       def 	_SCREAMING_SNAKE_CASE       (  self :							List[str]			)->  Optional[int]:







              """simple docstring"""
              UpperCamelCase					 =		XLMRobertaModel.from_pretrained("xlm-roberta-base"			)
              UpperCamelCase					 =		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

              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(UpperCAmelCase_			)["last_hidden_state"].detach()
              self.assertEqual(output.shape       ,      UpperCAmelCase_			)
              # compare the actual values for a slice of last dim
              self.assertTrue(torch.allclose(output[:, :, -1]       ,      UpperCAmelCase_       ,      atol=1e-3			)			)






       @slow
       def 	_SCREAMING_SNAKE_CASE       (  self :							Union[str, Any]			)->  Optional[int]:







              """simple docstring"""
              UpperCamelCase					 =		XLMRobertaModel.from_pretrained("xlm-roberta-large"			)
              UpperCamelCase					 =		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

              UpperCamelCase					 =		torch.Size((1, 12, 1_024)			)  # 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(UpperCAmelCase_			)["last_hidden_state"].detach()
              self.assertEqual(output.shape       ,      UpperCAmelCase_			)
              # compare the actual values for a slice of last dim
              self.assertTrue(torch.allclose(output[:, :, -1]       ,      UpperCAmelCase_       ,      atol=1e-3			)			)





