






from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase     ):

  '''simple docstring'''







  def  lowerCamelCase       (      self		:			List[str]							)						->	Dict:


         """simple docstring"""
         return [
             {"col_1": 3, "col_2": "a"},
             {"col_1": 2, "col_2": "b"},
             {"col_1": 1, "col_2": "c"},
             {"col_1": 0, "col_2": "d"},
         ]


  def  lowerCamelCase       (      self		:			List[str]							)						->	List[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    {"""col_1""": [3, 2, 1, 0], """col_2""": ["""a""", """b""", """c""", """d"""]}
         return Dataset.from_dict(lowerCamelCase							)


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


         """simple docstring"""
         _UpperCAmelCase							=    self._create_example_records()
         _UpperCAmelCase							=    Dataset.from_list(lowerCamelCase							)
         self.assertListEqual(dset.column_names       ,				["""col_1""", """col_2"""]							)
         for i, r in enumerate(lowerCamelCase							):
                self.assertDictEqual(lowerCamelCase       ,				example_records[i]							)


  def  lowerCamelCase       (      self		:			List[Any]							)						->	Union[str, Any]:


         """simple docstring"""
         _UpperCAmelCase							=    self._create_example_records()
         _UpperCAmelCase							=    Dataset.from_list(lowerCamelCase							)
         _UpperCAmelCase							=    Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]}							)
         self.assertEqual(dset.info       ,				dset_from_dict.info							)


  def  lowerCamelCase       (      self		:			str							)						->	Any:  # checks what happens with missing columns


         """simple docstring"""
         _UpperCAmelCase							=    [{"""col_1""": 1}, {"""col_2""": """x"""}]
         _UpperCAmelCase							=    Dataset.from_list(lowerCamelCase							)
         self.assertDictEqual(dset[0]       ,				{"""col_1""": 1}							)
         self.assertDictEqual(dset[1]       ,				{"""col_1""": None}							)  # NB: first record is used for columns


  def  lowerCamelCase       (      self		:			List[str]							)						->	Optional[int]:  # checks if the type can be inferred from the second record


         """simple docstring"""
         _UpperCAmelCase							=    [{"""col_1""": []}, {"""col_1""": [1, 2]}]
         _UpperCAmelCase							=    Dataset.from_list(lowerCamelCase							)
         self.assertEqual(dset.info.features["""col_1"""]       ,				Sequence(Value("""int64"""							)							)							)





  def  lowerCamelCase       (      self		:			Optional[int]							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase							=    Dataset.from_list([]							)
         self.assertEqual(len(lowerCamelCase							)       ,				0							)
         self.assertListEqual(dset.column_names       ,				[]							)







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

  '''simple docstring'''







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


         """simple docstring"""
         _UpperCAmelCase							=    XLMRobertaModel.from_pretrained("""xlm-roberta-base"""							)
         _UpperCAmelCase							=    torch.tensor([[0, 581, 1_0269, 83, 9_9942, 136, 6_0742, 23, 70, 8_0583, 1_8276, 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(lowerCamelCase							)["""last_hidden_state"""].detach()
         self.assertEqual(output.shape       ,				lowerCamelCase							)
         # compare the actual values for a slice of last dim
         self.assertTrue(torch.allclose(output[:, :, -1]       ,				lowerCamelCase       ,				atol=1E-3							)							)





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


         """simple docstring"""
         _UpperCAmelCase							=    XLMRobertaModel.from_pretrained("""xlm-roberta-large"""							)
         _UpperCAmelCase							=    torch.tensor([[0, 581, 1_0269, 83, 9_9942, 136, 6_0742, 23, 70, 8_0583, 1_8276, 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(lowerCamelCase							)["""last_hidden_state"""].detach()
         self.assertEqual(output.shape       ,				lowerCamelCase							)
         # compare the actual values for a slice of last dim
         self.assertTrue(torch.allclose(output[:, :, -1]       ,				lowerCamelCase       ,				atol=1E-3							)							)