


from __future__ import annotations

from random import random
from typing import Generic, TypeVar

UpperCamelCase								=	TypeVar("""KT""")
UpperCamelCase								=	TypeVar("""VT""")






class   _lowerCamelCase (					Generic[KT, VT]			):




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE = "root"				,       _SCREAMING_SNAKE_CASE = None		)->str:




         '''simple docstring'''





         A_      :				Any		     =					key
         A_      :				List[Any]		     =					value
         A_      :				list[Node[KT, VT]]		     =					[]



       def __repr__(      self		)->str:




         '''simple docstring'''





         return F'''Node({self.key}: {self.value})'''







       @property
       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         return len(self.forward		)






class   _lowerCamelCase (					Generic[KT, VT]			):




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE = 0.5				,       _SCREAMING_SNAKE_CASE = 16		)->Dict:




         '''simple docstring'''





         A_      :				Node[KT, VT]		     =					Node[KT, VT]()
         A_      :				int		     =					0
         A_      :				Dict		     =					p
         A_      :				Union[str, Any]		     =					max_level



       def __str__(      self		)->str:




         '''simple docstring'''





         A_      :				Optional[int]		     =					list(self		)

         if len(_SCREAMING_SNAKE_CASE		) == 0:
           return F'''SkipList(level={self.level})'''

         A_      :				List[Any]		     =					max((len(str(_SCREAMING_SNAKE_CASE		)		) for item in items)				,       default=4		)
         A_      :				Tuple		     =					max(_SCREAMING_SNAKE_CASE				,       4		) + 4

         A_      :				Union[str, Any]		     =					self.head
         A_      :				int		     =					[]

         A_      :				Optional[Any]		     =					node.forward.copy()
         lines.append(F'''[{node.key}]'''.ljust(_SCREAMING_SNAKE_CASE				,       '''-'''		) + '''* ''' * len(_SCREAMING_SNAKE_CASE		)		)
         lines.append(''' ''' * label_size + '''| ''' * len(_SCREAMING_SNAKE_CASE		)		)

         while len(node.forward		) != 0:
           A_      :				Dict		     =					node.forward[0]

           lines.append(
               F'''[{node.key}]'''.ljust(_SCREAMING_SNAKE_CASE				,       '''-'''		)
               + ''' '''.join(str(n.key		) if n.key == node.key else '''|''' for n in forwards		)		)
           lines.append(''' ''' * label_size + '''| ''' * len(_SCREAMING_SNAKE_CASE		)		)
           A_      :				Optional[int]		     =					node.forward

         lines.append('''None'''.ljust(_SCREAMING_SNAKE_CASE		) + '''* ''' * len(_SCREAMING_SNAKE_CASE		)		)
         return F'''SkipList(level={self.level})\n''' + "\n".join(_SCREAMING_SNAKE_CASE		)



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




         '''simple docstring'''





         A_      :				Dict		     =					self.head

         while len(node.forward		) != 0:
           yield node.forward[0].key
           A_      :				int		     =					node.forward[0]



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				List[Any]		     =					1
         while random() < self.p and level < self.max_level:
           level += 1

         return level



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE		)->tuple[Node[KT, VT] | None, list[Node[KT, VT]]]:




         '''simple docstring'''





         A_      :				Optional[Any]		     =					[]

         A_      :				Dict		     =					self.head

         for i in reversed(range(self.level		)		):
           # i < node.level - When node level is lesser than `i` decrement `i`.
           # node.forward[i].key < key - Jumping to node with key value higher
           #                             or equal to searched key would result
           #                             in skipping searched key.
           while i < node.level and node.forward[i].key < key:
             A_      :				Union[str, Any]		     =					node.forward[i]
           # Each leftmost node (relative to searched node) will potentially have to
           # be updated.
           update_vector.append(_SCREAMING_SNAKE_CASE		)

         update_vector.reverse()  # Note that we were inserting values in reverse order.

         # len(node.forward) != 0 - If current node doesn't contain any further
         #                          references then searched key is not present.
         # node.forward[0].key == key - Next node key should be equal to search key
         #                              if key is present.
         if len(node.forward		) != 0 and node.forward[0].key == key:
           return node.forward[0], update_vector
         else:
           return None, update_vector



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE		)->Tuple:




         '''simple docstring'''





         A_     ,       A_      :				Dict		     =					self._locate_node(_SCREAMING_SNAKE_CASE		)

         if node is not None:
           for i, update_node in enumerate(_SCREAMING_SNAKE_CASE		):
             # Remove or replace all references to removed node.
             if update_node.level > i and update_node.forward[i].key == key:
               if node.level > i:
                 A_      :				Dict		     =					node.forward[i]
               else:
                 A_      :				Any		     =					update_node.forward[:i]



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->Dict:




         '''simple docstring'''





         A_     ,       A_      :				int		     =					self._locate_node(_SCREAMING_SNAKE_CASE		)
         if node is not None:
           A_      :				Any		     =					value
         else:
           A_      :				Tuple		     =					self.random_level()

           if level > self.level:
             # After level increase we have to add additional nodes to head.
             for _ in range(self.level - 1				,       _SCREAMING_SNAKE_CASE		):
               update_vector.append(self.head		)
             A_      :				List[str]		     =					level

           A_      :				List[str]		     =					Node(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

           for i, update_node in enumerate(update_vector[:level]		):
             # Change references to pass through new node.
             if update_node.level > i:
               new_node.forward.append(update_node.forward[i]		)

             if update_node.level < i + 1:
               update_node.forward.append(_SCREAMING_SNAKE_CASE		)
             else:
               A_      :				int		     =					new_node







       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE		)->VT | None:




         '''simple docstring'''





         A_     ,       A_      :				Optional[Any]		     =					self._locate_node(_SCREAMING_SNAKE_CASE		)

         if node is not None:
           return node.value

         return None




def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				str		     =					SkipList()
  skip_list.insert('''Key1''' ,			3       )
  skip_list.insert('''Key2''' ,			12       )
  skip_list.insert('''Key3''' ,			41       )
  skip_list.insert('''Key4''' ,			-19       )

  A_      :				Tuple		     =					skip_list.head
  A_      :				Optional[Any]		     =					{}
  while node.level != 0:
    A_      :				Any		     =					node.forward[0]
    A_      :				List[str]		     =					node.value

  assert len(SCREAMING_SNAKE_CASE       ) == 4
  assert all_values["Key1"] == 3
  assert all_values["Key2"] == 12
  assert all_values["Key3"] == 41
  assert all_values["Key4"] == -19


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				str		     =					SkipList()
  skip_list.insert('''Key1''' ,			10       )
  skip_list.insert('''Key1''' ,			12       )

  skip_list.insert('''Key5''' ,			7       )
  skip_list.insert('''Key7''' ,			10       )
  skip_list.insert('''Key10''' ,			5       )

  skip_list.insert('''Key7''' ,			7       )
  skip_list.insert('''Key5''' ,			5       )
  skip_list.insert('''Key10''' ,			10       )

  A_      :				int		     =					skip_list.head
  A_      :				Optional[Any]		     =					{}
  while node.level != 0:
    A_      :				Any		     =					node.forward[0]
    A_      :				str		     =					node.value

  if len(SCREAMING_SNAKE_CASE       ) != 4:
    print()
  assert len(SCREAMING_SNAKE_CASE       ) == 4
  assert all_values["Key1"] == 12
  assert all_values["Key7"] == 7
  assert all_values["Key5"] == 5
  assert all_values["Key10"] == 10


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Any		     =					SkipList()
  assert skip_list.find('''Some key'''       ) is None


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Tuple		     =					SkipList()

  skip_list.insert('''Key2''' ,			20       )
  assert skip_list.find('''Key2'''       ) == 20

  skip_list.insert('''Some Key''' ,			10       )
  skip_list.insert('''Key2''' ,			8       )
  skip_list.insert('''V''' ,			13       )

  assert skip_list.find('''Y'''       ) is None
  assert skip_list.find('''Key2'''       ) == 8
  assert skip_list.find('''Some Key'''       ) == 10
  assert skip_list.find('''V'''       ) == 13


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Any		     =					SkipList()
  skip_list.delete('''Some key'''       )

  assert len(skip_list.head.forward       ) == 0


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				List[str]		     =					SkipList()

  skip_list.insert('''Key1''' ,			12       )
  skip_list.insert('''V''' ,			13       )
  skip_list.insert('''X''' ,			14       )
  skip_list.insert('''Key2''' ,			15       )

  skip_list.delete('''V'''       )
  skip_list.delete('''Key2'''       )

  assert skip_list.find('''V'''       ) is None
  assert skip_list.find('''Key2'''       ) is None


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				str		     =					SkipList()

  skip_list.insert('''Key1''' ,			12       )
  skip_list.insert('''V''' ,			13       )
  skip_list.insert('''X''' ,			14       )
  skip_list.insert('''Key2''' ,			15       )

  skip_list.delete('''V'''       )
  assert skip_list.find('''V'''       ) is None
  assert skip_list.find('''X'''       ) == 14
  assert skip_list.find('''Key1'''       ) == 12
  assert skip_list.find('''Key2'''       ) == 15

  skip_list.delete('''X'''       )
  assert skip_list.find('''V'''       ) is None
  assert skip_list.find('''X'''       ) is None
  assert skip_list.find('''Key1'''       ) == 12
  assert skip_list.find('''Key2'''       ) == 15

  skip_list.delete('''Key1'''       )
  assert skip_list.find('''V'''       ) is None
  assert skip_list.find('''X'''       ) is None
  assert skip_list.find('''Key1'''       ) is None
  assert skip_list.find('''Key2'''       ) == 15

  skip_list.delete('''Key2'''       )
  assert skip_list.find('''V'''       ) is None
  assert skip_list.find('''X'''       ) is None
  assert skip_list.find('''Key1'''       ) is None
  assert skip_list.find('''Key2'''       ) is None


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Tuple		     =					SkipList()

  skip_list.insert('''Key1''' ,			12       )
  skip_list.insert('''V''' ,			13       )
  skip_list.insert('''X''' ,			142       )
  skip_list.insert('''Key2''' ,			15       )

  skip_list.delete('''X'''       )

  def traverse_keys(SCREAMING_SNAKE_CASE       ):
    yield node.key
    for forward_node in node.forward:
      yield from traverse_keys(SCREAMING_SNAKE_CASE       )

  assert len(set(traverse_keys(skip_list.head       )       )       ) == 4


def   _SCREAMING_SNAKE_CASE	( ):
  def is_sorted(SCREAMING_SNAKE_CASE       ):
    return all(next_item >= item for item, next_item in zip(SCREAMING_SNAKE_CASE ,			lst[1:]       )       )

  A_      :				str		     =					SkipList()
  for i in range(10       ):
    skip_list.insert(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )
  assert is_sorted(list(SCREAMING_SNAKE_CASE       )       )
  skip_list.delete(5       )
  skip_list.delete(8       )
  skip_list.delete(2       )
  assert is_sorted(list(SCREAMING_SNAKE_CASE       )       )
  skip_list.insert(-12 ,			-12       )
  skip_list.insert(77 ,			77       )
  assert is_sorted(list(SCREAMING_SNAKE_CASE       )       )


def   _SCREAMING_SNAKE_CASE	( ):
  for _ in range(100       ):
    # Repeat test 100 times due to the probabilistic nature of skip list
    # random values == random bugs
    test_insert()
    test_insert_overrides_existing_value()

    test_searching_empty_list_returns_none()
    test_search()

    test_deleting_item_from_empty_list_do_nothing()
    test_deleted_items_are_not_founded_by_find_method()
    test_delete_removes_only_given_key()
    test_delete_doesnt_leave_dead_nodes()

    test_iter_always_yields_sorted_values()


def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Optional[Any]		     =					SkipList()
  skip_list.insert(2 ,			'''2'''       )
  skip_list.insert(4 ,			'''4'''       )
  skip_list.insert(6 ,			'''4'''       )
  skip_list.insert(4 ,			'''5'''       )
  skip_list.insert(8 ,			'''4'''       )
  skip_list.insert(9 ,			'''4'''       )

  skip_list.delete(4       )

  print(SCREAMING_SNAKE_CASE       )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()








import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
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 torch import nn

     from transformers import RegNetForImageClassification, RegNetModel
     from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor






class   _lowerCamelCase :




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE=3				,       _SCREAMING_SNAKE_CASE=32				,       _SCREAMING_SNAKE_CASE=3				,       _SCREAMING_SNAKE_CASE=10				,       _SCREAMING_SNAKE_CASE=[10, 20, 30, 40]				,       _SCREAMING_SNAKE_CASE=[1, 1, 2, 1]				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE="relu"				,       _SCREAMING_SNAKE_CASE=3				,       _SCREAMING_SNAKE_CASE=None				,       )->List[str]:




         '''simple docstring'''





         A_      :				str		     =					parent
         A_      :				int		     =					batch_size
         A_      :				List[str]		     =					image_size
         A_      :				Dict		     =					num_channels
         A_      :				Tuple		     =					embeddings_size
         A_      :				Union[str, Any]		     =					hidden_sizes
         A_      :				Dict		     =					depths
         A_      :				str		     =					is_training
         A_      :				Union[str, Any]		     =					use_labels
         A_      :				Union[str, Any]		     =					hidden_act
         A_      :				Optional[Any]		     =					num_labels
         A_      :				Tuple		     =					scope
         A_      :				Optional[int]		     =					len(_SCREAMING_SNAKE_CASE		)



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




         '''simple docstring'''





         A_      :				List[str]		     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

         A_      :				str		     =					None
         if self.use_labels:
           A_      :				Union[str, Any]		     =					ids_tensor([self.batch_size]				,       self.num_labels		)

         A_      :				Optional[Any]		     =					self.get_config()

         return config, pixel_values, labels



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




         '''simple docstring'''





         return RegNetConfig(
             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				,       )



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




         '''simple docstring'''





         A_      :				Dict		     =					RegNetModel(config=_SCREAMING_SNAKE_CASE		)
         model.to(_SCREAMING_SNAKE_CASE		)
         model.eval()
         A_      :				Any		     =					model(_SCREAMING_SNAKE_CASE		)
         # 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        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->Union[str, Any]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					self.num_labels
         A_      :				Dict		     =					RegNetForImageClassification(_SCREAMING_SNAKE_CASE		)
         model.to(_SCREAMING_SNAKE_CASE		)
         model.eval()
         A_      :				int		     =					model(_SCREAMING_SNAKE_CASE				,       labels=_SCREAMING_SNAKE_CASE		)
         self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)		)







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




         '''simple docstring'''





         A_      :				Tuple		     =					self.prepare_config_and_inputs()
         A_     ,       A_     ,       A_      :				str		     =					config_and_inputs
         A_      :				Any		     =					{'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
class   _lowerCamelCase (					UpperCamelCase					,							UpperCamelCase					,							unittest.TestCase			):




       """simple docstring"""
       snake_case      =    (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
       snake_case      =    (
           {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
           if is_torch_available()
           else {}
       )

       snake_case      =    False
       snake_case      =    False
       snake_case      =    False
       snake_case      =    False



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




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					RegNetModelTester(self		)
         A_      :				Union[str, Any]		     =					ConfigTester(self				,       config_class=_SCREAMING_SNAKE_CASE				,       has_text_modality=_SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->Dict:




         '''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        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         return



       @unittest.skip(reason='''RegNet does not use inputs_embeds'''		)
       def        _snake_case       (      self		)->Dict:




         '''simple docstring'''





         pass



       @unittest.skip(reason='''RegNet does not support input and output embeddings'''		)
       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         pass



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




         '''simple docstring'''





         A_     ,       A_      :				Optional[Any]		     =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_      :				str		     =					model_class(_SCREAMING_SNAKE_CASE		)
           A_      :				Union[str, Any]		     =					inspect.signature(model.forward		)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           A_      :				Any		     =					[*signature.parameters.keys()]

           A_      :				Any		     =					['''pixel_values''']
           self.assertListEqual(arg_names[:1]				,       _SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_      :				Dict		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)



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




         '''simple docstring'''





         A_     ,       A_      :				int		     =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_      :				Union[str, Any]		     =					model_class(config=_SCREAMING_SNAKE_CASE		)
           for name, module in model.named_modules():
             if isinstance(_SCREAMING_SNAKE_CASE				,       (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        _snake_case       (      self		)->List[Any]:




         '''simple docstring'''





         def check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
           A_      :				str		     =					model_class(_SCREAMING_SNAKE_CASE		)
           model.to(_SCREAMING_SNAKE_CASE		)
           model.eval()

           with torch.no_grad():
             A_      :				Tuple		     =					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)		)

           A_      :				Union[str, Any]		     =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           A_      :				Optional[int]		     =					self.model_tester.num_stages
           self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       expected_num_stages + 1		)

           # RegNet'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 // 2, self.model_tester.image_size // 2]				,       )

         A_     ,       A_      :				Tuple		     =					self.model_tester.prepare_config_and_inputs_for_common()
         A_      :				int		     =					['''basic''', '''bottleneck''']
         for model_class in self.all_model_classes:
           for layer_type in layers_type:
             A_      :				int		     =					layer_type
             A_      :				List[Any]		     =					True
             check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             A_      :				str		     =					True

             check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->Dict:




         '''simple docstring'''





         A_      :				List[str]		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE		)







       @slow
       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           A_      :				Dict		     =					RegNetModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)




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







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




       """simple docstring"""



       @cached_property
       def        _snake_case       (      self		)->List[str]:




         '''simple docstring'''





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







       @slow
       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         A_      :				List[Any]		     =					RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(_SCREAMING_SNAKE_CASE		)

         A_      :				Optional[Any]		     =					self.default_image_processor
         A_      :				Any		     =					prepare_img()
         A_      :				Optional[Any]		     =					image_processor(images=_SCREAMING_SNAKE_CASE				,       return_tensors='''pt'''		).to(_SCREAMING_SNAKE_CASE		)

         # forward pass
         with torch.no_grad():
           A_      :				Union[str, Any]		     =					model(**_SCREAMING_SNAKE_CASE		)

         # verify the logits
         A_      :				Union[str, Any]		     =					torch.Size((1, 1000)		)
         self.assertEqual(outputs.logits.shape				,       _SCREAMING_SNAKE_CASE		)

         A_      :				Optional[int]		     =					torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]		).to(_SCREAMING_SNAKE_CASE		)

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




