





'''simple docstring'''




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 				__snake_case     :





	def __init__(		self      ,       UpperCamelCase_      ,       UpperCamelCase_=13      ,       UpperCamelCase_=32      ,       UpperCamelCase_=3      ,       UpperCamelCase_=4      ,       UpperCamelCase_=[10, 20, 30, 40]      ,       UpperCamelCase_=[2, 2, 3, 2]      ,       UpperCamelCase_=True      ,       UpperCamelCase_=True      ,       UpperCamelCase_=37      ,       UpperCamelCase_="gelu"      ,       UpperCamelCase_=10      ,       UpperCamelCase_=0.0_2      ,       UpperCamelCase_=["stage2", "stage3", "stage4"]      ,       UpperCamelCase_=[2, 3, 4]      ,       UpperCamelCase_=None      ,       )      ->		Tuple:
		snake_case__	       =   parent
		snake_case__	       =   batch_size
		snake_case__	       =   image_size
		snake_case__	       =   num_channels
		snake_case__	       =   num_stages
		snake_case__	       =   hidden_sizes
		snake_case__	       =   depths
		snake_case__	       =   is_training
		snake_case__	       =   use_labels
		snake_case__	       =   intermediate_size
		snake_case__	       =   hidden_act
		snake_case__	       =   num_labels
		snake_case__	       =   initializer_range
		snake_case__	       =   out_features
		snake_case__	       =   out_indices
		snake_case__	       =   scope





	def   _snake_case   (		self		)      ->		int:
		snake_case__	       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

		snake_case__	       =   self.get_config()

		return config, pixel_values, labels





	def   _snake_case   (		self		)      ->		List[Any]:
		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=UpperCamelCase_      ,       initializer_range=self.initializer_range      ,       out_features=self.out_features      ,       out_indices=self.out_indices      ,       num_labels=self.num_labels      ,       )





	def   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		List[str]:
		snake_case__	       =   ConvNextVaModel(config=UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_		)
		# 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   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		str:
		snake_case__	       =   ConvNextVaForImageClassification(UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_      ,       labels=UpperCamelCase_		)
		self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)		)





	def   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		Union[str, Any]:
		snake_case__	       =   ConvNextVaBackbone(config=UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_		)

		# 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
		snake_case__	       =   None
		snake_case__	       =   ConvNextVaBackbone(config=UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_		)

		# 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   _snake_case   (		self		)      ->		List[str]:
		snake_case__	       =   self.prepare_config_and_inputs()
		snake_case__       ,  snake_case__       ,  snake_case__	       =   config_and_inputs
		snake_case__	       =   {'pixel_values': pixel_values}
		return config, inputs_dict





	def   _snake_case   (		self		)      ->		List[Any]:
		snake_case__	       =   self.prepare_config_and_inputs()
		snake_case__       ,  snake_case__       ,  snake_case__	       =   config_and_inputs
		snake_case__	       =   {'pixel_values': pixel_values, 'labels': labels}
		return config, inputs_dict






@require_torch
class 				__snake_case     (					__magic_name__       ,       __magic_name__       ,       unittest.TestCase							):
	__lowerCAmelCase       						=  (
	    (
	        ConvNextVaModel,
	        ConvNextVaForImageClassification,
	        ConvNextVaBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	__lowerCAmelCase       						=  (
	    {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
	    if is_torch_available()
	    else {}
	)

	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False





	def   _snake_case   (		self		)      ->		Tuple:
		snake_case__	       =   ConvNextVaModelTester(self		)
		snake_case__	       =   ConfigTester(self      ,       config_class=UpperCamelCase_      ,       has_text_modality=UpperCamelCase_      ,       hidden_size=37		)





	def   _snake_case   (		self		)      ->		List[Any]:
		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   _snake_case   (		self		)      ->		Dict:
		return





	@unittest.skip(reason='ConvNextV2 does not use inputs_embeds'		)
	def   _snake_case   (		self		)      ->		int:
		pass





	@unittest.skip(reason='ConvNextV2 does not support input and output embeddings'		)
	def   _snake_case   (		self		)      ->		Tuple:
		pass





	@unittest.skip(reason='ConvNextV2 does not use feedforward chunking'		)
	def   _snake_case   (		self		)      ->		Optional[Any]:
		pass





	def   _snake_case   (		self		)      ->		Tuple:
		if not self.model_tester.is_training:
			return

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

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

			snake_case__	       =   model_class(UpperCamelCase_		)
			model.to(UpperCamelCase_		)
			model.train()
			snake_case__	       =   self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_      ,       return_labels=UpperCamelCase_		)
			snake_case__	       =   model(**UpperCamelCase_		).loss
			loss.backward()





	def   _snake_case   (		self		)      ->		str:
		if not self.model_tester.is_training:
			return

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

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

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





	def   _snake_case   (		self		)      ->		Optional[Any]:
		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()

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

			snake_case__	       =   ['pixel_values']
			self.assertListEqual(arg_names[:1]      ,       UpperCamelCase_		)





	def   _snake_case   (		self		)      ->		List[str]:
		snake_case__	       =   self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*UpperCamelCase_		)





	def   _snake_case   (		self		)      ->		Union[str, Any]:
		def check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		):
			snake_case__	       =   model_class(UpperCamelCase_		)
			model.to(UpperCamelCase_		)
			model.eval()

			with torch.no_grad():
				snake_case__	       =   model(**self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_		)		)

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

			snake_case__	       =   self.model_tester.num_stages
			self.assertEqual(len(UpperCamelCase_		)      ,       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]      ,       )

		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			snake_case__	       =   True
			check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)

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

			check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)





	def   _snake_case   (		self		)      ->		Optional[Any]:
		snake_case__	       =   self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_		)





	@slow
	def   _snake_case   (		self		)      ->		Union[str, Any]:
		for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			snake_case__	       =   ConvNextVaModel.from_pretrained(UpperCamelCase_		)
			self.assertIsNotNone(UpperCamelCase_		)





def 						__lowerCamelCase			(	)   ->List[Any]:
	snake_case__	       =   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
	return image







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





	@cached_property
	def   _snake_case   (		self		)      ->		Dict:
		return AutoImageProcessor.from_pretrained('facebook/convnextv2-tiny-1k-224'		) if is_vision_available() else None





	@slow
	def   _snake_case   (		self		)      ->		int:
		snake_case__	       =   ConvNextVaForImageClassification.from_pretrained('facebook/convnextv2-tiny-1k-224'		).to(UpperCamelCase_		)

		snake_case__	       =   self.default_image_processor
		snake_case__	       =   prepare_img()
		snake_case__	       =   preprocessor(images=UpperCamelCase_      ,       return_tensors='pt'		).to(UpperCamelCase_		)

		# forward pass
		with torch.no_grad():
			snake_case__	       =   model(**UpperCamelCase_		)

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

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










'''simple docstring'''




from typing import List, Optional, Tuple, Union

import torch

from ...schedulers import DDIMScheduler
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput






class 				__snake_case     (					__magic_name__							):





	def __init__(		self      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		int:
		super().__init__()

		# make sure scheduler can always be converted to DDIM
		snake_case__	       =   DDIMScheduler.from_config(scheduler.config		)

		self.register_modules(unet=UpperCamelCase_      ,       scheduler=UpperCamelCase_		)





	@torch.no_grad()
	def __call__(		self      ,       UpperCamelCase_ = 1      ,       UpperCamelCase_ = None      ,       UpperCamelCase_ = 0.0      ,       UpperCamelCase_ = 50      ,       UpperCamelCase_ = None      ,       UpperCamelCase_ = "pil"      ,       UpperCamelCase_ = True      ,       )      ->		Union[ImagePipelineOutput, Tuple]:

		# Sample gaussian noise to begin loop
		if isinstance(self.unet.config.sample_size      ,       UpperCamelCase_		):
			snake_case__	       =   (
			    batch_size,
			    self.unet.config.in_channels,
			    self.unet.config.sample_size,
			    self.unet.config.sample_size,
			)
		else:
			snake_case__	       =   (batch_size, self.unet.config.in_channels, *self.unet.config.sample_size)

		if isinstance(UpperCamelCase_      ,       UpperCamelCase_		) and len(UpperCamelCase_		) != batch_size:
			raise ValueError(
			    F'''You have passed a list of generators of length {len(UpperCamelCase_		)}, but requested an effective batch'''
			    F''' size of {batch_size}. Make sure the batch size matches the length of the generators.'''		)

		snake_case__	       =   randn_tensor(UpperCamelCase_      ,       generator=UpperCamelCase_      ,       device=self.device      ,       dtype=self.unet.dtype		)

		# set step values
		self.scheduler.set_timesteps(UpperCamelCase_		)

		for t in self.progress_bar(self.scheduler.timesteps		):
			# 1. predict noise model_output
			snake_case__	       =   self.unet(UpperCamelCase_      ,       UpperCamelCase_		).sample

			# 2. predict previous mean of image x_t-1 and add variance depending on eta
			# eta corresponds to η in paper and should be between [0, 1]
			# do x_t -> x_t-1
			snake_case__	       =   self.scheduler.step(
			    UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       eta=UpperCamelCase_      ,       use_clipped_model_output=UpperCamelCase_      ,       generator=UpperCamelCase_		).prev_sample

		snake_case__	       =   (image / 2 + 0.5).clamp(0      ,       1		)
		snake_case__	       =   image.cpu().permute(0      ,       2      ,       3      ,       1		).numpy()
		if output_type == "pil":
			snake_case__	       =   self.numpy_to_pil(UpperCamelCase_		)

		if not return_dict:
			return (image,)

		return ImagePipelineOutput(images=UpperCamelCase_		)



