code: 
  """simple docstring"""
  import inspect
  import unittest
  
  from transformers import ResNetConfig
  from transformers.testing_utils import require_torch, require_vision, slow, torch_device
  from transformers.utils import cached_property, is_torch_available, is_vision_available
  
  from ...test_backbone_common import BackboneTesterMixin
  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 torch import nn
  
  			from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
  			from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  if is_vision_available():
  			from PIL import Image
  
  			from transformers import AutoImageProcessor
  
  
  class    _lowerCAmelCase						:
  
  
  
  							def __init__(      self ,						a_ ,						a_=3 ,						a_=32 ,						a_=3 ,						a_=10 ,						a_=[10, 20, 30, 40] ,						a_=[1, 1, 2, 1] ,						a_=True ,						a_=True ,						a_="relu" ,						a_=3 ,						a_=None ,						a_=["stage2", "stage3", "stage4"] ,						a_=[2, 3, 4] ,						)							->							Union[str, Any]:
  								_UpperCAmelCase =						parent
  								_UpperCAmelCase =						batch_size
  								_UpperCAmelCase =						image_size
  								_UpperCAmelCase =						num_channels
  								_UpperCAmelCase =						embeddings_size
  								_UpperCAmelCase =						hidden_sizes
  								_UpperCAmelCase =						depths
  								_UpperCAmelCase =						is_training
  								_UpperCAmelCase =						use_labels
  								_UpperCAmelCase =						hidden_act
  								_UpperCAmelCase =						num_labels
  								_UpperCAmelCase =						scope
  								_UpperCAmelCase =						len(a_   )
  								_UpperCAmelCase =						out_features
  								_UpperCAmelCase =						out_indices
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								_UpperCAmelCase =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )
  
  								_UpperCAmelCase =						None
  								if self.use_labels:
  									_UpperCAmelCase =						ids_tensor([self.batch_size] ,						self.num_labels   )
  
  								_UpperCAmelCase =						self.get_config()
  
  								return config, pixel_values, labels
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								return ResNetConfig(
  								    num_channels=self.num_channels ,						embeddings_size=self.embeddings_size ,						hidden_sizes=self.hidden_sizes ,						depths=self.depths ,						hidden_act=self.hidden_act ,						num_labels=self.num_labels ,						out_features=self.out_features ,						out_indices=self.out_indices ,						)
  
  
  
  							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							Optional[Any]:
  								_UpperCAmelCase =						ResNetModel(config=a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_   )
  								# expected last hidden states: B, C, H // 32, W // 32
  								self.parent.assertEqual(
  								    result.last_hidden_state.shape ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,						)
  
  
  
  							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							Any:
  								_UpperCAmelCase =						self.num_labels
  								_UpperCAmelCase =						ResNetForImageClassification(a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_ ,						labels=a_   )
  								self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels)   )
  
  
  
  							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							Any:
  								_UpperCAmelCase =						ResNetBackbone(config=a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_   )
  
  								# verify feature maps
  								self.parent.assertEqual(len(result.feature_maps   ) ,						len(config.out_features   )   )
  								self.parent.assertListEqual(list(result.feature_maps[0].shape   ) ,						[self.batch_size, self.hidden_sizes[1], 4, 4]   )
  
  								# verify channels
  								self.parent.assertEqual(len(model.channels   ) ,						len(config.out_features   )   )
  								self.parent.assertListEqual(model.channels ,						config.hidden_sizes[1:]   )
  
  								# verify backbone works with out_features=None
  								_UpperCAmelCase =						None
  								_UpperCAmelCase =						ResNetBackbone(config=a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_   )
  
  								# verify feature maps
  								self.parent.assertEqual(len(result.feature_maps   ) ,						1   )
  								self.parent.assertListEqual(list(result.feature_maps[0].shape   ) ,						[self.batch_size, self.hidden_sizes[-1], 1, 1]   )
  
  								# verify channels
  								self.parent.assertEqual(len(model.channels   ) ,						1   )
  								self.parent.assertListEqual(model.channels ,						[config.hidden_sizes[-1]]   )
  
  
  
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase =						self.prepare_config_and_inputs()
  								_UpperCAmelCase ,      _UpperCAmelCase ,      _UpperCAmelCase =						config_and_inputs
  								_UpperCAmelCase =						{"pixel_values": pixel_values}
  								return config, inputs_dict
  
  
  
  
  
  @require_torch
  class    _lowerCAmelCase						(						lowerCamelCase    ,       lowerCamelCase    ,       unittest.TestCase						):
  							lowercase_     :     Any       =							(
  							    (
  							        ResNetModel,
  							        ResNetForImageClassification,
  							        ResNetBackbone,
  							    )
  							    if is_torch_available()
  							    else ()
  							)
  							lowercase_     :     List[str]       =							(
  							    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
  							    if is_torch_available()
  							    else {}
  							)
  
  							lowercase_     :     Any       =							True
  							lowercase_     :     str       =							False
  							lowercase_     :     List[Any]       =							False
  							lowercase_     :     Optional[Any]       =							False
  							lowercase_     :     Tuple       =							False
  
  
  
  							def       _a   (      self   )							->							int:
  								_UpperCAmelCase =						ResNetModelTester(self   )
  								_UpperCAmelCase =						ConfigTester(self ,						config_class=a_ ,						has_text_modality=a_   )
  
  
  
  							def       _a   (      self   )							->							str:
  								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       _a   (      self   )							->							Optional[int]:
  								return
  
  
  
  							@unittest.skip(reason="ResNet does not use inputs_embeds"   )
  							def       _a   (      self   )							->							Dict:
  								pass
  
  
  
  							@unittest.skip(reason="ResNet does not support input and output embeddings"   )
  							def       _a   (      self   )							->							List[Any]:
  								pass
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  									_UpperCAmelCase =						model_class(a_   )
  									_UpperCAmelCase =						inspect.signature(model.forward   )
  									# signature.parameters is an OrderedDict => so arg_names order is deterministic
  									_UpperCAmelCase =						[*signature.parameters.keys()]
  
  									_UpperCAmelCase =						["pixel_values"]
  									self.assertListEqual(arg_names[:1] ,						a_   )
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_model(*a_   )
  
  
  
  							def       _a   (      self   )							->							int:
  								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_backbone(*a_   )
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  									_UpperCAmelCase =						model_class(config=a_   )
  									for name, module in model.named_modules():
  										if isinstance(a_ ,						(nn.BatchNormad, nn.GroupNorm)   ):
  											self.assertTrue(
  											    torch.all(module.weight == 1   ) ,						msg=f"Parameter {name} of model {model_class} seems not properly initialized" ,						)
  											self.assertTrue(
  											    torch.all(module.bias == 0   ) ,						msg=f"Parameter {name} of model {model_class} seems not properly initialized" ,						)
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								def check_hidden_states_output(a_ ,						a_ ,						a_   ):
  									_UpperCAmelCase =						model_class(a_   )
  									model.to(a_   )
  									model.eval()
  
  									with torch.no_grad():
  										_UpperCAmelCase =						model(**self._prepare_for_class(a_ ,						a_   )   )
  
  									_UpperCAmelCase =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
  									_UpperCAmelCase =						self.model_tester.num_stages
  									self.assertEqual(len(a_   ) ,						expected_num_stages + 1   )
  
  									# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
  									self.assertListEqual(
  									    list(hidden_states[0].shape[-2:]   ) ,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4] ,						)
  
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  								_UpperCAmelCase =						["basic", "bottleneck"]
  								for model_class in self.all_model_classes:
  									for layer_type in layers_type:
  										_UpperCAmelCase =						layer_type
  										_UpperCAmelCase =						True
  										check_hidden_states_output(a_ ,						a_ ,						a_   )
  
  										# check that output_hidden_states also work using config
  										del inputs_dict["output_hidden_states"]
  										_UpperCAmelCase =						True
  
  										check_hidden_states_output(a_ ,						a_ ,						a_   )
  
  
  
  							@unittest.skip(reason="ResNet does not use feedforward chunking"   )
  							def       _a   (      self   )							->							List[str]:
  								pass
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_for_image_classification(*a_   )
  
  
  
  							@slow
  							def       _a   (      self   )							->							int:
  								for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  									_UpperCAmelCase =						ResNetModel.from_pretrained(a_   )
  									self.assertIsNotNone(a_   )
  
  
  
  
  
  def     __lowerCamelCase  (		):
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  	_UpperCAmelCase =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
  	return image
  
  
  @require_torch
  @require_vision
  class    _lowerCAmelCase						(						unittest.TestCase						):
  
  
  
  							@cached_property
  							def       _a   (      self   )							->							str:
  								return (
  								    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
  								    if is_vision_available()
  								    else None
  								)
  
  
  
  							@slow
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase =						ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(a_   )
  
  								_UpperCAmelCase =						self.default_image_processor
  								_UpperCAmelCase =						prepare_img()
  								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )
  
  								# forward pass
  								with torch.no_grad():
  									_UpperCAmelCase =						model(**a_   )
  
  								# verify the logits
  								_UpperCAmelCase =						torch.Size((1, 1000)   )
  								self.assertEqual(outputs.logits.shape ,						a_   )
  
  								_UpperCAmelCase =						torch.tensor([-11.1069, -9.7877, -8.3777]   ).to(a_   )
  
  								self.assertTrue(torch.allclose(outputs.logits[0, :3] ,						a_ ,						atol=1e-4   )   )
  
  
  
  
  
  @require_torch
  class    _lowerCAmelCase						(						lowerCamelCase    ,       unittest.TestCase						):
  							lowercase_     :     Union[str, Any]       =							(ResNetBackbone,) if is_torch_available() else ()
  							lowercase_     :     int       =							False
  							lowercase_     :     str       =							ResNetConfig
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						ResNetModelTester(self   )
  
  
  
  
  
style_context: 
  """simple docstring"""
  import heapq
  
  
  
  
  def     __lowerCamelCase  (		UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__      ):
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  	_UpperCAmelCase =						[(0, start)]  # cost from start node,end node
  	_UpperCAmelCase =						set()
  	while heap:
  		((_UpperCAmelCase) ,      (_UpperCAmelCase)) =						heapq.heappop(UpperCamelCase__      )
  		if u in visited:
  			continue
  		visited.add(UpperCamelCase__      )
  		if u == end:
  			return cost
  		for v, c in graph[u]:
  			if v in visited:
  				continue
  			_UpperCAmelCase =						cost + c
  			heapq.heappush(UpperCamelCase__				,     (next_item, v)      )
  	return -1
  
  
  __magic_name__		       =				{
      '''A''': [['''B''', 2], ['''C''', 5]],
      '''B''': [['''A''', 2], ['''D''', 3], ['''E''', 1], ['''F''', 1]],
      '''C''': [['''A''', 5], ['''F''', 3]],
      '''D''': [['''B''', 3]],
      '''E''': [['''B''', 4], ['''F''', 3]],
      '''F''': [['''C''', 3], ['''E''', 3]],
  }
  __magic_name__		       =				{
      '''B''': [['''C''', 1]],
      '''C''': [['''D''', 1]],
      '''D''': [['''F''', 1]],
      '''E''': [['''B''', 1], ['''F''', 3]],
      '''F''': [],
  }
  __magic_name__		       =				{
      '''B''': [['''C''', 1]],
      '''C''': [['''D''', 1]],
      '''D''': [['''F''', 1]],
      '''E''': [['''B''', 1], ['''G''', 2]],
      '''F''': [],
      '''G''': [['''F''', 1]],
  }
  
  __magic_name__		       =				dijkstra(G, '''E''', '''C''')
  print(short_distance)  # E -- 3 --> F -- 3 --> C == 6
  
  __magic_name__		       =				dijkstra(Ga, '''E''', '''F''')
  print(short_distance)  # E -- 3 --> F == 3
  
  __magic_name__		       =				dijkstra(Ga, '''E''', '''F''')
  print(short_distance)  # E -- 2 --> G -- 1 --> F == 3
  
  if __name__ == "__main__":
  			import doctest
  
  			doctest.testmod()
  
  
  
  
  