





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     :
			'''simple docstring'''




			def __init__(     self  :       int				,      __lowerCAmelCase  :       Tuple				,      __lowerCAmelCase  :       Dict=13				,      __lowerCAmelCase  :       Optional[Any]=32				,      __lowerCAmelCase  :       str=3				,      __lowerCAmelCase  :       Optional[int]=4				,      __lowerCAmelCase  :       Dict=[10, 20, 30, 40]				,      __lowerCAmelCase  :       Dict=[2, 2, 3, 2]				,      __lowerCAmelCase  :       Optional[Any]=True				,      __lowerCAmelCase  :       Any=True				,      __lowerCAmelCase  :       List[str]=37				,      __lowerCAmelCase  :       Optional[Any]="gelu"				,      __lowerCAmelCase  :       str=10				,      __lowerCAmelCase  :       List[Any]=0.0_2				,      __lowerCAmelCase  :       int=["stage2", "stage3", "stage4"]				,      __lowerCAmelCase  :       Union[str, Any]=[2, 3, 4]				,      __lowerCAmelCase  :       List[str]=None				,      )      ->      Any:







					"""simple docstring"""






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






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







					"""simple docstring"""






					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  :       List[Any]  )      ->      Tuple:







					"""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  :       str				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       Optional[int]				,      __lowerCAmelCase  :       Dict  )      ->      Optional[int]:







					"""simple docstring"""






					A__     =  ConvNextModel(config=__lowerCAmelCase  )
					model.to(__lowerCAmelCase  )
					model.eval()
					A__     =  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  :       str				,      __lowerCAmelCase  :       List[str]				,      __lowerCAmelCase  :       Optional[Any]				,      __lowerCAmelCase  :       Dict  )      ->      List[str]:







					"""simple docstring"""






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






			def   a_			(     self  :       Dict				,      __lowerCAmelCase  :       Dict				,      __lowerCAmelCase  :       Tuple				,      __lowerCAmelCase  :       Optional[int]  )      ->      Optional[Any]:







					"""simple docstring"""






					A__     =  ConvNextBackbone(config=__lowerCAmelCase  )
					model.to(__lowerCAmelCase  )
					model.eval()
					A__     =  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
					A__     =  None
					A__     =  ConvNextBackbone(config=__lowerCAmelCase  )
					model.to(__lowerCAmelCase  )
					model.eval()
					A__     =  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  :       int  )      ->      Any:







					"""simple docstring"""






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


@require_torch
class     A     (SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	unittest.TestCase       ):
			'''simple docstring'''




			__lowerCamelCase      :			str							     =       (
			    (
			        ConvNextModel,
			        ConvNextForImageClassification,
			        ConvNextBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__lowerCamelCase      :			Union[str, Any]							     =       (
			    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
			    if is_torch_available()
			    else {}
			)

			__lowerCamelCase      :			Optional[int]							     =       True
			__lowerCamelCase      :			Union[str, Any]							     =       False
			__lowerCamelCase      :			Tuple							     =       False
			__lowerCamelCase      :			Any							     =       False
			__lowerCamelCase      :			Optional[int]							     =       False






			def   a_			(     self  :       Dict  )      ->      Dict:







					"""simple docstring"""






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






			def   a_			(     self  :       int  )      ->      Any:







					"""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  :       Any  )      ->      str:







					"""simple docstring"""






					return






			@unittest.skip(reason="""ConvNext does not use inputs_embeds"""  )
			def   a_			(     self  :       Optional[Any]  )      ->      Tuple:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""ConvNext does not support input and output embeddings"""  )
			def   a_			(     self  :       Any  )      ->      Tuple:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""ConvNext does not use feedforward chunking"""  )
			def   a_			(     self  :       Any  )      ->      str:







					"""simple docstring"""






					pass






			def   a_			(     self  :       int  )      ->      int:







					"""simple docstring"""






					A__ ,     A__     =  self.model_tester.prepare_config_and_inputs_for_common()

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

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






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







					"""simple docstring"""






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






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







					"""simple docstring"""






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






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







					"""simple docstring"""






					def check_hidden_states_output(__lowerCAmelCase  :       int				,      __lowerCAmelCase  :       Tuple				,      __lowerCAmelCase  :       Any  ):
							A__     =  model_class(__lowerCAmelCase  )
							model.to(__lowerCAmelCase  )
							model.eval()

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

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

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

					A__ ,     A__     =  self.model_tester.prepare_config_and_inputs_for_common()

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

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

							check_hidden_states_output(__lowerCAmelCase				,      __lowerCAmelCase				,      __lowerCAmelCase  )






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







					"""simple docstring"""






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







			@slow
			def   a_			(     self  :       Optional[Any]  )      ->      List[str]:







					"""simple docstring"""






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







def   __lowerCamelCase   (				)						->							str:






		"""simple docstring"""

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


@require_torch
@require_vision
class     A     (unittest.TestCase       ):
			'''simple docstring'''




			@cached_property
			def   a_			(     self  :       Union[str, Any]  )      ->      int:







					"""simple docstring"""






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







			@slow
			def   a_			(     self  :       int  )      ->      List[Any]:







					"""simple docstring"""






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

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

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

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

					A__     =  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  ,	SCREAMING_SNAKE_CASE       ):
			'''simple docstring'''




			__lowerCamelCase      :			str							     =       (ConvNextBackbone,) if is_torch_available() else ()
			__lowerCamelCase      :			Optional[int]							     =       ConvNextConfig

			__lowerCamelCase      :			Optional[Any]							     =       False






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







					"""simple docstring"""






					A__     =  ConvNextModelTester(self  )










import argparse

from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection

from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline


if __name__ == "__main__":
					A       :   List[Any]					= argparse.ArgumentParser()

					parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')

					parser.add_argument(
					    '''--txt2img_unclip''',
					    default='''kakaobrain/karlo-v1-alpha''',
					    type=str,
					    required=False,
					    help='''The pretrained txt2img unclip.''',
					)

					A       :   List[Any]					= parser.parse_args()

					A       :   int					= UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)

					A       :   Tuple					= CLIPImageProcessor()
					A       :   int					= CLIPVisionModelWithProjection.from_pretrained('''openai/clip-vit-large-patch14''')

					A       :   Tuple					= UnCLIPImageVariationPipeline(
					    decoder=txtaimg.decoder,
					    text_encoder=txtaimg.text_encoder,
					    tokenizer=txtaimg.tokenizer,
					    text_proj=txtaimg.text_proj,
					    feature_extractor=feature_extractor,
					    image_encoder=image_encoder,
					    super_res_first=txtaimg.super_res_first,
					    super_res_last=txtaimg.super_res_last,
					    decoder_scheduler=txtaimg.decoder_scheduler,
					    super_res_scheduler=txtaimg.super_res_scheduler,
					)

					imgaimg.save_pretrained(args.dump_path)



