





'''simple docstring'''






import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
      import torch

      from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin




class  UpperCAmelCase     :




      def __init__(			self			: Dict			,			__snake_case			: Dict			,			__snake_case			: str=None			,			__snake_case			: Optional[Any]=None			,			__snake_case			: Union[str, Any]=None			,			__snake_case			: Dict="resnet50"			,			__snake_case			: Dict=3			,			__snake_case			: Union[str, Any]=32			,			__snake_case			: int=3			,			__snake_case			: List[Any]=True			,			__snake_case			: Optional[int]=True			,			)				->      Any:
            _lowerCAmelCase							     =							parent
            _lowerCAmelCase							     =							out_indices if out_indices is not None else [4]
            _lowerCAmelCase							     =							stage_names
            _lowerCAmelCase							     =							out_features
            _lowerCAmelCase							     =							backbone
            _lowerCAmelCase							     =							batch_size
            _lowerCAmelCase							     =							image_size
            _lowerCAmelCase							     =							num_channels
            _lowerCAmelCase							     =							use_pretrained_backbone
            _lowerCAmelCase							     =							is_training




      def 				lowercase__    (			self			: int  )				->      Dict:
            _lowerCAmelCase							     =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
            _lowerCAmelCase							     =							self.get_config()

            return config, pixel_values




      def 				lowercase__    (			self			: List[str]  )				->      str:
            return TimmBackboneConfig(
                image_size=self.image_size			,			num_channels=self.num_channels			,			out_features=self.out_features			,			out_indices=self.out_indices			,			stage_names=self.stage_names			,			use_pretrained_backbone=self.use_pretrained_backbone			,			backbone=self.backbone			,			)




      def 				lowercase__    (			self			: str			,			__snake_case			: Any			,			__snake_case			: List[str]  )				->      Any:
            _lowerCAmelCase							     =							TimmBackbone(config=_snake_case  )
            model.to(_snake_case  )
            model.eval()
            with torch.no_grad():
                  _lowerCAmelCase							     =							model(_snake_case  )
            self.parent.assertEqual(
                result.feature_map[-1].shape			,			(self.batch_size, model.channels[-1], 14, 14)			,			)




      def 				lowercase__    (			self			: Optional[Any]  )				->      Optional[Any]:
            _lowerCAmelCase							     =							self.prepare_config_and_inputs()
            _lowerCAmelCase							     =							config_and_inputs
            _lowerCAmelCase							     =							{'''pixel_values''': pixel_values}
            return config, inputs_dict




@require_torch
@require_timm
class  UpperCAmelCase     (			A_							,		A_							,		A_							,		unittest.TestCase   ):
      _lowercase:			Optional[Any]						     =   (TimmBackbone,) if is_torch_available() else ()
      _lowercase:			List[Any]						     =   {"feature-extraction": TimmBackbone} if is_torch_available() else {}
      _lowercase:			int						     =   False
      _lowercase:			List[str]						     =   False
      _lowercase:			Tuple						     =   False
      _lowercase:			int						     =   False




      def 				lowercase__    (			self			: Any  )				->      int:
            _lowerCAmelCase							     =							TimmBackboneModelTester(self  )
            _lowerCAmelCase							     =							ConfigTester(self			,			config_class=_snake_case			,			has_text_modality=_snake_case  )




      def 				lowercase__    (			self			: Union[str, Any]  )				->      List[Any]:
            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 				lowercase__    (			self			: Optional[Any]  )				->      Union[str, Any]:
            _lowerCAmelCase							     =							'''resnet18'''
            _lowerCAmelCase							     =							'''microsoft/resnet-18'''

            _lowerCAmelCase							     =							AutoBackbone.from_pretrained(_snake_case			,			use_timm_backbone=_snake_case  )
            _lowerCAmelCase							     =							AutoBackbone.from_pretrained(_snake_case  )

            self.assertEqual(len(timm_model.out_features  )			,			len(transformers_model.out_features  )  )
            self.assertEqual(len(timm_model.stage_names  )			,			len(transformers_model.stage_names  )  )
            self.assertEqual(timm_model.channels			,			transformers_model.channels  )
            # Out indices are set to the last layer by default. For timm models, we don't know
            # the number of layers in advance, so we set it to (-1,), whereas for transformers
            # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
            self.assertEqual(timm_model.out_indices			,			(-1,)  )
            self.assertEqual(transformers_model.out_indices			,			[len(timm_model.stage_names  ) - 1]  )

            _lowerCAmelCase							     =							AutoBackbone.from_pretrained(_snake_case			,			use_timm_backbone=_snake_case			,			out_indices=[1, 2, 3]  )
            _lowerCAmelCase							     =							AutoBackbone.from_pretrained(_snake_case			,			out_indices=[1, 2, 3]  )

            self.assertEqual(timm_model.out_indices			,			transformers_model.out_indices  )
            self.assertEqual(len(timm_model.out_features  )			,			len(transformers_model.out_features  )  )
            self.assertEqual(timm_model.channels			,			transformers_model.channels  )




      @unittest.skip("""TimmBackbone doesn\'t support feed forward chunking"""  )
      def 				lowercase__    (			self			: Tuple  )				->      Union[str, Any]:
            pass




      @unittest.skip("""TimmBackbone doesn\'t have num_hidden_layers attribute"""  )
      def 				lowercase__    (			self			: Union[str, Any]  )				->      Dict:
            pass




      @unittest.skip("""TimmBackbone initialization is managed on the timm side"""  )
      def 				lowercase__    (			self			: str  )				->      List[Any]:
            pass




      @unittest.skip("""TimmBackbone models doesn\'t have inputs_embeds"""  )
      def 				lowercase__    (			self			: int  )				->      Any:
            pass




      @unittest.skip("""TimmBackbone models doesn\'t have inputs_embeds"""  )
      def 				lowercase__    (			self			: str  )				->      List[Any]:
            pass




      @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""  )
      def 				lowercase__    (			self			: str  )				->      int:
            pass




      @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
      def 				lowercase__    (			self			: Tuple  )				->      Tuple:
            pass




      @unittest.skip("""model weights aren\'t tied in TimmBackbone."""  )
      def 				lowercase__    (			self			: Any  )				->      int:
            pass




      @unittest.skip("""model weights aren\'t tied in TimmBackbone."""  )
      def 				lowercase__    (			self			: Optional[Any]  )				->      Any:
            pass




      @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
      def 				lowercase__    (			self			: Optional[Any]  )				->      Tuple:
            pass




      @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
      def 				lowercase__    (			self			: Union[str, Any]  )				->      Any:
            pass




      @unittest.skip("""TimmBackbone doesn\'t have hidden size info in its configuration."""  )
      def 				lowercase__    (			self			: Optional[Any]  )				->      Union[str, Any]:
            pass




      @unittest.skip("""TimmBackbone doesn\'t support output_attentions."""  )
      def 				lowercase__    (			self			: Union[str, Any]  )				->      Union[str, Any]:
            pass




      @unittest.skip("""Safetensors is not supported by timm."""  )
      def 				lowercase__    (			self			: int  )				->      Optional[int]:
            pass




      @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
      def 				lowercase__    (			self			: List[Any]  )				->      int:
            pass




      def 				lowercase__    (			self			: List[str]  )				->      Optional[Any]:
            _lowerCAmelCase							     =							self.model_tester.prepare_config_and_inputs_for_common()

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

                  _lowerCAmelCase							     =							['''pixel_values''']
                  self.assertListEqual(arg_names[:1]			,			_snake_case  )




      def 				lowercase__    (			self			: Any  )				->      Optional[Any]:
            _lowerCAmelCase							     =							self.model_tester.prepare_config_and_inputs_for_common()
            _lowerCAmelCase							     =							True
            _lowerCAmelCase							     =							self.has_attentions

            # no need to test all models as different heads yield the same functionality
            _lowerCAmelCase							     =							self.all_model_classes[0]
            _lowerCAmelCase							     =							model_class(_snake_case  )
            model.to(_snake_case  )

            _lowerCAmelCase							     =							self._prepare_for_class(_snake_case			,			_snake_case  )
            _lowerCAmelCase							     =							model(**_snake_case  )
            _lowerCAmelCase							     =							outputs[0][-1]

            # Encoder-/Decoder-only models
            _lowerCAmelCase							     =							outputs.hidden_states[0]
            hidden_states.retain_grad()

            if self.has_attentions:
                  _lowerCAmelCase							     =							outputs.attentions[0]
                  attentions.retain_grad()

            output.flatten()[0].backward(retain_graph=_snake_case  )

            self.assertIsNotNone(hidden_states.grad  )

            if self.has_attentions:
                  self.assertIsNotNone(attentions.grad  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Optional[int]:
            _lowerCAmelCase							     =							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  _lowerCAmelCase							     =							model_class(_snake_case  )
                  model.to(_snake_case  )
                  model.eval()
                  _lowerCAmelCase							     =							model(**_snake_case  )

                  self.assertEqual(len(result.feature_maps  )			,			len(config.out_indices  )  )
                  self.assertEqual(len(model.channels  )			,			len(config.out_indices  )  )

                  # Check output of last stage is taken if out_features=None, out_indices=None
                  _lowerCAmelCase							     =							copy.deepcopy(_snake_case  )
                  _lowerCAmelCase							     =							None
                  _lowerCAmelCase							     =							model_class(_snake_case  )
                  model.to(_snake_case  )
                  model.eval()
                  _lowerCAmelCase							     =							model(**_snake_case  )

                  self.assertEqual(len(result.feature_maps  )			,			1  )
                  self.assertEqual(len(model.channels  )			,			1  )

                  # Check backbone can be initialized with fresh weights
                  _lowerCAmelCase							     =							copy.deepcopy(_snake_case  )
                  _lowerCAmelCase							     =							False
                  _lowerCAmelCase							     =							model_class(_snake_case  )
                  model.to(_snake_case  )
                  model.eval()
                  _lowerCAmelCase							     =							model(**_snake_case  )











"""simple docstring"""







def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      List[Any]:
		print('''\nThe shortest path matrix using Floyd Warshall algorithm\n'''	)
		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						if dist[i][j] != float('''inf'''	):
								print(int(dist[i][j]	)						,     end='''\t'''	)
						else:
								print('''INF'''						,     end='''\t'''	)
				print()



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      Optional[Any]:
		lowercase__   :    str				=			[[float('''inf'''	) for _ in range(__lowerCamelCase	)] for _ in range(__lowerCamelCase	)]

		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						lowercase__   :    List[str]				=			graph[i][j]

						# check vertex k against all other vertices (i, j)
		for k in range(__lowerCamelCase	):
				# looping through rows of graph array
				for i in range(__lowerCamelCase	):
						# looping through columns of graph array
						for j in range(__lowerCamelCase	):
								if (
								    dist[i][k] != float('''inf'''	)
								    and dist[k][j] != float('''inf'''	)
								    and dist[i][k] + dist[k][j] < dist[i][j]
								):
										lowercase__   :    str				=			dist[i][k] + dist[k][j]

		_print_dist(__lowerCamelCase						,     __lowerCamelCase	)
		return dist, v


if __name__ == "__main__":
							lowerCAmelCase_   						=   int(input('Enter number of vertices: '))
							lowerCAmelCase_   						=   int(input('Enter number of edges: '))

							lowerCAmelCase_   						=   [[float('inf') for i in range(v)] for j in range(v)]

							for i in range(v):
														lowerCAmelCase_   						=   0.0

														# src and dst are indices that must be within the array size graph[e][v]
														# failure to follow this will result in an error
							for i in range(e):
														print('\nEdge ', i + 1)
														lowerCAmelCase_   						=   int(input('Enter source:'))
														lowerCAmelCase_   						=   int(input('Enter destination:'))
														lowerCAmelCase_   						=   float(input('Enter weight:'))
														lowerCAmelCase_   						=   weight

							floyd_warshall(graph, v)

							# Example Input
							# Enter number of vertices: 3
							# Enter number of edges: 2

							# # generated graph from vertex and edge inputs
							# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
							# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

							# specify source, destination and weight for edge #1
							# Edge  1
							# Enter source:1
							# Enter destination:2
							# Enter weight:2

							# specify source, destination and weight for edge #2
							# Edge  2
							# Enter source:2
							# Enter destination:1
							# Enter weight:1

							# # Expected Output from the vertice, edge and src, dst, weight inputs!!
							# 0		INF	INF
							# INF	0	2
							# INF	1	0
