import numpy as np
from PIL import Image
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase						):
					__a		 =       np.array(__lowerCamelCase						)
					if arr.shape[0] != arr.shape[1]:
										raise ValueError('The input array is not a square matrix'						)
					__a		 =       0
					__a		 =       0
					__a		 =       0
					__a		 =       0

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

					return updated_arr
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase						):
					__a		 =       np.array(__lowerCamelCase						)
					if arr.shape[0] != arr.shape[1]:
										raise ValueError('The input array is not a square matrix'						)
					__a		 =       0
					__a		 =       0
					__a		 =       0
					__a		 =       0

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

					return updated_arr


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

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

	# Loading the image
	lowerCamelCase_    :		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()





from typing import TYPE_CHECKING

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


lowerCamelCase_    :		Optional[int]							=	{"""configuration_xlnet""": ["""XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLNetConfig"""]}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		str							=	["""XLNetTokenizer"""]

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Optional[Any]							=	["""XLNetTokenizerFast"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Union[str, Any]							=	[
	    """XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """XLNetForMultipleChoice""",
	    """XLNetForQuestionAnswering""",
	    """XLNetForQuestionAnsweringSimple""",
	    """XLNetForSequenceClassification""",
	    """XLNetForTokenClassification""",
	    """XLNetLMHeadModel""",
	    """XLNetModel""",
	    """XLNetPreTrainedModel""",
	    """load_tf_weights_in_xlnet""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Optional[int]							=	[
	    """TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """TFXLNetForMultipleChoice""",
	    """TFXLNetForQuestionAnsweringSimple""",
	    """TFXLNetForSequenceClassification""",
	    """TFXLNetForTokenClassification""",
	    """TFXLNetLMHeadModel""",
	    """TFXLNetMainLayer""",
	    """TFXLNetModel""",
	    """TFXLNetPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlnet import XLNetTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlnet_fast import XLNetTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_xlnet import (
		    XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XLNetForMultipleChoice,
		    XLNetForQuestionAnswering,
		    XLNetForQuestionAnsweringSimple,
		    XLNetForSequenceClassification,
		    XLNetForTokenClassification,
		    XLNetLMHeadModel,
		    XLNetModel,
		    XLNetPreTrainedModel,
		    load_tf_weights_in_xlnet,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_xlnet import (
		    TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFXLNetForMultipleChoice,
		    TFXLNetForQuestionAnsweringSimple,
		    TFXLNetForSequenceClassification,
		    TFXLNetForTokenClassification,
		    TFXLNetLMHeadModel,
		    TFXLNetMainLayer,
		    TFXLNetModel,
		    TFXLNetPreTrainedModel,
		)

else:
	import sys

	lowerCamelCase_    :		Tuple							=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




