





"""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 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				@slow
				def        __lowercase	(  self	:str      ):
											__lowerCamelCase   :   Any       =XLMRobertaModel.from_pretrained('''xlm-roberta-base'''      )
											__lowerCamelCase   :   List[Any]       =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

											__lowerCamelCase   :   Dict       =torch.Size((1, 12, 768)      )  # batch_size, sequence_length, embedding_vector_dim
											__lowerCamelCase   :   int       =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():
																		__lowerCamelCase   :   Optional[int]       =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        __lowercase	(  self	:Any      ):
											__lowerCamelCase   :   List[str]       =XLMRobertaModel.from_pretrained('''xlm-roberta-large'''      )
											__lowerCamelCase   :   Dict       =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

											__lowerCamelCase   :   int       =torch.Size((1, 12, 1024)      )  # batch_size, sequence_length, embedding_vector_dim
											__lowerCamelCase   :   Optional[int]       =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():
																		__lowerCamelCase   :   List[Any]       =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      )      )











def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				float       , UpperCamelCase__:				float     ):
		if mass < 0:
				raise ValueError("""The mass of a body cannot be negative"""     )
		return 0.5 * mass * abs(UpperCamelCase__     ) * abs(UpperCamelCase__     )


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)