






'''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							):
							"""simple docstring"""




							@slow
							def 							_A	(		self			:List[str]				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_				:					List[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_				:					Any   =       torch.tensor(
										    [[-0.0_1_0_1, 0.1_2_1_8, -0.0_8_0_3, 0.0_8_0_1, 0.1_3_2_7, 0.0_7_7_6, -0.1_2_1_5, 0.2_3_8_3, 0.3_3_3_8, 0.3_1_0_6, 0.0_3_0_0, 0.0_2_5_2]]				)
										#  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(_lowercase				)["last_hidden_state"].detach()
										self.assertEqual(output.shape       ,							_lowercase				)
										# compare the actual values for a slice of last dim
										self.assertTrue(torch.allclose(output[:, :, -1]       ,							_lowercase       ,							atol=1E-3				)				)






							@slow
							def 							_A	(		self			:Any				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_				:					Tuple   =       XLMRobertaModel.from_pretrained("xlm-roberta-large"				)
										snake_case_				:					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

										snake_case_				:					Tuple   =       torch.Size((1, 12, 1_024)				)  # batch_size, sequence_length, embedding_vector_dim
										snake_case_				:					Union[str, Any]   =       torch.tensor(
										    [[-0.0_6_9_9, -0.0_3_1_8, 0.0_7_0_5, -0.1_2_4_1, 0.0_9_9_9, -0.0_5_2_0, 0.1_0_0_4, -0.1_8_3_8, -0.4_7_0_4, 0.1_4_3_7, 0.0_8_2_1, 0.0_1_2_6]]				)
										#  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_				:					Any   =       model(_lowercase				)["last_hidden_state"].detach()
										self.assertEqual(output.shape       ,							_lowercase				)
										# compare the actual values for a slice of last dim
										self.assertTrue(torch.allclose(output[:, :, -1]       ,							_lowercase       ,							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    A_	(unittest.TestCase							):
							"""simple docstring"""




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


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       torch.nn.Linear(10       ,							10				)
										snake_case_				:					Dict   =       torch.optim.SGD(model.parameters()       ,							0.1				)
										snake_case_				:					Tuple   =       Accelerator()
										snake_case_				:					Optional[Any]   =       accelerator.prepare(lowerCAmelCase__				)
										try:
													pickle.loads(pickle.dumps(lowerCAmelCase__				)				)
										except Exception as e:
													self.fail(F'''Accelerated optimizer pickling failed with {e}'''				)
										AcceleratorState._reset_state()




