

a_     =			8.314_4598

def        lowerCamelCase__       (    _a							,	_a):
	if temperature < 0:
		raise Exception("Temperature cannot be less than 0 K")
	if molar_mass <= 0:
		raise Exception("Molar mass cannot be less than or equal to 0 kg/mol")
	else:
		return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5


if __name__ == "__main__":
			import doctest

			# run doctest
			doctest.testmod()

			# example
			a_     =			300
			a_     =			28
			a_     =			rms_speed_of_molecule(temperature, molar_mass)
			print(F'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    LevitForImageClassification,
		    LevitForImageClassificationWithTeacher,
		    LevitModel,
		)
		from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import LevitImageProcessor




class    _UpperCamelCase      (						_UpperCAmelCase ):


			"""simple docstring"""






			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)
							self.parent.assertTrue(hasattr(lowerCAmelCase__      ,   '''hidden_sizes'''						)						)
							self.parent.assertTrue(hasattr(lowerCAmelCase__      ,   '''num_attention_heads'''						)						)




class    _UpperCamelCase      :


			"""simple docstring"""






			def __init__(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__=13      ,   lowerCAmelCase__=64      ,   lowerCAmelCase__=3      ,   lowerCAmelCase__=3      ,   lowerCAmelCase__=2      ,   lowerCAmelCase__=1      ,   lowerCAmelCase__=16      ,   lowerCAmelCase__=[1_28, 2_56, 3_84]      ,   lowerCAmelCase__=[4, 6, 8]      ,   lowerCAmelCase__=[2, 3, 4]      ,   lowerCAmelCase__=[16, 16, 16]      ,   lowerCAmelCase__=0      ,   lowerCAmelCase__=[2, 2, 2]      ,   lowerCAmelCase__=[2, 2, 2]      ,   lowerCAmelCase__=0.02      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=2      ,   )     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							parent
							__lowercase 			=							batch_size
							__lowercase 			=							image_size
							__lowercase 			=							num_channels
							__lowercase 			=							kernel_size
							__lowercase 			=							stride
							__lowercase 			=							padding
							__lowercase 			=							hidden_sizes
							__lowercase 			=							num_attention_heads
							__lowercase 			=							depths
							__lowercase 			=							key_dim
							__lowercase 			=							drop_path_rate
							__lowercase 			=							patch_size
							__lowercase 			=							attention_ratio
							__lowercase 			=							mlp_ratio
							__lowercase 			=							initializer_range
							__lowercase 			=							[
							    ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
							    ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
							]
							__lowercase 			=							is_training
							__lowercase 			=							use_labels
							__lowercase 			=							num_labels
							__lowercase 			=							initializer_range





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

							'''simple docstring'''


							__lowercase 			=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

							__lowercase 			=							None
							if self.use_labels:
											__lowercase 			=							ids_tensor([self.batch_size]      ,   self.num_labels						)

							__lowercase 			=							self.get_config()
							return config, pixel_values, labels





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							return LevitConfig(
							    image_size=self.image_size      ,   num_channels=self.num_channels      ,   kernel_size=self.kernel_size      ,   stride=self.stride      ,   padding=self.padding      ,   patch_size=self.patch_size      ,   hidden_sizes=self.hidden_sizes      ,   num_attention_heads=self.num_attention_heads      ,   depths=self.depths      ,   key_dim=self.key_dim      ,   drop_path_rate=self.drop_path_rate      ,   mlp_ratio=self.mlp_ratio      ,   attention_ratio=self.attention_ratio      ,   initializer_range=self.initializer_range      ,   down_ops=self.down_ops      ,   )





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							LevitModel(config=lowerCAmelCase__						)
							model.to(lowerCAmelCase__						)
							model.eval()
							__lowercase 			=							model(lowerCAmelCase__						)
							__lowercase 			=							(self.image_size, self.image_size)
							__lowercase			,     __lowercase 			=							image_size[0], image_size[1]
							for _ in range(4						):
											__lowercase 			=							floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
											__lowercase 			=							floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
							self.parent.assertEqual(
							    result.last_hidden_state.shape      ,   (self.batch_size, ceil(height / 4						) * ceil(width / 4						), self.hidden_sizes[-1])      ,   )





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					str:

							'''simple docstring'''


							__lowercase 			=							self.num_labels
							__lowercase 			=							LevitForImageClassification(lowerCAmelCase__						)
							model.to(lowerCAmelCase__						)
							model.eval()
							__lowercase 			=							model(lowerCAmelCase__      ,   labels=lowerCAmelCase__						)
							self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels)						)





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

							'''simple docstring'''


							__lowercase 			=							self.prepare_config_and_inputs()
							__lowercase			,     __lowercase			,     __lowercase 			=							config_and_inputs
							__lowercase 			=							{'''pixel_values''': pixel_values}
							return config, inputs_dict




@require_torch
class    _UpperCamelCase      (						_UpperCAmelCase						,_UpperCAmelCase						,unittest.TestCase ):


			"""simple docstring"""






			__a  : int			 =						(
			    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
			    if is_torch_available()
			    else ()
			)
			__a  : List[str]			 =						(
			    {
			        '''feature-extraction''': LevitModel,
			        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
			    }
			    if is_torch_available()
			    else {}
			)

			__a  : int			 =						False
			__a  : Dict			 =						False
			__a  : Optional[Any]			 =						False
			__a  : Optional[int]			 =						False
			__a  : Dict			 =						False





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

							'''simple docstring'''


							__lowercase 			=							LevitModelTester(self						)
							__lowercase 			=							ConfigTester(self      ,   config_class=lowerCAmelCase__      ,   has_text_modality=lowerCAmelCase__      ,   hidden_size=37						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

							'''simple docstring'''


							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							return





			@unittest.skip(reason='''Levit does not use inputs_embeds'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Union[str, Any]:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''Levit does not support input and output embeddings'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''Levit does not output attentions'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase 			=							model_class(lowerCAmelCase__						)
											__lowercase 			=							inspect.signature(model.forward						)
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											__lowercase 			=							[*signature.parameters.keys()]

											__lowercase 			=							['''pixel_values''']
											self.assertListEqual(arg_names[:1]      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						):
											__lowercase 			=							model_class(lowerCAmelCase__						)
											model.to(lowerCAmelCase__						)
											model.eval()

											with torch.no_grad():
															__lowercase 			=							model(**self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__						)						)

											__lowercase 			=							outputs.hidden_states

											__lowercase 			=							len(self.model_tester.depths						) + 1
											self.assertEqual(len(lowerCAmelCase__						)      ,   lowerCAmelCase__						)

											__lowercase 			=							(self.model_tester.image_size, self.model_tester.image_size)
											__lowercase			,     __lowercase 			=							image_size[0], image_size[1]
											for _ in range(4						):
															__lowercase 			=							floor(
															    (
															        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
															        / self.model_tester.stride
															    )
															    + 1						)
															__lowercase 			=							floor(
															    (
															        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
															        / self.model_tester.stride
															    )
															    + 1						)
											# verify the first hidden states (first block)
											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]						)      ,   [
											        height * width,
											        self.model_tester.hidden_sizes[0],
											    ]      ,   )

							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase 			=							True
											check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__lowercase 			=							True

											check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)





			@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__=False						)     ->					str:

							'''simple docstring'''


							__lowercase 			=							super()._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)

							if return_labels:
											if model_class.__name__ == "LevitForImageClassificationWithTeacher":
															del inputs_dict["labels"]

							return inputs_dict





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

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							if not self.model_tester.is_training:
											return

							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()
							__lowercase 			=							True

							for model_class in self.all_model_classes:
											# LevitForImageClassificationWithTeacher supports inference-only
											if (
											    model_class in get_values(lowerCAmelCase__						)
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
															continue
											__lowercase 			=							model_class(lowerCAmelCase__						)
											model.to(lowerCAmelCase__						)
											model.train()
											__lowercase 			=							self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)
											__lowercase 			=							model(**lowerCAmelCase__						).loss
											loss.backward()





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
											return

							__lowercase 			=							False
							__lowercase 			=							True

							for model_class in self.all_model_classes:
											if model_class in get_values(lowerCAmelCase__						) or not model_class.supports_gradient_checkpointing:
															continue
											# LevitForImageClassificationWithTeacher supports inference-only
											if model_class.__name__ == "LevitForImageClassificationWithTeacher":
															continue
											__lowercase 			=							model_class(lowerCAmelCase__						)
											model.gradient_checkpointing_enable()
											model.to(lowerCAmelCase__						)
											model.train()
											__lowercase 			=							self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)
											__lowercase 			=							model(**lowerCAmelCase__						).loss
											loss.backward()





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							__lowercase 			=							[
							    {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
							    {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
							    {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
							]

							for model_class in self.all_model_classes:
											if (
											    model_class
											    not in [
											        *get_values(lowerCAmelCase__						),
											    ]
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
															continue

											for problem_type in problem_types:
															with self.subTest(msg=F"Testing {model_class} with {problem_type['title']}"						):
																			__lowercase 			=							problem_type['''title''']
																			__lowercase 			=							problem_type['''num_labels''']

																			__lowercase 			=							model_class(lowerCAmelCase__						)
																			model.to(lowerCAmelCase__						)
																			model.train()

																			__lowercase 			=							self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)

																			if problem_type["num_labels"] > 1:
																							__lowercase 			=							inputs['''labels'''].unsqueeze(1						).repeat(1      ,   problem_type['''num_labels''']						)

																			__lowercase 			=							inputs['''labels'''].to(problem_type['''dtype''']						)

																			# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																			# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																			# they have the same size." which is a symptom something in wrong for the regression problem.
																			# See https://github.com/huggingface/transformers/issues/11780
																			with warnings.catch_warnings(record=lowerCAmelCase__						) as warning_list:
																							__lowercase 			=							model(**lowerCAmelCase__						).loss
																			for w in warning_list:
																							if "Using a target size that is different to the input size" in str(w.message						):
																											raise ValueError(
																											    F"Something is going wrong in the regression problem: intercepted {w.message}"						)

																			loss.backward()





			@slow
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 			=							LevitModel.from_pretrained(lowerCAmelCase__						)
											self.assertIsNotNone(lowerCAmelCase__						)





def 				UpperCAmelCase						(    ):







				"""simple docstring"""



				__lowercase 			=							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
				return image




@require_torch
@require_vision
class    _UpperCamelCase      (						unittest.TestCase ):


			"""simple docstring"""






			@cached_property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)





			@slow
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
							    lowerCAmelCase__						)

							__lowercase 			=							self.default_image_processor
							__lowercase 			=							prepare_img()
							__lowercase 			=							image_processor(images=lowerCAmelCase__      ,   return_tensors='''pt'''						).to(lowerCAmelCase__						)

							# forward pass
							with torch.no_grad():
											__lowercase 			=							model(**lowerCAmelCase__						)

							# verify the logits
							__lowercase 			=							torch.Size((1, 10_00)						)
							self.assertEqual(outputs.logits.shape      ,   lowerCAmelCase__						)

							__lowercase 			=							torch.tensor([1.0448, -0.3745, -1.8317]						).to(lowerCAmelCase__						)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,   lowerCAmelCase__      ,   atol=1E-4						)						)