
"""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 			A__	:

		def __init__(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=13	,		_SCREAMING_SNAKE_CASE=32	,		_SCREAMING_SNAKE_CASE=3	,		_SCREAMING_SNAKE_CASE=4	,		_SCREAMING_SNAKE_CASE=[10, 20, 30, 40]	,		_SCREAMING_SNAKE_CASE=[2, 2, 3, 2]	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=37	,		_SCREAMING_SNAKE_CASE="gelu"	,		_SCREAMING_SNAKE_CASE=10	,		_SCREAMING_SNAKE_CASE=0.02	,		_SCREAMING_SNAKE_CASE=["stage2", "stage3", "stage4"]	,		_SCREAMING_SNAKE_CASE=[2, 3, 4]	,		_SCREAMING_SNAKE_CASE=None	,		):
			__lowerCAmelCase      :						Any						      =				parent
			__lowerCAmelCase      :						Optional[int]						      =				batch_size
			__lowerCAmelCase      :						Dict						      =				image_size
			__lowerCAmelCase      :						Optional[Any]						      =				num_channels
			__lowerCAmelCase      :						Tuple						      =				num_stages
			__lowerCAmelCase      :						List[str]						      =				hidden_sizes
			__lowerCAmelCase      :						int						      =				depths
			__lowerCAmelCase      :						List[Any]						      =				is_training
			__lowerCAmelCase      :						int						      =				use_labels
			__lowerCAmelCase      :						Dict						      =				intermediate_size
			__lowerCAmelCase      :						List[Any]						      =				hidden_act
			__lowerCAmelCase      :						Optional[Any]						      =				num_labels
			__lowerCAmelCase      :						int						      =				initializer_range
			__lowerCAmelCase      :						str						      =				out_features
			__lowerCAmelCase      :						Tuple						      =				out_indices
			__lowerCAmelCase      :						Optional[int]						      =				scope

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[int]						      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

			__lowerCAmelCase      :						List[Any]						      =				None
			if self.use_labels:
				__lowerCAmelCase      :						str						      =				ids_tensor([self.batch_size]	,		self.num_labels			)

			__lowerCAmelCase      :						Union[str, Any]						      =				self.get_config()

			return config, pixel_values, labels

		def 							__lowerCamelCase							(				self			):
			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=_SCREAMING_SNAKE_CASE	,		initializer_range=self.initializer_range	,		out_features=self.out_features	,		out_indices=self.out_indices	,		num_labels=self.num_labels	,		)

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
			__lowerCAmelCase      :						List[str]						      =				ConvNextVaModel(config=_SCREAMING_SNAKE_CASE			)
			model.to(_SCREAMING_SNAKE_CASE			)
			model.eval()
			__lowerCAmelCase      :						Any						      =				model(_SCREAMING_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 // 32, self.image_size // 32)	,		)

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
			__lowerCAmelCase      :						List[Any]						      =				ConvNextVaForImageClassification(_SCREAMING_SNAKE_CASE			)
			model.to(_SCREAMING_SNAKE_CASE			)
			model.eval()
			__lowerCAmelCase      :						int						      =				model(_SCREAMING_SNAKE_CASE	,		labels=_SCREAMING_SNAKE_CASE			)
			self.parent.assertEqual(result.logits.shape	,		(self.batch_size, self.num_labels)			)

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
			__lowerCAmelCase      :						Union[str, Any]						      =				ConvNextVaBackbone(config=_SCREAMING_SNAKE_CASE			)
			model.to(_SCREAMING_SNAKE_CASE			)
			model.eval()
			__lowerCAmelCase      :						Optional[int]						      =				model(_SCREAMING_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
			__lowerCAmelCase      :						Optional[Any]						      =				None
			__lowerCAmelCase      :						List[Any]						      =				ConvNextVaBackbone(config=_SCREAMING_SNAKE_CASE			)
			model.to(_SCREAMING_SNAKE_CASE			)
			model.eval()
			__lowerCAmelCase      :						Dict						      =				model(_SCREAMING_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 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				self.prepare_config_and_inputs()
			__lowerCAmelCase      ,       __lowerCAmelCase      ,       __lowerCAmelCase      :						Any						      =				config_and_inputs
			__lowerCAmelCase      :						Any						      =				{'pixel_values': pixel_values}
			return config, inputs_dict







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				self.prepare_config_and_inputs()
			__lowerCAmelCase      ,       __lowerCAmelCase      ,       __lowerCAmelCase      :						Any						      =				config_and_inputs
			__lowerCAmelCase      :						List[Any]						      =				{'pixel_values': pixel_values, 'labels': labels}
			return config, inputs_dict




@require_torch
class 			A__	(     _lowerCamelCase	,					_lowerCamelCase	,					unittest.TestCase):
		A_						:	Any           =     (
		    (
		        ConvNextVaModel,
		        ConvNextVaForImageClassification,
		        ConvNextVaBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		A_						:	str           =     (
		    {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
		    if is_torch_available()
		    else {}
		)

		A_						:	List[str]           =     False
		A_						:	Tuple           =     False
		A_						:	List[Any]           =     False
		A_						:	Tuple           =     False
		A_						:	Tuple           =     False

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						int						      =				ConvNextVaModelTester(self			)
			__lowerCAmelCase      :						Union[str, Any]						      =				ConfigTester(self	,		config_class=_SCREAMING_SNAKE_CASE	,		has_text_modality=_SCREAMING_SNAKE_CASE	,		hidden_size=37			)

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

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

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

		@unittest.skip(reason='ConvNextV2 does not use feedforward chunking'			)
		def 							__lowerCamelCase							(				self			):
			pass

		def 							__lowerCamelCase							(				self			):
			if not self.model_tester.is_training:
				return

			for model_class in self.all_model_classes:
				__lowerCAmelCase      ,       __lowerCAmelCase      :						List[Any]						      =				self.model_tester.prepare_config_and_inputs_with_labels()
				__lowerCAmelCase      :						str						      =				True

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

				__lowerCAmelCase      :						str						      =				model_class(_SCREAMING_SNAKE_CASE			)
				model.to(_SCREAMING_SNAKE_CASE			)
				model.train()
				__lowerCAmelCase      :						Tuple						      =				self._prepare_for_class(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_labels=_SCREAMING_SNAKE_CASE			)
				__lowerCAmelCase      :						Optional[Any]						      =				model(**_SCREAMING_SNAKE_CASE			).loss
				loss.backward()

		def 							__lowerCamelCase							(				self			):
			if not self.model_tester.is_training:
				return

			for model_class in self.all_model_classes:
				__lowerCAmelCase      ,       __lowerCAmelCase      :						Optional[Any]						      =				self.model_tester.prepare_config_and_inputs_with_labels()
				__lowerCAmelCase      :						List[Any]						      =				False
				__lowerCAmelCase      :						Dict						      =				True

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

				__lowerCAmelCase      :						Dict						      =				model_class(_SCREAMING_SNAKE_CASE			)
				model.to(_SCREAMING_SNAKE_CASE			)
				model.gradient_checkpointing_enable()
				model.train()
				__lowerCAmelCase      :						Any						      =				self._prepare_for_class(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		return_labels=_SCREAMING_SNAKE_CASE			)
				__lowerCAmelCase      :						Optional[int]						      =				model(**_SCREAMING_SNAKE_CASE			).loss
				loss.backward()

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      ,       __lowerCAmelCase      :						int						      =				self.model_tester.prepare_config_and_inputs_for_common()

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

				__lowerCAmelCase      :						List[str]						      =				['pixel_values']
				self.assertListEqual(arg_names[:1]	,		_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			def check_hidden_states_output(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
				__lowerCAmelCase      :						Optional[int]						      =				model_class(_SCREAMING_SNAKE_CASE			)
				model.to(_SCREAMING_SNAKE_CASE			)
				model.eval()

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

				__lowerCAmelCase      :						Optional[Any]						      =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

				__lowerCAmelCase      :						Optional[int]						      =				self.model_tester.num_stages
				self.assertEqual(len(_SCREAMING_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]	,		)

			__lowerCAmelCase      ,       __lowerCAmelCase      :						Optional[int]						      =				self.model_tester.prepare_config_and_inputs_for_common()

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

				# check that output_hidden_states also work using config
				del inputs_dict["output_hidden_states"]
				__lowerCAmelCase      :						Dict						      =				True

				check_hidden_states_output(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE			)







		@slow
		def 							__lowerCamelCase							(				self			):
			for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				__lowerCAmelCase      :						Union[str, Any]						      =				ConvNextVaModel.from_pretrained(_SCREAMING_SNAKE_CASE			)
				self.assertIsNotNone(_SCREAMING_SNAKE_CASE			)



def    __lowerCAmelCase    ():
	__lowerCAmelCase      :						Dict						      =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
	return image




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

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







		@slow
		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[int]						      =				ConvNextVaForImageClassification.from_pretrained('facebook/convnextv2-tiny-1k-224'			).to(_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Optional[Any]						      =				self.default_image_processor
			__lowerCAmelCase      :						Dict						      =				prepare_img()
			__lowerCAmelCase      :						str						      =				preprocessor(images=_SCREAMING_SNAKE_CASE	,		return_tensors='pt'			).to(_SCREAMING_SNAKE_CASE			)

			# forward pass
			with torch.no_grad():
				__lowerCAmelCase      :						Optional[Any]						      =				model(**_SCREAMING_SNAKE_CASE			)

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

			__lowerCAmelCase      :						str						      =				torch.tensor([0.9996, 0.1966, -0.4386]			).to(_SCREAMING_SNAKE_CASE			)
			self.assertTrue(torch.allclose(outputs.logits[0, :3]	,		_SCREAMING_SNAKE_CASE	,		atol=1E-4			)			)

"""simple docstring"""







lowerCamelCase__        =		"""0.21.0"""

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
							from .utils import rich