from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import TFResNetForImageClassification, TFResNetModel
      from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor


class      lowerCAmelCase						:



     def __init__(					self				,      lowerCAmelCase__				,      lowerCAmelCase__=3				,      lowerCAmelCase__=32				,      lowerCAmelCase__=3				,      lowerCAmelCase__=10				,      lowerCAmelCase__=[10, 20, 30, 40]				,      lowerCAmelCase__=[1, 1, 2, 1]				,      lowerCAmelCase__=True				,      lowerCAmelCase__=True				,      lowerCAmelCase__="relu"				,      lowerCAmelCase__=3				,      lowerCAmelCase__=None				,      ):
            _A=	parent
            _A=	batch_size
            _A=	image_size
            _A=	num_channels
            _A=	embeddings_size
            _A=	hidden_sizes
            _A=	depths
            _A=	is_training
            _A=	use_labels
            _A=	hidden_act
            _A=	num_labels
            _A=	scope
            _A=	len(_a       )



     def 			a__  (					self       ):
            _A=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

            _A=	self.get_config()

            return config, pixel_values, labels



     def 			a__  (					self       ):
            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				,      image_size=self.image_size				,      )



     def 			a__  (					self				,      lowerCAmelCase__				,      lowerCAmelCase__				,      lowerCAmelCase__       ):
            _A=	TFResNetModel(config=_a       )
            _A=	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				,      lowerCAmelCase__				,      lowerCAmelCase__				,      lowerCAmelCase__       ):
            _A=	self.num_labels
            _A=	TFResNetForImageClassification(_a       )
            _A=	model(_a				,      labels=_a       )
            self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.num_labels)       )





     def 			a__  (					self       ):
            _A=	self.prepare_config_and_inputs()
            _A=	config_and_inputs
            _A=	{"""pixel_values""": pixel_values}
            return config, inputs_dict


@require_tf
class      lowerCAmelCase						(					UpperCamelCase_			,		UpperCamelCase_			,		unittest.TestCase			):
     _SCREAMING_SNAKE_CASE     :     List[str]		=(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     _SCREAMING_SNAKE_CASE     :     Optional[Any]		=(
         {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     _SCREAMING_SNAKE_CASE     :     Tuple		=False
     _SCREAMING_SNAKE_CASE     :     Union[str, Any]		=False
     _SCREAMING_SNAKE_CASE     :     Tuple		=False
     _SCREAMING_SNAKE_CASE     :     Optional[Any]		=False
     _SCREAMING_SNAKE_CASE     :     Dict		=False



     def 			a__  (					self       ):
            _A=	TFResNetModelTester(self       )
            _A=	ConfigTester(self				,      config_class=_a				,      has_text_modality=_a       )



     def 			a__  (					self       ):
            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       ):
            return



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



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



     def 			a__  (					self       ):
            _A=	self.model_tester.prepare_config_and_inputs_for_common()

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

                   _A=	["""pixel_values"""]
                   self.assertListEqual(arg_names[:1]				,      _a       )



     def 			a__  (					self       ):
            _A=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_a       )



     def 			a__  (					self       ):


            def check_hidden_states_output(lowerCAmelCase__				,      lowerCAmelCase__				,      lowerCAmelCase__       ):
                   _A=	model_class(_a       )
                   _A=	model(**self._prepare_for_class(_a				,      _a       )       )

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

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

            _A=	self.model_tester.prepare_config_and_inputs_for_common()
            _A=	["""basic""", """bottleneck"""]
            for model_class in self.all_model_classes:
                   for layer_type in layers_type:
                          _A=	layer_type
                          _A=	True
                          check_hidden_states_output(_a				,      _a				,      _a       )

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

                          check_hidden_states_output(_a				,      _a				,      _a       )



     def 			a__  (					self       ):
            _A=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*_a       )





     @slow
     def 			a__  (					self       ):


            for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _A=	TFResNetModel.from_pretrained(_a       )
                   self.assertIsNotNone(_a       )


def 							UpperCamelCase				(    )		->						List[Any]:




       '''simple docstring'''






       _A=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
       return image





@require_tf
@require_vision
class      lowerCAmelCase						(					unittest.TestCase			):



     @cached_property
     def 			a__  (					self       ):
            return (
                AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
                if is_vision_available()
                else None
            )





     @slow
     def 			a__  (					self       ):
            _A=	TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

            _A=	self.default_image_processor
            _A=	prepare_img()
            _A=	image_processor(images=_a				,      return_tensors='tf'       )

            # forward pass
            _A=	model(**_a       )

            # verify the logits
            _A=	tf.TensorShape((1, 1000)       )
            self.assertEqual(outputs.logits.shape				,      _a       )

            _A=	tf.constant([-11.1069, -9.7877, -8.3777]       )

            self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()				,      _a				,      atol=1E-4       )       )
import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu





@require_cpu
class      lowerCAmelCase						(					unittest.TestCase			):



     def 			a__  (					self       ):
            _A=	torch.nn.Linear(10				,      10       )
            _A=	torch.optim.SGD(model.parameters()				,      0.1       )
            _A=	Accelerator()
            _A=	accelerator.prepare(lowerCAmelCase__       )
            try:
                   pickle.loads(pickle.dumps(lowerCAmelCase__       )       )
            except Exception as e:
                   self.fail(f"Accelerated optimizer pickling failed with {e}"       )
            AcceleratorState._reset_state()