


# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()


class 			_a				(     UpperCamelCase__	,      UpperCamelCase__	,      UpperCamelCase__	,      unittest.TestCase     ):
							_lowercase      :     List[str]     =					StableDiffusionControlNetImgaImgPipeline
							_lowercase      :     int     =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
							_lowercase      :     Union[str, Any]     =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_lowercase      :     Tuple     =					IMAGE_TO_IMAGE_IMAGE_PARAMS.union({'''control_image'''}     )
							_lowercase      :     Tuple     =					IMAGE_TO_IMAGE_IMAGE_PARAMS

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





									"""simple docstring"""







									torch.manual_seed(0				)
									lowercase__				= UNetaDConditionModel(
									    block_out_channels=(32, 64)       ,		layers_per_block=2       ,		sample_size=32       ,		in_channels=4       ,		out_channels=4       ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,		up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,		cross_attention_dim=32       ,		)
									torch.manual_seed(0				)
									lowercase__				= ControlNetModel(
									    block_out_channels=(32, 64)       ,		layers_per_block=2       ,		in_channels=4       ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,		cross_attention_dim=32       ,		conditioning_embedding_out_channels=(16, 32)       ,		)
									torch.manual_seed(0				)
									lowercase__				= DDIMScheduler(
									    beta_start=0.00085       ,		beta_end=0.012       ,		beta_schedule='''scaled_linear'''       ,		clip_sample=UpperCamelCase_       ,		set_alpha_to_one=UpperCamelCase_       ,		)
									torch.manual_seed(0				)
									lowercase__				= AutoencoderKL(
									    block_out_channels=[32, 64]       ,		in_channels=3       ,		out_channels=3       ,		down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,		up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,		latent_channels=4       ,		)
									torch.manual_seed(0				)
									lowercase__				= CLIPTextConfig(
									    bos_token_id=0       ,		eos_token_id=2       ,		hidden_size=32       ,		intermediate_size=37       ,		layer_norm_eps=1E-0_5       ,		num_attention_heads=4       ,		num_hidden_layers=5       ,		pad_token_id=1       ,		vocab_size=1_000       ,		)
									lowercase__				= CLIPTextModel(UpperCamelCase_				)
									lowercase__				= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

									lowercase__				= {
									    '''unet''': unet,
									    '''controlnet''': controlnet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components

							def  lowerCamelCase_					(				self:      Any       ,		UpperCamelCase_:      List[Any]       ,		UpperCamelCase_:      Any=0				)     ->  Union[str, Any]:





									"""simple docstring"""







									if str(UpperCamelCase_				).startswith('''mps'''				):
											lowercase__				= torch.manual_seed(UpperCamelCase_				)
									else:
											lowercase__				= torch.Generator(device=UpperCamelCase_				).manual_seed(UpperCamelCase_				)

									lowercase__				= 2
									lowercase__				= randn_tensor(
									    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,		generator=UpperCamelCase_       ,		device=torch.device(UpperCamelCase_				)       ,		)
									lowercase__				= floats_tensor(control_image.shape       ,		rng=random.Random(UpperCamelCase_				)				).to(UpperCamelCase_				)
									lowercase__				= image.cpu().permute(0       ,		2       ,		3       ,		1				)[0]
									lowercase__				= Image.fromarray(np.uinta(UpperCamelCase_				)				).convert('''RGB'''				).resize((64, 64)				)
									lowercase__				= {
									    '''prompt''': '''A painting of a squirrel eating a burger''',
									    '''generator''': generator,
									    '''num_inference_steps''': 2,
									    '''guidance_scale''': 6.0,
									    '''output_type''': '''numpy''',
									    '''image''': image,
									    '''control_image''': control_image,
									}

									return inputs

							def  lowerCamelCase_					(				self:      str				)     ->  Tuple:





									"""simple docstring"""







									return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)

							@unittest.skipIf(
							    torch_device != '''cuda''' or not is_xformers_available()       ,		reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,		)
							def  lowerCamelCase_					(				self:      Dict				)     ->  List[str]:





									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)


							def  lowerCamelCase_					(				self:      str				)     ->  Any:





									"""simple docstring"""







									self._test_inference_batch_single_identical(expected_max_diff=2E-3				)


class 			_a				(     UpperCamelCase__	,      UpperCamelCase__	,      unittest.TestCase     ):
							_lowercase      :     Optional[int]     =					StableDiffusionControlNetImgaImgPipeline
							_lowercase      :     List[Any]     =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
							_lowercase      :     List[Any]     =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_lowercase      :     Dict     =					frozenset([]     )  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess

							def  lowerCamelCase_					(				self:      Dict				)     ->  List[Any]:





									"""simple docstring"""







									torch.manual_seed(0				)
									lowercase__				= UNetaDConditionModel(
									    block_out_channels=(32, 64)       ,		layers_per_block=2       ,		sample_size=32       ,		in_channels=4       ,		out_channels=4       ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,		up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,		cross_attention_dim=32       ,		)
									torch.manual_seed(0				)

									def init_weights(UpperCamelCase_:      Optional[int]				):
											if isinstance(UpperCamelCase_       ,		torch.nn.Convad				):
													torch.nn.init.normal(m.weight				)
													m.bias.data.fill_(1.0				)

									lowercase__				= ControlNetModel(
									    block_out_channels=(32, 64)       ,		layers_per_block=2       ,		in_channels=4       ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,		cross_attention_dim=32       ,		conditioning_embedding_out_channels=(16, 32)       ,		)
									controlneta.controlnet_down_blocks.apply(UpperCamelCase_				)

									torch.manual_seed(0				)
									lowercase__				= ControlNetModel(
									    block_out_channels=(32, 64)       ,		layers_per_block=2       ,		in_channels=4       ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,		cross_attention_dim=32       ,		conditioning_embedding_out_channels=(16, 32)       ,		)
									controlneta.controlnet_down_blocks.apply(UpperCamelCase_				)

									torch.manual_seed(0				)
									lowercase__				= DDIMScheduler(
									    beta_start=0.00085       ,		beta_end=0.012       ,		beta_schedule='''scaled_linear'''       ,		clip_sample=UpperCamelCase_       ,		set_alpha_to_one=UpperCamelCase_       ,		)
									torch.manual_seed(0				)
									lowercase__				= AutoencoderKL(
									    block_out_channels=[32, 64]       ,		in_channels=3       ,		out_channels=3       ,		down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,		up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,		latent_channels=4       ,		)
									torch.manual_seed(0				)
									lowercase__				= CLIPTextConfig(
									    bos_token_id=0       ,		eos_token_id=2       ,		hidden_size=32       ,		intermediate_size=37       ,		layer_norm_eps=1E-0_5       ,		num_attention_heads=4       ,		num_hidden_layers=5       ,		pad_token_id=1       ,		vocab_size=1_000       ,		)
									lowercase__				= CLIPTextModel(UpperCamelCase_				)
									lowercase__				= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

									lowercase__				= MultiControlNetModel([controlneta, controlneta]				)

									lowercase__				= {
									    '''unet''': unet,
									    '''controlnet''': controlnet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components

							def  lowerCamelCase_					(				self:      Tuple       ,		UpperCamelCase_:      Optional[Any]       ,		UpperCamelCase_:      List[Any]=0				)     ->  Union[str, Any]:





									"""simple docstring"""







									if str(UpperCamelCase_				).startswith('''mps'''				):
											lowercase__				= torch.manual_seed(UpperCamelCase_				)
									else:
											lowercase__				= torch.Generator(device=UpperCamelCase_				).manual_seed(UpperCamelCase_				)

									lowercase__				= 2

									lowercase__				= [
									    randn_tensor(
									        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,		generator=UpperCamelCase_       ,		device=torch.device(UpperCamelCase_				)       ,		),
									    randn_tensor(
									        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,		generator=UpperCamelCase_       ,		device=torch.device(UpperCamelCase_				)       ,		),
									]

									lowercase__				= floats_tensor(control_image[0].shape       ,		rng=random.Random(UpperCamelCase_				)				).to(UpperCamelCase_				)
									lowercase__				= image.cpu().permute(0       ,		2       ,		3       ,		1				)[0]
									lowercase__				= Image.fromarray(np.uinta(UpperCamelCase_				)				).convert('''RGB'''				).resize((64, 64)				)
									lowercase__				= {
									    '''prompt''': '''A painting of a squirrel eating a burger''',
									    '''generator''': generator,
									    '''num_inference_steps''': 2,
									    '''guidance_scale''': 6.0,
									    '''output_type''': '''numpy''',
									    '''image''': image,
									    '''control_image''': control_image,
									}

									return inputs

							def  lowerCamelCase_					(				self:      Optional[Any]				)     ->  int:





									"""simple docstring"""







									lowercase__				= self.get_dummy_components()
									lowercase__				= self.pipeline_class(**UpperCamelCase_				)
									pipe.to(UpperCamelCase_				)

									lowercase__				= 10.0
									lowercase__				= 4

									lowercase__				= self.get_dummy_inputs(UpperCamelCase_				)
									lowercase__				= steps
									lowercase__				= scale
									lowercase__				= pipe(**UpperCamelCase_				)[0]

									lowercase__				= self.get_dummy_inputs(UpperCamelCase_				)
									lowercase__				= steps
									lowercase__				= scale
									lowercase__				= pipe(**UpperCamelCase_       ,		control_guidance_start=0.1       ,		control_guidance_end=0.2				)[0]

									lowercase__				= self.get_dummy_inputs(UpperCamelCase_				)
									lowercase__				= steps
									lowercase__				= scale
									lowercase__				= pipe(**UpperCamelCase_       ,		control_guidance_start=[0.1, 0.3]       ,		control_guidance_end=[0.2, 0.7]				)[0]

									lowercase__				= self.get_dummy_inputs(UpperCamelCase_				)
									lowercase__				= steps
									lowercase__				= scale
									lowercase__				= pipe(**UpperCamelCase_       ,		control_guidance_start=0.4       ,		control_guidance_end=[0.5, 0.8]				)[0]

									# make sure that all outputs are different
									assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
									assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
									assert np.sum(np.abs(output_a - output_a				)				) > 1E-3

							def  lowerCamelCase_					(				self:      Optional[Any]				)     ->  str:





									"""simple docstring"""







									return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)

							@unittest.skipIf(
							    torch_device != '''cuda''' or not is_xformers_available()       ,		reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,		)
							def  lowerCamelCase_					(				self:      Dict				)     ->  Any:





									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)

							def  lowerCamelCase_					(				self:      Optional[int]				)     ->  List[str]:





									"""simple docstring"""







									self._test_inference_batch_single_identical(expected_max_diff=2E-3				)


							def  lowerCamelCase_					(				self:      List[str]				)     ->  Tuple:





									"""simple docstring"""







									lowercase__				= self.get_dummy_components()
									lowercase__				= self.pipeline_class(**UpperCamelCase_				)
									pipe.to(UpperCamelCase_				)
									pipe.set_progress_bar_config(disable=UpperCamelCase_				)
									with tempfile.TemporaryDirectory() as tmpdir:
											try:
													# save_pretrained is not implemented for Multi-ControlNet
													pipe.save_pretrained(UpperCamelCase_				)
											except NotImplementedError:
													pass


@slow
@require_torch_gpu
class 			_a				(     unittest.TestCase     ):

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





									"""simple docstring"""







									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()


							def  lowerCamelCase_					(				self:      int				)     ->  Optional[int]:





									"""simple docstring"""







									lowercase__				= ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''				)

									lowercase__				= StableDiffusionControlNetImgaImgPipeline.from_pretrained(
									    '''runwayml/stable-diffusion-v1-5'''       ,		safety_checker=UpperCamelCase_       ,		controlnet=UpperCamelCase_				)
									pipe.enable_model_cpu_offload()
									pipe.set_progress_bar_config(disable=UpperCamelCase_				)

									lowercase__				= torch.Generator(device='''cpu'''				).manual_seed(0				)
									lowercase__				= '''evil space-punk bird'''
									lowercase__				= load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''				).resize((512, 512)				)
									lowercase__				= load_image(
									    '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''				).resize((512, 512)				)

									lowercase__				= pipe(
									    UpperCamelCase_       ,		UpperCamelCase_       ,		control_image=UpperCamelCase_       ,		generator=UpperCamelCase_       ,		output_type='''np'''       ,		num_inference_steps=50       ,		strength=0.6       ,		)

									lowercase__				= output.images[0]

									assert image.shape == (512, 512, 3)

									lowercase__				= load_numpy(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy'''				)

									assert np.abs(expected_image - image				).max() < 9E-2



"""simple docstring"""






import inspect
import unittest

from transformers import ConvNextConfig
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 transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
       from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor





class 					_A		:

      def __init__(		self						,			__lowerCAmelCase						,			__lowerCAmelCase=13						,			__lowerCAmelCase=32						,			__lowerCAmelCase=3						,			__lowerCAmelCase=4						,			__lowerCAmelCase=[10, 20, 30, 40]						,			__lowerCAmelCase=[2, 2, 3, 2]						,			__lowerCAmelCase=True						,			__lowerCAmelCase=True						,			__lowerCAmelCase=37						,			__lowerCAmelCase="gelu"						,			__lowerCAmelCase=10						,			__lowerCAmelCase=0.0_2						,			__lowerCAmelCase=["stage2", "stage3", "stage4"]						,			__lowerCAmelCase=[2, 3, 4]						,			__lowerCAmelCase=None						,			):







            """simple docstring"""



            lowercase								=      parent
            lowercase								=      batch_size
            lowercase								=      image_size
            lowercase								=      num_channels
            lowercase								=      num_stages
            lowercase								=      hidden_sizes
            lowercase								=      depths
            lowercase								=      is_training
            lowercase								=      use_labels
            lowercase								=      intermediate_size
            lowercase								=      hidden_act
            lowercase								=      num_labels
            lowercase								=      initializer_range
            lowercase								=      out_features
            lowercase								=      out_indices
            lowercase								=      scope

      def 							A__			(		self		):







            """simple docstring"""



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

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

            lowercase								=      self.get_config()
            return config, pixel_values, labels

      def 							A__			(		self		):







            """simple docstring"""



            return ConvNextConfig(
                num_channels=self.num_channels						,			hidden_sizes=self.hidden_sizes						,			depths=self.depths						,			num_stages=self.num_stages						,			hidden_act=self.hidden_act						,			is_decoder=__lowerCAmelCase						,			initializer_range=self.initializer_range						,			out_features=self.out_features						,			out_indices=self.out_indices						,			num_labels=self.num_labels						,			)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      ConvNextModel(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      model(__lowerCAmelCase		)
            # 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		):







            """simple docstring"""



            lowercase								=      ConvNextForImageClassification(__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      model(__lowerCAmelCase						,			labels=__lowerCAmelCase		)
            self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.num_labels)		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      ConvNextBackbone(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      model(__lowerCAmelCase		)

            # verify hidden states
            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
            lowercase								=      None
            lowercase								=      ConvNextBackbone(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      model(__lowerCAmelCase		)

            # 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		):







            """simple docstring"""



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






@require_torch
class 					_A		(			lowerCAmelCase    ,       lowerCAmelCase    ,       unittest.TestCase      ):
      snake_case__     :  List[str]				    =      (
          (
              ConvNextModel,
              ConvNextForImageClassification,
              ConvNextBackbone,
          )
          if is_torch_available()
          else ()
      )
      snake_case__     :  Optional[Any]				    =      (
          {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
          if is_torch_available()
          else {}
      )

      snake_case__     :  List[str]				    =      True
      snake_case__     :  Dict				    =      False
      snake_case__     :  Optional[int]				    =      False
      snake_case__     :  Tuple				    =      False
      snake_case__     :  List[str]				    =      False

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ConvNextModelTester(self		)
            lowercase								=      ConfigTester(self						,			config_class=__lowerCAmelCase						,			has_text_modality=__lowerCAmelCase						,			hidden_size=37		)

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







            """simple docstring"""



            return

      @unittest.skip(reason="""ConvNext does not use inputs_embeds"""		)
      def 							A__			(		self		):







            """simple docstring"""



            pass

      @unittest.skip(reason="""ConvNext does not support input and output embeddings"""		)
      def 							A__			(		self		):







            """simple docstring"""



            pass

      @unittest.skip(reason="""ConvNext does not use feedforward chunking"""		)
      def 							A__			(		self		):







            """simple docstring"""



            pass

      def 							A__			(		self		):







            """simple docstring"""



            lowercase				,				lowercase								=      self.model_tester.prepare_config_and_inputs_for_common()

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

                  lowercase								=      ["""pixel_values"""]
                  self.assertListEqual(arg_names[:1]						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            def check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):
                  lowercase								=      model_class(__lowerCAmelCase		)
                  model.to(__lowerCAmelCase		)
                  model.eval()

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

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

                  lowercase								=      self.model_tester.num_stages
                  self.assertEqual(len(__lowerCAmelCase		)						,			expected_num_stages + 1		)

                  # ConvNext'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]						,			)

            lowercase				,				lowercase								=      self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  lowercase								=      True
                  check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)

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

                  check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase		)







      @slow
      def 							A__			(		self		):







            """simple docstring"""



            for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase								=      ConvNextModel.from_pretrained(__lowerCAmelCase		)
                  self.assertIsNotNone(__lowerCAmelCase		)






def      UpperCAmelCase__			(							)					->       List[str]:
      '''simple docstring'''


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





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

      @cached_property
      def 							A__			(		self		):







            """simple docstring"""



            return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""		) if is_vision_available() else None







      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""		).to(__lowerCAmelCase		)

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

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

            # verify the logits
            lowercase								=      torch.Size((1, 1000)		)
            self.assertEqual(outputs.logits.shape						,			__lowerCAmelCase		)

            lowercase								=      torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]		).to(__lowerCAmelCase		)

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






@require_torch
class 					_A		(			unittest.TestCase    ,       lowerCAmelCase      ):
      snake_case__     :  int				    =      (ConvNextBackbone,) if is_torch_available() else ()
      snake_case__     :  Tuple				    =      ConvNextConfig

      snake_case__     :  Dict				    =      False

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ConvNextModelTester(self		)



