

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






			"""simple docstring"""




			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.02 ,				__UpperCamelCase=["stage2", "stage3", "stage4"] ,				__UpperCamelCase=[2, 3, 4] ,				__UpperCamelCase=None ,				):

				"""simple docstring"""


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

				"""simple docstring"""


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

				"""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=__UpperCamelCase ,				initializer_range=self.initializer_range ,				out_features=self.out_features ,				out_indices=self.out_indices ,				num_labels=self.num_labels ,				)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


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

				"""simple docstring"""


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

				"""simple docstring"""


				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 SCREAMING_SNAKE_CASE  (		__snake_case							,						__snake_case							,						unittest.TestCase							):






			"""simple docstring"""




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

			__A						  =  False
			__A						  =  False
			__A						  =  False
			__A						  =  False
			__A						  =  False


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= ConvNextVaModelTester(self							)
				snake_case_      		= ConfigTester(self ,				config_class=__UpperCamelCase ,				has_text_modality=__UpperCamelCase ,				hidden_size=37							)


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

				"""simple docstring"""


				return


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

				"""simple docstring"""


				pass


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

				"""simple docstring"""


				pass


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

				"""simple docstring"""


				pass


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


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

				"""simple docstring"""


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

				"""simple docstring"""


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

				"""simple docstring"""


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


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


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

				"""simple docstring"""


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







			@slow
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


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







def a():





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






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






			"""simple docstring"""




			@cached_property
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


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







			@slow
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				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, 10_00)							)
				self.assertEqual(outputs.logits.shape ,				__UpperCamelCase							)

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



# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


A											=     '3'

print('Python version:', sys.version)

print('OS platform:', platform.platform())
print('OS architecture:', platform.machine())

try:
		import torch

		print('Torch version:', torch.__version__)
		print('Cuda available:', torch.cuda.is_available())
		print('Cuda version:', torch.version.cuda)
		print('CuDNN version:', torch.backends.cudnn.version())
		print('Number of GPUs available:', torch.cuda.device_count())
except ImportError:
		print('Torch version:', None)

try:
		import transformers

		print('transformers version:', transformers.__version__)
except ImportError:
		print('transformers version:', None)
