





"""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 			a       :



 def __init__(    self							,					_snake_case							,					_snake_case=3							,					_snake_case=32							,					_snake_case=3							,					_snake_case=10							,					_snake_case=[10, 20, 30, 40]							,					_snake_case=[1, 1, 2, 1]							,					_snake_case=True							,					_snake_case=True							,					_snake_case="relu"							,					_snake_case=3							,					_snake_case=None							,					_snake_case=["stage2", "stage3", "stage4"]							,					_snake_case=[2, 3, 4]							,					):







  """simple docstring"""






  lowerCAmelCase													=   parent
  lowerCAmelCase													=   batch_size
  lowerCAmelCase													=   image_size
  lowerCAmelCase													=   num_channels
  lowerCAmelCase													=   embeddings_size
  lowerCAmelCase													=   hidden_sizes
  lowerCAmelCase													=   depths
  lowerCAmelCase													=   is_training
  lowerCAmelCase													=   use_labels
  lowerCAmelCase													=   hidden_act
  lowerCAmelCase													=   num_labels
  lowerCAmelCase													=   scope
  lowerCAmelCase													=   len(a_    )
  lowerCAmelCase													=   out_features
  lowerCAmelCase													=   out_indices



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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

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

  lowerCAmelCase													=   self.get_config()

  return config, pixel_values, labels



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  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       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   ResNetModel(config=a_    )
  model.to(a_    )
  model.eval()
  lowerCAmelCase													=   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       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   self.num_labels
  lowerCAmelCase													=   ResNetForImageClassification(a_    )
  model.to(a_    )
  model.eval()
  lowerCAmelCase													=   model(a_							,					labels=a_    )
  self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels)    )



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   ResNetBackbone(config=a_    )
  model.to(a_    )
  model.eval()
  lowerCAmelCase													=   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
  lowerCAmelCase													=   None
  lowerCAmelCase													=   ResNetBackbone(config=a_    )
  model.to(a_    )
  model.eval()
  lowerCAmelCase													=   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       UpperCamelCase__     (    self    ):







  """simple docstring"""






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







@require_torch
class 			a       (      a__      ,   a__      ,   unittest.TestCase     ):
 snake_case__								=					(
     (
         ResNetModel,
         ResNetForImageClassification,
         ResNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 snake_case__								=					(
     {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
     if is_torch_available()
     else {}
 )

 snake_case__								=					True
 snake_case__								=					False
 snake_case__								=					False
 snake_case__								=					False
 snake_case__								=					False



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   ResNetModelTester(self    )
  lowerCAmelCase													=   ConfigTester(self							,					config_class=a_							,					has_text_modality=a_    )



 def       UpperCamelCase__     (    self    ):







  """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       UpperCamelCase__     (    self    ):







  """simple docstring"""






  return



 @unittest.skip(reason='ResNet does not use inputs_embeds'    )
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  pass



 @unittest.skip(reason='ResNet does not support input and output embeddings'    )
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  pass



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase							,lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   lowerCAmelCase													=   model_class(a_    )
   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]							,					a_    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*a_    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_backbone(*a_    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase							,lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   lowerCAmelCase													=   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       UpperCamelCase__     (    self    ):







  """simple docstring"""






  def check_hidden_states_output(_snake_case							,					_snake_case							,					_snake_case    ):
   lowerCAmelCase													=   model_class(a_    )
   model.to(a_    )
   model.eval()

   with torch.no_grad():
    lowerCAmelCase													=   model(**self._prepare_for_class(a_							,					a_    )    )

   lowerCAmelCase													=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

   lowerCAmelCase													=   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]							,					)

  lowerCAmelCase							,lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs_for_common()
  lowerCAmelCase													=   ['basic', 'bottleneck']
  for model_class in self.all_model_classes:
   for layer_type in layers_type:
    lowerCAmelCase													=   layer_type
    lowerCAmelCase													=   True
    check_hidden_states_output(a_							,					a_							,					a_    )

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

    check_hidden_states_output(a_							,					a_							,					a_    )



 @unittest.skip(reason='ResNet does not use feedforward chunking'    )
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  pass



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*a_    )



 @slow
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   lowerCAmelCase													=   ResNetModel.from_pretrained(a_    )
   self.assertIsNotNone(a_    )


def 		_SCREAMING_SNAKE_CASE ():
 lowerCAmelCase													=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
 return image







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



 @cached_property
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  return (
      AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )
      if is_vision_available()
      else None
  )



 @slow
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(a_    )

  lowerCAmelCase													=   self.default_image_processor
  lowerCAmelCase													=   prepare_img()
  lowerCAmelCase													=   image_processor(images=a_							,					return_tensors='pt'    ).to(a_    )

  # forward pass
  with torch.no_grad():
   lowerCAmelCase													=   model(**a_    )

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

  lowerCAmelCase													=   torch.tensor([-11.1_069, -9.7_877, -8.3_777]    ).to(a_    )

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







@require_torch
class 			a       (      a__      ,   unittest.TestCase     ):
 snake_case__								=					(ResNetBackbone,) if is_torch_available() else ()
 snake_case__								=					False
 snake_case__								=					ResNetConfig



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   ResNetModelTester(self    )












"""simple docstring"""
import math
import sys







class 			a       :



 def __init__(    self    ):







  """simple docstring"""






  lowerCAmelCase													=   0
  lowerCAmelCase													=   []
  lowerCAmelCase													=   {}  # To store the pos of node in array



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  return self.cur_size == 0



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   self.left(_snake_case    )
  lowerCAmelCase													=   self.right(_snake_case    )
  if lc < self.cur_size and self.array(_snake_case    )[0] < self.array(_snake_case    )[0]:
   lowerCAmelCase													=   lc
  else:
   lowerCAmelCase													=   idx
  if rc < self.cur_size and self.array(_snake_case    )[0] < self.array(_snake_case    )[0]:
   lowerCAmelCase													=   rc
  if smallest != idx:
   self.swap(_snake_case							,					_snake_case    )
   self.min_heapify(_snake_case    )



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   self.cur_size
  self.cur_size += 1
  self.array.append((sys.maxsize, tup[1])    )
  self.decrease_key((sys.maxsize, tup[1])							,					tup[0]    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   self.array[0][1]
  lowerCAmelCase													=   self.array[self.cur_size - 1]
  self.cur_size -= 1
  self.min_heapify(1    )
  del self.pos[min_node]
  return min_node



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  return 2 * i + 1



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  return 2 * i + 2



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  return math.floor(i / 2    )



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   j
  lowerCAmelCase													=   i
  lowerCAmelCase													=   self.array[i]
  lowerCAmelCase													=   self.array[j]
  lowerCAmelCase													=   temp



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   self.pos[tup[1]]
  # assuming the new_d is atmost old_d
  lowerCAmelCase													=   (new_d, tup[1])
  while idx > 0 and self.array[self.par(_snake_case    )][0] > self.array[idx][0]:
   self.swap(_snake_case							,					self.par(_snake_case    )    )
   lowerCAmelCase													=   self.par(_snake_case    )







class 			a       :



 def __init__(    self							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   {}  # To store graph: u -> (v,w)
  lowerCAmelCase													=   num  # Number of nodes in graph
  # To store the distance from source vertex
  lowerCAmelCase													=   [0] * self.num_nodes
  lowerCAmelCase													=   [-1] * self.num_nodes  # To store the path



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  if u in self.adjList:
   self.adjList[u].append((v, w)    )
  else:
   lowerCAmelCase													=   [(v, w)]

  # Assuming undirected graph
  if v in self.adjList:
   self.adjList[v].append((u, w)    )
  else:
   lowerCAmelCase													=   [(u, w)]



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  for u in self.adjList:
   print(_snake_case							,					'->'							,					' -> '.join(str(F'{v}({w})'    ) for v, w in self.adjList[u]    )    )



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   [-1] * self.num_nodes
  # src is the source node
  lowerCAmelCase													=   0
  lowerCAmelCase													=   PriorityQueue()
  q.insert((0, src)    )  # (dist from src, node)
  for u in self.adjList:
   if u != src:
    lowerCAmelCase													=   sys.maxsize  # Infinity
    lowerCAmelCase													=   -1

  while not q.is_empty():
   lowerCAmelCase													=   q.extract_min()  # Returns node with the min dist from source
   # Update the distance of all the neighbours of u and
   # if their prev dist was INFINITY then push them in Q
   for v, w in self.adjList[u]:
    lowerCAmelCase													=   self.dist[u] + w
    if self.dist[v] > new_dist:
     if self.dist[v] == sys.maxsize:
      q.insert((new_dist, v)    )
     else:
      q.decrease_key((self.dist[v], v)							,					_snake_case    )
     lowerCAmelCase													=   new_dist
     lowerCAmelCase													=   u

        # Show the shortest distances from src
  self.show_distances(_snake_case    )



 def       UpperCamelCase__     (    self							,					_snake_case    ):







  """simple docstring"""






  print(F'Distance from node: {src}'    )
  for u in range(self.num_nodes    ):
   print(F'Node {u} has distance: {self.dist[u]}'    )



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






  lowerCAmelCase													=   []
  lowerCAmelCase													=   0
  lowerCAmelCase													=   dest
  # Backtracking from dest to src
  while self.par[temp] != -1:
   path.append(_snake_case    )
   if temp != src:
    for v, w in self.adjList[temp]:
     if v == self.par[temp]:
      cost += w
      break
   lowerCAmelCase													=   self.par[temp]
  path.append(_snake_case    )
  path.reverse()

  print(F'----Path to reach {dest} from {src}----'    )
  for u in path:
   print(F'{u}'							,					end=' '    )
   if u != dest:
    print('-> '							,					end=''    )

  print('\nTotal cost of path: '							,					_snake_case    )


if __name__ == "__main__":
       __UpperCamelCase    :	str						=     Graph(9)
       graph.add_edge(0, 1, 4)
       graph.add_edge(0, 7, 8)
       graph.add_edge(1, 2, 8)
       graph.add_edge(1, 7, 11)
       graph.add_edge(2, 3, 7)
       graph.add_edge(2, 8, 2)
       graph.add_edge(2, 5, 4)
       graph.add_edge(3, 4, 9)
       graph.add_edge(3, 5, 14)
       graph.add_edge(4, 5, 10)
       graph.add_edge(5, 6, 2)
       graph.add_edge(6, 7, 1)
       graph.add_edge(6, 8, 6)
       graph.add_edge(7, 8, 7)
       graph.show_graph()
       graph.dijkstra(0)
       graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21





