

import numpy as np
from PIL import Image






def 					lowerCamelCase_     (							UpperCAmelCase_							:     np.ndarray							,       UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				np.ndarray:




	'''simple docstring'''




	_UpperCamelCase   :		Any			=						np.array(UpperCAmelCase_	)
	if arr.shape[0] != arr.shape[1]:
		raise ValueError('The input array is not a square matrix'	)
	_UpperCamelCase   :		List[str]			=						0
	_UpperCamelCase   :		str			=						0
	_UpperCamelCase   :		int			=						0
	_UpperCamelCase   :		Tuple			=						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 maxpool_shape
	_UpperCamelCase   :		List[Any]			=						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   :		Dict			=						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   :		int			=						0
		_UpperCamelCase   :		Optional[Any]			=						0

	return updated_arr






def 					lowerCamelCase_     (							UpperCAmelCase_							:     np.ndarray							,       UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				np.ndarray:




	'''simple docstring'''




	_UpperCamelCase   :		Tuple			=						np.array(UpperCAmelCase_	)
	if arr.shape[0] != arr.shape[1]:
		raise ValueError('The input array is not a square matrix'	)
	_UpperCamelCase   :		Any			=						0
	_UpperCamelCase   :		List[Any]			=						0
	_UpperCamelCase   :		Optional[int]			=						0
	_UpperCamelCase   :		Optional[Any]			=						0

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

	return updated_arr


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

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

							# Loading the image
							lowerCAmelCase__								=		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 logging

from transformers.configuration_utils import PretrainedConfig


lowerCAmelCase__								=		logging.getLogger(__name__)







class 	lowercase    (				_lowercase							):


		"""simple docstring"""




		a__					       =  "masked_bert"


		def __init__(				self	,       __snake_case=3_05_22	,       __snake_case=7_68	,       __snake_case=12	,       __snake_case=12	,       __snake_case=30_72	,       __snake_case="gelu"	,       __snake_case=0.1	,       __snake_case=0.1	,       __snake_case=5_12	,       __snake_case=2	,       __snake_case=0.0_2	,       __snake_case=1e-12	,       __snake_case=0	,       __snake_case="topK"	,       __snake_case="constant"	,       __snake_case=0.0	,       **__snake_case	,       ):
			super().__init__(pad_token_id=__snake_case	,       **__snake_case)

			_UpperCamelCase   :		List[Any]			=						vocab_size
			_UpperCamelCase   :		Union[str, Any]			=						hidden_size
			_UpperCamelCase   :		Optional[int]			=						num_hidden_layers
			_UpperCamelCase   :		Any			=						num_attention_heads
			_UpperCamelCase   :		int			=						hidden_act
			_UpperCamelCase   :		str			=						intermediate_size
			_UpperCamelCase   :		str			=						hidden_dropout_prob
			_UpperCamelCase   :		Any			=						attention_probs_dropout_prob
			_UpperCamelCase   :		Tuple			=						max_position_embeddings
			_UpperCamelCase   :		Dict			=						type_vocab_size
			_UpperCamelCase   :		str			=						initializer_range
			_UpperCamelCase   :		List[Any]			=						layer_norm_eps
			_UpperCamelCase   :		Tuple			=						pruning_method
			_UpperCamelCase   :		Tuple			=						mask_init
			_UpperCamelCase   :		Dict			=						mask_scale




