
import numpy as np
from PIL import Image



def    _lowercase       (   __SCREAMING_SNAKE_CASE					,     __SCREAMING_SNAKE_CASE					,     __SCREAMING_SNAKE_CASE			)						->  str:
			UpperCamelCase__     :		int	 =					np.array(UpperCamelCase__			)
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('The input array is not a square matrix'			)
			UpperCamelCase__     :		int	 =					0
			UpperCamelCase__     :		Optional[int]	 =					0
			UpperCamelCase__     :		Union[str, Any]	 =					0
			UpperCamelCase__     :		str	 =					0

			# compute the shape of the output matrix
			UpperCamelCase__     :		Union[str, Any]	 =					(arr.shape[0] - size) // stride + 1
			# initialize the output matrix with zeros of shape maxpool_shape
			UpperCamelCase__     :		Tuple	 =					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
									UpperCamelCase__     :		int	 =					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
						UpperCamelCase__     :		Tuple	 =					0
						UpperCamelCase__     :		List[str]	 =					0

			return updated_arr



def    _lowercase       (   __SCREAMING_SNAKE_CASE					,     __SCREAMING_SNAKE_CASE					,     __SCREAMING_SNAKE_CASE			)						->  int:
			UpperCamelCase__     :		Any	 =					np.array(UpperCamelCase__			)
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('The input array is not a square matrix'			)
			UpperCamelCase__     :		Union[str, Any]	 =					0
			UpperCamelCase__     :		List[Any]	 =					0
			UpperCamelCase__     :		Union[str, Any]	 =					0
			UpperCamelCase__     :		List[Any]	 =					0

			# compute the shape of the output matrix
			UpperCamelCase__     :		Optional[Any]	 =					(arr.shape[0] - size) // stride + 1
			# initialize the output matrix with zeros of shape avgpool_shape
			UpperCamelCase__     :		str	 =					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
									UpperCamelCase__     :		Optional[Any]	 =					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
						UpperCamelCase__     :		Any	 =					0
						UpperCamelCase__     :		Optional[int]	 =					0

			return updated_arr


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

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

							# Loading the image
							UpperCAmelCase__					:	Any							       =					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()







'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase_			:  Optional[Any]										=   {
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Any										=   [
     'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'AdaptiveEmbedding',
     'TransfoXLForSequenceClassification',
     'TransfoXLLMHeadModel',
     'TransfoXLModel',
     'TransfoXLPreTrainedModel',
     'load_tf_weights_in_transfo_xl',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Optional[Any]										=   [
     'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFAdaptiveEmbedding',
     'TFTransfoXLForSequenceClassification',
     'TFTransfoXLLMHeadModel',
     'TFTransfoXLMainLayer',
     'TFTransfoXLModel',
     'TFTransfoXLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_transfo_xl import (
      TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      AdaptiveEmbedding,
      TransfoXLForSequenceClassification,
      TransfoXLLMHeadModel,
      TransfoXLModel,
      TransfoXLPreTrainedModel,
      load_tf_weights_in_transfo_xl,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_transfo_xl import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAdaptiveEmbedding,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLMainLayer,
      TFTransfoXLModel,
      TFTransfoXLPreTrainedModel,
  )

else:
 import sys

 UpperCAmelCase_			:  Optional[int]										=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






