


"""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 							_lowercase					(			self:						List[Any]    ):







     '''simple docstring'''







     _lowerCamelCase   :				Any							=     XLMRobertaModel.from_pretrained("xlm-roberta-base"    )
     _lowerCamelCase   :				Tuple							=     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

     _lowerCamelCase   :				str							=     torch.Size((1, 12, 768)    )  # batch_size, sequence_length, embedding_vector_dim
     _lowerCamelCase   :				List[str]							=     torch.tensor(
         [[-0.01_01, 0.12_18, -0.08_03, 0.08_01, 0.13_27, 0.07_76, -0.12_15, 0.23_83, 0.33_38, 0.31_06, 0.03_00, 0.02_52]]    )
     #  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():
        _lowerCamelCase   :				List[str]							=     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 							_lowercase					(			self:						Union[str, Any]    ):







     '''simple docstring'''







     _lowerCamelCase   :				Any							=     XLMRobertaModel.from_pretrained("xlm-roberta-large"    )
     _lowerCamelCase   :				Optional[int]							=     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

     _lowerCamelCase   :				str							=     torch.Size((1, 12, 1_024)    )  # batch_size, sequence_length, embedding_vector_dim
     _lowerCamelCase   :				Optional[int]							=     torch.tensor(
         [[-0.06_99, -0.03_18, 0.07_05, -0.12_41, 0.09_99, -0.05_20, 0.10_04, -0.18_38, -0.47_04, 0.14_37, 0.08_21, 0.01_26]]    )
     #  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():
        _lowerCamelCase   :				Tuple							=     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    )    )


"""simple docstring"""




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu





@require_cpu
class  lowerCamelCase    (unittest.TestCase      ):

			def        SCREAMING_SNAKE_CASE					(       self					:    Dict							) ->     str:
						SCREAMING_SNAKE_CASE__										=   torch.nn.Linear(1_0     ,					1_0							)
						SCREAMING_SNAKE_CASE__										=   torch.optim.SGD(model.parameters()     ,					0.1							)
						SCREAMING_SNAKE_CASE__										=   Accelerator()
						SCREAMING_SNAKE_CASE__										=   accelerator.prepare(__UpperCAmelCase							)
						try:
									pickle.loads(pickle.dumps(__UpperCAmelCase							)							)
						except Exception as e:
									self.fail(F"""Accelerated optimizer pickling failed with {e}"""							)
						AcceleratorState._reset_state()


