



import numpy as np
from PIL import Image






def      __lowercase       (			a__							,       a__							,       a__       )    ->			np.ndarray:
							__SCREAMING_SNAKE_CASE									= np.array(a__       )
							if arr.shape[0] != arr.shape[1]:
														raise ValueError('The input array is not a square matrix'       )
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0

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

							return updated_arr






def      __lowercase       (			a__							,       a__							,       a__       )    ->			np.ndarray:
							__SCREAMING_SNAKE_CASE									= np.array(a__       )
							if arr.shape[0] != arr.shape[1]:
														raise ValueError('The input array is not a square matrix'       )
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0

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

							return updated_arr


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

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

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











from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__		:					Optional[int]							={'''configuration_fnet''': ['''FNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FNetConfig''']}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__		:					Optional[int]							=['''FNetTokenizer''']

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__		:					Optional[Any]							=['''FNetTokenizerFast''']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__		:					Tuple							=[
			    '''FNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''FNetForMaskedLM''',
			    '''FNetForMultipleChoice''',
			    '''FNetForNextSentencePrediction''',
			    '''FNetForPreTraining''',
			    '''FNetForQuestionAnswering''',
			    '''FNetForSequenceClassification''',
			    '''FNetForTokenClassification''',
			    '''FNetLayer''',
			    '''FNetModel''',
			    '''FNetPreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_fnet import FNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FNetConfig

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_fnet import FNetTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_fnet_fast import FNetTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_fnet import (
						    FNET_PRETRAINED_MODEL_ARCHIVE_LIST,
						    FNetForMaskedLM,
						    FNetForMultipleChoice,
						    FNetForNextSentencePrediction,
						    FNetForPreTraining,
						    FNetForQuestionAnswering,
						    FNetForSequenceClassification,
						    FNetForTokenClassification,
						    FNetLayer,
						    FNetModel,
						    FNetPreTrainedModel,
						)


else:
			import sys

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






