
import numpy as np
from PIL import Image





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       ):
				lowerCamelCase_         =     np.array(lowerCamelCase__       )
				if arr.shape[0] != arr.shape[1]:
								raise ValueError("The input array is not a square matrix"       )
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0

				# compute the shape of the output matrix
				lowerCamelCase_         =     (arr.shape[0] - size) // stride + 1
				# initialize the output matrix with zeros of shape maxpool_shape
				lowerCamelCase_         =     np.zeros((maxpool_shape, maxpool_shape)       )

				while i < arr.shape[0]:
								if i + size > arr.shape[0]:
												# if the end of the matrix is reached, break
												break
								while j < arr.shape[1]:
												# if the end of the matrix is reached, break
												if j + size > arr.shape[1]:
																break
												# compute the maximum of the pooling matrix
												lowerCamelCase_         =     np.max(arr[i : i + size, j : j + size]       )
												# shift the pooling matrix by stride of column pixels
												j += stride
												mat_j += 1

								# shift the pooling matrix by stride of row pixels
								i += stride
								mat_i += 1

								# reset the column index to 0
								lowerCamelCase_         =     0
								lowerCamelCase_         =     0

				return updated_arr





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       ):
				lowerCamelCase_         =     np.array(lowerCamelCase__       )
				if arr.shape[0] != arr.shape[1]:
								raise ValueError("The input array is not a square matrix"       )
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0
				lowerCamelCase_         =     0

				# compute the shape of the output matrix
				lowerCamelCase_         =     (arr.shape[0] - size) // stride + 1
				# initialize the output matrix with zeros of shape avgpool_shape
				lowerCamelCase_         =     np.zeros((avgpool_shape, avgpool_shape)       )

				while i < arr.shape[0]:
								# if the end of the matrix is reached, break
								if i + size > arr.shape[0]:
												break
								while j < arr.shape[1]:
												# if the end of the matrix is reached, break
												if j + size > arr.shape[1]:
																break
												# compute the average of the pooling matrix
												lowerCamelCase_         =     int(np.average(arr[i : i + size, j : j + size]       )       )
												# shift the pooling matrix by stride of column pixels
												j += stride
												mat_j += 1

								# shift the pooling matrix by stride of row pixels
								i += stride
								mat_i += 1
								# reset the column index to 0
								lowerCamelCase_         =     0
								lowerCamelCase_         =     0

				return updated_arr


# Main Function
if __name__ == "__main__":
			from doctest import testmod

			testmod(name='''avgpooling''', verbose=True)

			# Loading the image
			__A							=Image.open('''path_to_image''')

			# Converting the image to numpy array and maxpooling, displaying the result
			# Ensure that the image is a square matrix

			Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

			# Converting the image to numpy array and averagepooling, displaying the result
			# Ensure that the image is a square matrix

			Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()




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



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



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					lowerCamelCase_         =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

					lowerCamelCase_         =     self.get_config()
					return config, pixel_values, labels



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



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			Tuple:
					lowerCamelCase_         =     ConvNextModel(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)
					# 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        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextForImageClassification(lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase		,    labels=lowercase					)
					self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)					)



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# 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_         =     None
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# 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        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					lowerCamelCase_         =     self.prepare_config_and_inputs()
					lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     config_and_inputs
					lowerCamelCase_         =     {"pixel_values": pixel_values}
					return config, inputs_dict




@require_torch
class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					(
	    (
	        ConvNextModel,
	        ConvNextForImageClassification,
	        ConvNextBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase__   =					(
	    {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowerCAmelCase__   =					True
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     ConvNextModelTester(self					)
					lowerCamelCase_         =     ConfigTester(self		,    config_class=lowercase		,    has_text_modality=lowercase		,    hidden_size=37					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, 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        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					return



	@unittest.skip(reason="ConvNext does not use inputs_embeds"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					pass



	@unittest.skip(reason="ConvNext does not support input and output embeddings"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					pass



	@unittest.skip(reason="ConvNext does not use feedforward chunking"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

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

									lowerCamelCase_         =     ["pixel_values"]
									self.assertListEqual(arg_names[:1]		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					def check_hidden_states_output(lowercase		,    lowercase		,    lowercase					):
									lowerCamelCase_         =     model_class(lowercase					)
									model.to(lowercase					)
									model.eval()

									with torch.no_grad():
													lowerCamelCase_         =     model(**self._prepare_for_class(lowercase		,    lowercase					)					)

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

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

					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowerCamelCase_         =     True
									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)

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

									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			str:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase					)



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowerCamelCase_         =     ConvNextModel.from_pretrained(lowercase					)
									self.assertIsNotNone(lowercase					)





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




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



	@cached_property
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					return AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224"					) if is_vision_available() else None



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"					).to(lowercase					)

					lowerCamelCase_         =     self.default_image_processor
					lowerCamelCase_         =     prepare_img()
					lowerCamelCase_         =     image_processor(images=lowercase		,    return_tensors="pt"					).to(lowercase					)

					# forward pass
					with torch.no_grad():
									lowerCamelCase_         =     model(**lowercase					)

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

					lowerCamelCase_         =     torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]					).to(lowercase					)

					self.assertTrue(torch.allclose(outputs.logits[0, :3]		,    lowercase		,    atol=1e-4					)					)




@require_torch
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase     ,			snake_case_		):
	lowerCAmelCase__   =					(ConvNextBackbone,) if is_torch_available() else ()
	lowerCAmelCase__   =					ConvNextConfig

	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextModelTester(self					)


