



"""simple docstring"""






import numpy as np
from PIL import Image


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

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

			return updated_arr


def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case	)						->   np.ndarray:
			__lowerCAmelCase      :  Optional[int]												=       np.array(__snake_case	)
			if arr.shape[0] != arr.shape[1]:
						raise ValueError("The input array is not a square matrix"	)
			__lowerCAmelCase      :  Optional[int]												=       0
			__lowerCAmelCase      :  List[str]												=       0
			__lowerCAmelCase      :  Optional[int]												=       0
			__lowerCAmelCase      :  List[str]												=       0

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

			return updated_arr


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

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

	# Loading the image
	__snake_case							:   List[str]      =    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 _LazyModule


__snake_case							:   Optional[int]      =    {
    'config': [
        'EXTERNAL_DATA_FORMAT_SIZE_LIMIT',
        'OnnxConfig',
        'OnnxConfigWithPast',
        'OnnxSeq2SeqConfigWithPast',
        'PatchingSpec',
    ],
    'convert': ['export', 'validate_model_outputs'],
    'features': ['FeaturesManager'],
    'utils': ['ParameterFormat', 'compute_serialized_parameters_size'],
}


if TYPE_CHECKING:
	from .config import (
	    EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
	    OnnxConfig,
	    OnnxConfigWithPast,
	    OnnxSeqaSeqConfigWithPast,
	    PatchingSpec,
	)
	from .convert import export, validate_model_outputs
	from .features import FeaturesManager
	from .utils import ParameterFormat, compute_serialized_parameters_size

else:
	import sys

	__snake_case							:   Any      =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)