'''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     _lowercase					:


 '''simple docstring'''






 def __init__(				self       :     Union[str, Any]				,	SCREAMING_SNAKE_CASE__       :     Tuple				,	SCREAMING_SNAKE_CASE__       :     Optional[int]=3				,	SCREAMING_SNAKE_CASE__       :     List[Any]=32				,	SCREAMING_SNAKE_CASE__       :     Tuple=3				,	SCREAMING_SNAKE_CASE__       :     int=10				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]=[10, 20, 30, 40]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]=[1, 1, 2, 1]				,	SCREAMING_SNAKE_CASE__       :     Tuple=True				,	SCREAMING_SNAKE_CASE__       :     int=True				,	SCREAMING_SNAKE_CASE__       :     str="relu"				,	SCREAMING_SNAKE_CASE__       :     List[Any]=3				,	SCREAMING_SNAKE_CASE__       :     Dict=None				,	SCREAMING_SNAKE_CASE__       :     str=["stage2", "stage3", "stage4"]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]=[2, 3, 4]				,	)  ->   Union[str, Any]:
  __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(SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase    							=						out_features
  __lowerCAmelCase    							=						out_indices
 def a (				self       :     Union[str, Any]							)  ->   Tuple:
  __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 a (				self       :     List[str]							)  ->   Tuple:
  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       :     Optional[Any]				,	SCREAMING_SNAKE_CASE__       :     Any				,	SCREAMING_SNAKE_CASE__       :     Tuple				,	SCREAMING_SNAKE_CASE__       :     int							)  ->   List[Any]:
  __lowerCAmelCase    							=						ResNetModel(config=SCREAMING_SNAKE_CASE__							)
  model.to(SCREAMING_SNAKE_CASE__							)
  model.eval()
  __lowerCAmelCase    							=						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 a (				self       :     Dict				,	SCREAMING_SNAKE_CASE__       :     Tuple				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Tuple:
  __lowerCAmelCase    							=						self.num_labels
  __lowerCAmelCase    							=						ResNetForImageClassification(SCREAMING_SNAKE_CASE__							)
  model.to(SCREAMING_SNAKE_CASE__							)
  model.eval()
  __lowerCAmelCase    							=						model(SCREAMING_SNAKE_CASE__				,	labels=SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.num_labels)							)
 def a (				self       :     List[Any]				,	SCREAMING_SNAKE_CASE__       :     Tuple				,	SCREAMING_SNAKE_CASE__       :     List[Any]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Dict:
  __lowerCAmelCase    							=						ResNetBackbone(config=SCREAMING_SNAKE_CASE__							)
  model.to(SCREAMING_SNAKE_CASE__							)
  model.eval()
  __lowerCAmelCase    							=						model(SCREAMING_SNAKE_CASE__							)

  # 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=SCREAMING_SNAKE_CASE__							)
  model.to(SCREAMING_SNAKE_CASE__							)
  model.eval()
  __lowerCAmelCase    							=						model(SCREAMING_SNAKE_CASE__							)

  # 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       :     Optional[Any]							)  ->   Optional[Any]:
  __lowerCAmelCase    							=						self.prepare_config_and_inputs()
  __lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase    							=						config_and_inputs
  __lowerCAmelCase    							=						{"""pixel_values""": pixel_values}
  return config, inputs_dict







@require_torch
class     _lowercase					(    UpperCAmelCase__  ,							UpperCAmelCase__  ,							unittest.TestCase      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[Any]				     = (
     (
         ResNetModel,
         ResNetForImageClassification,
         ResNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 _SCREAMING_SNAKE_CASE					:	Any				     = (
     {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
     if is_torch_available()
     else {}
 )

 _SCREAMING_SNAKE_CASE					:	int				     = True
 _SCREAMING_SNAKE_CASE					:	List[Any]				     = False
 _SCREAMING_SNAKE_CASE					:	Union[str, Any]				     = False
 _SCREAMING_SNAKE_CASE					:	Tuple				     = False
 _SCREAMING_SNAKE_CASE					:	List[str]				     = False
 def a (				self       :     Any							)  ->   List[Any]:
  __lowerCAmelCase    							=						ResNetModelTester(self							)
  __lowerCAmelCase    							=						ConfigTester(self				,	config_class=SCREAMING_SNAKE_CASE__				,	has_text_modality=SCREAMING_SNAKE_CASE__							)
 def a (				self       :     Dict							)  ->   List[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       :     int							)  ->   Dict:
  return
 @unittest.skip(reason="""ResNet does not use inputs_embeds"""							)
 def a (				self       :     Any							)  ->   Tuple:
  pass
 @unittest.skip(reason="""ResNet does not support input and output embeddings"""							)
 def a (				self       :     Dict							)  ->   Union[str, Any]:
  pass
 def a (				self       :     Tuple							)  ->   Dict:
  __lowerCAmelCase							,	__lowerCAmelCase    							=						self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __lowerCAmelCase    							=						model_class(SCREAMING_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]				,	SCREAMING_SNAKE_CASE__							)
 def a (				self       :     int							)  ->   Union[str, Any]:
  __lowerCAmelCase    							=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)
 def a (				self       :     int							)  ->   List[Any]:
  __lowerCAmelCase    							=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__							)
 def a (				self       :     Tuple							)  ->   Any:
  __lowerCAmelCase							,	__lowerCAmelCase    							=						self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __lowerCAmelCase    							=						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 a (				self       :     Dict							)  ->   str:
  def check_hidden_states_output(SCREAMING_SNAKE_CASE__       :     List[Any]				,	SCREAMING_SNAKE_CASE__       :     Optional[int]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]							):
   __lowerCAmelCase    							=						model_class(SCREAMING_SNAKE_CASE__							)
   model.to(SCREAMING_SNAKE_CASE__							)
   model.eval()

   with torch.no_grad():
    __lowerCAmelCase    							=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__							)							)

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

   __lowerCAmelCase    							=						self.model_tester.num_stages
   self.assertEqual(len(SCREAMING_SNAKE_CASE__							)				,	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(SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__							)

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

    check_hidden_states_output(SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__							)
 @unittest.skip(reason="""ResNet does not use feedforward chunking"""							)
 def a (				self       :     str							)  ->   Optional[int]:
  pass
 def a (				self       :     str							)  ->   str:
  __lowerCAmelCase    							=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__							)





 @slow
 def a (				self       :     Any							)  ->   List[str]:
  for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   __lowerCAmelCase    							=						ResNetModel.from_pretrained(SCREAMING_SNAKE_CASE__							)
   self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)







def 					UpperCamelCase_						( ) ->					Optional[int]:






 '''simple docstring'''

 __lowerCAmelCase    							=						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
 return image







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


 '''simple docstring'''






 @cached_property
 def a (				self       :     List[str]							)  ->   str:
  return (
      AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
      if is_vision_available()
      else None
  )





 @slow
 def a (				self       :     Union[str, Any]							)  ->   str:
  __lowerCAmelCase    							=						ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase    							=						self.default_image_processor
  __lowerCAmelCase    							=						prepare_img()
  __lowerCAmelCase    							=						image_processor(images=SCREAMING_SNAKE_CASE__				,	return_tensors="""pt"""							).to(SCREAMING_SNAKE_CASE__							)

  # forward pass
  with torch.no_grad():
   __lowerCAmelCase    							=						model(**SCREAMING_SNAKE_CASE__							)

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

  __lowerCAmelCase    							=						torch.tensor([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]							).to(SCREAMING_SNAKE_CASE__							)

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







@require_torch
class     _lowercase					(    UpperCAmelCase__  ,							unittest.TestCase      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = (ResNetBackbone,) if is_torch_available() else ()
 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = False
 _SCREAMING_SNAKE_CASE					:	str				     = ResNetConfig
 def a (				self       :     List[str]							)  ->   int:
  __lowerCAmelCase    							=						ResNetModelTester(self							)







'''simple docstring'''

from unittest.mock import patch

import datasets
from datasets import Dataset







def 					UpperCamelCase_						( ) ->					Dict:






 '''simple docstring'''

 __lowerCAmelCase    							=						Dataset.from_dict({"""col_1""": [3, 2, 0, 1]}				)

 with patch("""tqdm.auto.tqdm"""				) as mock_tqdm:
  datasets.disable_progress_bar()
  dset.map(lambda snake_case_				: {"col_2": x["col_1"] + 1}				)
  mock_tqdm.assert_not_called()

  mock_tqdm.reset_mock()

  datasets.enable_progress_bar()
  dset.map(lambda snake_case_				: {"col_2": x["col_1"] + 1}				)
  mock_tqdm.assert_called()






