





import numpy as np
from PIL import Image






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				np.ndarray       , UpperCamelCase__:				int       , UpperCamelCase__:				int     ):
		SCREAMING_SNAKE_CASE__								=   np.array(UpperCamelCase__     )
		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 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				np.ndarray       , UpperCamelCase__:				int       , UpperCamelCase__:				int     ):
		SCREAMING_SNAKE_CASE__								=   np.array(UpperCamelCase__     )
		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 					=      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 copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Value
from .base import TaskTemplate




@dataclass(frozen=UpperCamelCase__     )
class 	UpperCamelCase_							(  UpperCamelCase__     ):
							# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
							lowerCamelCase_							     =       field(default="text-classification"					,	metadata={"include_in_asdict_even_if_is_default": True}     )
							lowerCamelCase_							     =       Features({"text": Value("string"     )}     )
							lowerCamelCase_							     =       Features({"labels": ClassLabel}     )
							lowerCamelCase_							     =       "text"
							lowerCamelCase_							     =       "labels"


							def   _snake_case	(				self     :Any				,					__A     :Dict		) -> Optional[Any]:



									"""simple docstring"""



									if self.label_column not in features:
											raise ValueError(f'''Column {self.label_column} is not present in features.'''		)
									if not isinstance(features[self.label_column]				,					__A		):
											raise ValueError(f'''Column {self.label_column} is not a ClassLabel.'''		)
									SCREAMING_SNAKE_CASE__								=   copy.deepcopy(self		)
									SCREAMING_SNAKE_CASE__								=   self.label_schema.copy()
									SCREAMING_SNAKE_CASE__								=   features[self.label_column]
									SCREAMING_SNAKE_CASE__								=   label_schema
									return task_template


							@property
							def   _snake_case	(				self     :str		) -> Dict[str, str]:



									"""simple docstring"""



									return {
									    self.text_column: "text",
									    self.label_column: "labels",
									}