


import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
	from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor
class 	lowerCamelCase_       :



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=1_3 ,       snake_case_=3_2 ,       snake_case_=3 ,       snake_case_=4 ,       snake_case_=[1_0, 2_0, 3_0, 4_0] ,       snake_case_=[2, 2, 3, 2] ,       snake_case_=True ,       snake_case_=True ,       snake_case_=3_7 ,       snake_case_="gelu" ,       snake_case_=1_0 ,       snake_case_=0.0_2 ,       snake_case_=["stage2", "stage3", "stage4"] ,       snake_case_=[2, 3, 4] ,       snake_case_=None ,       )   ->			int:







								'''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						)   ->			Optional[Any]:







								'''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						)   ->			Union[str, Any]:







								'''simple docstring'''

								return ConvNextVaConfig(
								    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=snake_case_ ,       initializer_range=self.initializer_range ,       out_features=self.out_features ,       out_indices=self.out_indices ,       num_labels=self.num_labels ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   ConvNextVaModel(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(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 // 3_2, self.image_size // 3_2) ,       )






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







								'''simple docstring'''

								__lowercase 					=   ConvNextVaForImageClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   ConvNextVaBackbone(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_						)

								# 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 					=   ConvNextVaBackbone(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(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						)   ->			List[Any]:







								'''simple docstring'''

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






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







								'''simple docstring'''

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




@require_torch
class 	lowerCamelCase_       (				lowerCAmelCase__     ,     lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				(
					    (
					        ConvNextVaModel,
					        ConvNextVaForImageClassification,
					        ConvNextVaBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					__UpperCAmelCase            =				(
					    {"feature-extraction": ConvNextVaModel, "image-classification": ConvNextVaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False






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







								'''simple docstring'''

								__lowercase 					=   ConvNextVaModelTester(self						)
								__lowercase 					=   ConfigTester(self ,       config_class=snake_case_ ,       has_text_modality=snake_case_ ,       hidden_size=3_7						)






					def A      (				self						)   ->			List[str]:







								'''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						)   ->			Optional[int]:







								'''simple docstring'''

								return






					@unittest.skip(reason='''ConvNextV2 does not use inputs_embeds'''						)
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								pass






					@unittest.skip(reason='''ConvNextV2 does not support input and output embeddings'''						)
					def A      (				self						)   ->			Optional[int]:







								'''simple docstring'''

								pass






					@unittest.skip(reason='''ConvNextV2 does not use feedforward chunking'''						)
					def A      (				self						)   ->			Union[str, Any]:







								'''simple docstring'''

								pass






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								if not self.model_tester.is_training:
											return

								for model_class in self.all_model_classes:
											__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_with_labels()
											__lowercase 					=   True

											if model_class.__name__ in [
											    *get_values(snake_case_						),
											    *get_values(snake_case_						),
											]:
														continue

											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.train()
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											__lowercase 					=   model(**snake_case_						).loss
											loss.backward()






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







								'''simple docstring'''

								if not self.model_tester.is_training:
											return

								for model_class in self.all_model_classes:
											__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_with_labels()
											__lowercase 					=   False
											__lowercase 					=   True

											if (
											    model_class.__name__
											    in [*get_values(snake_case_						), *get_values(snake_case_						)]
											    or not model_class.supports_gradient_checkpointing
											):
														continue

											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.gradient_checkpointing_enable()
											model.train()
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											__lowercase 					=   model(**snake_case_						).loss
											loss.backward()






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()

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






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







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_						)






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







								'''simple docstring'''

								def check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						):
											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.eval()

											with torch.no_grad():
														__lowercase 					=   model(**self._prepare_for_class(snake_case_ ,       snake_case_						)						)

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

											__lowercase 					=   self.model_tester.num_stages
											self.assertEqual(len(snake_case_						) ,       expected_num_stages + 1						)

											# ConvNextV2'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(snake_case_ ,       snake_case_ ,       snake_case_						)

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

											check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						)






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







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case_						)






					@slow
					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   ConvNextVaModel.from_pretrained(snake_case_						)
											self.assertIsNotNone(snake_case_						)




def 		lowercase_  (     ):


			'''simple docstring'''







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





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



					'''simple docstring'''







					@cached_property
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								return AutoImageProcessor.from_pretrained('''facebook/convnextv2-tiny-1k-224'''						) if is_vision_available() else None






					@slow
					def A      (				self						)   ->			Optional[int]:







								'''simple docstring'''

								__lowercase 					=   ConvNextVaForImageClassification.from_pretrained('''facebook/convnextv2-tiny-1k-224'''						).to(snake_case_						)

								__lowercase 					=   self.default_image_processor
								__lowercase 					=   prepare_img()
								__lowercase 					=   preprocessor(images=snake_case_ ,       return_tensors='''pt'''						).to(snake_case_						)

								# forward pass
								with torch.no_grad():
											__lowercase 					=   model(**snake_case_						)

								# verify the logits
								__lowercase 					=   torch.Size((1, 1_0_0_0)						)
								self.assertEqual(outputs.logits.shape ,       snake_case_						)

								__lowercase 					=   torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6]						).to(snake_case_						)
								self.assertTrue(torch.allclose(outputs.logits[0, :3] ,       snake_case_ ,       atol=1e-4						)						)






from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)
@dataclass
class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42


try:
	if not (is_transformers_available() and is_torch_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
	from .pipeline_if import IFPipeline
	from .pipeline_if_imgaimg import IFImgaImgPipeline
	from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
	from .pipeline_if_inpainting import IFInpaintingPipeline
	from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
	from .pipeline_if_superresolution import IFSuperResolutionPipeline
	from .safety_checker import IFSafetyChecker
	from .watermark import IFWatermarker


