






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

	@slow
	def      __UpperCamelCase							(      self   :						Any):
			UpperCamelCase__				:					Tuple					=					XLMRobertaModel.from_pretrained('xlm-roberta-base')
			UpperCamelCase__				:					Optional[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

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







'''simple docstring'''




from math import log

from scipy.constants import Boltzmann, physical_constants

lowerCAmelCase__          =						300  # TEMPERATURE (unit = K)







def       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      )							->     float:

		if donor_conc <= 0:
				raise ValueError('Donor concentration should be positive')
		elif acceptor_conc <= 0:
				raise ValueError('Acceptor concentration should be positive')
		elif intrinsic_conc <= 0:
				raise ValueError('Intrinsic concentration should be positive')
		elif donor_conc <= intrinsic_conc:
				raise ValueError(
				    'Donor concentration should be greater than intrinsic concentration')
		elif acceptor_conc <= intrinsic_conc:
				raise ValueError(
				    'Acceptor concentration should be greater than intrinsic concentration')
		else:
				return (
				    Boltzmann
				    * T
				    * log((donor_conc * acceptor_conc) / intrinsic_conc**2)
				    / physical_constants["electron volt"][0]
				)


if __name__ == "__main__":
		import doctest

		doctest.testmod()




