

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFRoFormerForCausalLM,
         TFRoFormerForMaskedLM,
         TFRoFormerForMultipleChoice,
         TFRoFormerForQuestionAnswering,
         TFRoFormerForSequenceClassification,
         TFRoFormerForTokenClassification,
         TFRoFormerModel,
     )
     from transformers.models.roformer.modeling_tf_roformer import (
         TFRoFormerSelfAttention,
         TFRoFormerSinusoidalPositionalEmbedding,
     )







class 							A__    :





  def __init__(		self      :	Optional[int]							,					_a      :	List[str]							,					_a      :	List[Any]=13							,					_a      :	str=7							,					_a      :	str=True							,					_a      :	Any=True							,					_a      :	Tuple=True							,					_a      :	Dict=True							,					_a      :	str=99							,					_a      :	int=32							,					_a      :	Dict=2							,					_a      :	Optional[int]=4							,					_a      :	Any=37							,					_a      :	List[Any]="gelu"							,					_a      :	Optional[int]=0.1							,					_a      :	List[Any]=0.1							,					_a      :	Optional[Any]=512							,					_a      :	List[str]=16							,					_a      :	Optional[Any]=2							,					_a      :	List[str]=0.02							,					_a      :	int=3							,					_a      :	List[str]=4							,					_a      :	Union[str, Any]=None							,					)	->    int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =parent
       _SCREAMING_SNAKE_CASE							    =13
       _SCREAMING_SNAKE_CASE							    =7
       _SCREAMING_SNAKE_CASE							    =True
       _SCREAMING_SNAKE_CASE							    =True
       _SCREAMING_SNAKE_CASE							    =True
       _SCREAMING_SNAKE_CASE							    =True
       _SCREAMING_SNAKE_CASE							    =99
       _SCREAMING_SNAKE_CASE							    =32
       _SCREAMING_SNAKE_CASE							    =2
       _SCREAMING_SNAKE_CASE							    =4
       _SCREAMING_SNAKE_CASE							    =37
       _SCREAMING_SNAKE_CASE							    ='gelu'
       _SCREAMING_SNAKE_CASE							    =0.1
       _SCREAMING_SNAKE_CASE							    =0.1
       _SCREAMING_SNAKE_CASE							    =512
       _SCREAMING_SNAKE_CASE							    =16
       _SCREAMING_SNAKE_CASE							    =2
       _SCREAMING_SNAKE_CASE							    =0.02
       _SCREAMING_SNAKE_CASE							    =3
       _SCREAMING_SNAKE_CASE							    =4
       _SCREAMING_SNAKE_CASE							    =None





  def 						A  (		self      :	Optional[int] )	->    Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size )

       _SCREAMING_SNAKE_CASE							    =None
       if self.use_input_mask:
            _SCREAMING_SNAKE_CASE							    =random_attention_mask([self.batch_size, self.seq_length] )

       _SCREAMING_SNAKE_CASE							    =None
       if self.use_token_type_ids:
            _SCREAMING_SNAKE_CASE							    =ids_tensor([self.batch_size, self.seq_length]							,					self.type_vocab_size )

       _SCREAMING_SNAKE_CASE							    =None
       _SCREAMING_SNAKE_CASE							    =None
       _SCREAMING_SNAKE_CASE							    =None
       if self.use_labels:
            _SCREAMING_SNAKE_CASE							    =ids_tensor([self.batch_size]							,					self.type_sequence_label_size )
            _SCREAMING_SNAKE_CASE							    =ids_tensor([self.batch_size, self.seq_length]							,					self.num_labels )
            _SCREAMING_SNAKE_CASE							    =ids_tensor([self.batch_size]							,					self.num_choices )

       _SCREAMING_SNAKE_CASE							    =RoFormerConfig(
           vocab_size=self.vocab_size							,					hidden_size=self.hidden_size							,					num_hidden_layers=self.num_hidden_layers							,					num_attention_heads=self.num_attention_heads							,					intermediate_size=self.intermediate_size							,					hidden_act=self.hidden_act							,					hidden_dropout_prob=self.hidden_dropout_prob							,					attention_probs_dropout_prob=self.attention_probs_dropout_prob							,					max_position_embeddings=self.max_position_embeddings							,					type_vocab_size=self.type_vocab_size							,					initializer_range=self.initializer_range							,					return_dict=_a							,					)

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





  def 						A  (		self      :	str							,					_a      :	Optional[Any]							,					_a      :	Optional[Any]							,					_a      :	int							,					_a      :	str							,					_a      :	List[Any]							,					_a      :	Optional[int]							,					_a      :	Any )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerModel(config=_a )
       _SCREAMING_SNAKE_CASE							    ={'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

       _SCREAMING_SNAKE_CASE							    =[input_ids, input_mask]
       _SCREAMING_SNAKE_CASE							    =model(_a )

       _SCREAMING_SNAKE_CASE							    =model(_a )

       self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size) )





  def 						A  (		self      :	List[Any]							,					_a      :	str							,					_a      :	Dict							,					_a      :	List[str]							,					_a      :	List[Any]							,					_a      :	Optional[Any]							,					_a      :	int							,					_a      :	List[Any] )	->    Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =True
       _SCREAMING_SNAKE_CASE							    =TFRoFormerForCausalLM(config=_a )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							    =model(_a )['logits']
       self.parent.assertListEqual(
           list(prediction_scores.numpy().shape )							,					[self.batch_size, self.seq_length, self.vocab_size] )





  def 						A  (		self      :	Tuple							,					_a      :	Any							,					_a      :	Dict							,					_a      :	Optional[Any]							,					_a      :	str							,					_a      :	List[str]							,					_a      :	List[str]							,					_a      :	Tuple )	->    List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerForMaskedLM(config=_a )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							    =model(_a )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.vocab_size) )





  def 						A  (		self      :	Optional[int]							,					_a      :	Optional[int]							,					_a      :	Union[str, Any]							,					_a      :	str							,					_a      :	Tuple							,					_a      :	Tuple							,					_a      :	Tuple							,					_a      :	Union[str, Any] )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.num_labels
       _SCREAMING_SNAKE_CASE							    =TFRoFormerForSequenceClassification(config=_a )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       _SCREAMING_SNAKE_CASE							    =model(_a )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels) )





  def 						A  (		self      :	Any							,					_a      :	List[Any]							,					_a      :	Dict							,					_a      :	List[str]							,					_a      :	Any							,					_a      :	Tuple							,					_a      :	str							,					_a      :	List[Any] )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.num_choices
       _SCREAMING_SNAKE_CASE							    =TFRoFormerForMultipleChoice(config=_a )
       _SCREAMING_SNAKE_CASE							    =tf.tile(tf.expand_dims(_a							,					1 )							,					(1, self.num_choices, 1) )
       _SCREAMING_SNAKE_CASE							    =tf.tile(tf.expand_dims(_a							,					1 )							,					(1, self.num_choices, 1) )
       _SCREAMING_SNAKE_CASE							    =tf.tile(tf.expand_dims(_a							,					1 )							,					(1, self.num_choices, 1) )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							    =model(_a )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_choices) )





  def 						A  (		self      :	Tuple							,					_a      :	str							,					_a      :	Union[str, Any]							,					_a      :	Union[str, Any]							,					_a      :	Any							,					_a      :	List[Any]							,					_a      :	Dict							,					_a      :	List[str] )	->    Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.num_labels
       _SCREAMING_SNAKE_CASE							    =TFRoFormerForTokenClassification(config=_a )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							    =model(_a )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.num_labels) )





  def 						A  (		self      :	str							,					_a      :	Any							,					_a      :	str							,					_a      :	Optional[Any]							,					_a      :	Optional[int]							,					_a      :	str							,					_a      :	Any							,					_a      :	Optional[int] )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerForQuestionAnswering(config=_a )
       _SCREAMING_SNAKE_CASE							    ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       _SCREAMING_SNAKE_CASE							    =model(_a )
       self.parent.assertEqual(result.start_logits.shape							,					(self.batch_size, self.seq_length) )
       self.parent.assertEqual(result.end_logits.shape							,					(self.batch_size, self.seq_length) )





  def 						A  (		self      :	Tuple )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.prepare_config_and_inputs()
       (
           (
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						(
           _SCREAMING_SNAKE_CASE
       )    ,						
       )							    =config_and_inputs
       _SCREAMING_SNAKE_CASE							    ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
       return config, inputs_dict







@require_tf
class 							A__    (       A__     ,   A__     ,   unittest.TestCase  ):
  A__		 =				(
      (
          TFRoFormerModel,
          TFRoFormerForCausalLM,
          TFRoFormerForMaskedLM,
          TFRoFormerForQuestionAnswering,
          TFRoFormerForSequenceClassification,
          TFRoFormerForTokenClassification,
          TFRoFormerForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  A__		 =				(
      {
          'feature-extraction': TFRoFormerModel,
          'fill-mask': TFRoFormerForMaskedLM,
          'question-answering': TFRoFormerForQuestionAnswering,
          'text-classification': TFRoFormerForSequenceClassification,
          'text-generation': TFRoFormerForCausalLM,
          'token-classification': TFRoFormerForTokenClassification,
          'zero-shot': TFRoFormerForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )

  A__		 =				False
  A__		 =				False





  def 						A  (		self      :	Union[str, Any]							,					_a      :	List[str]							,					_a      :	int							,					_a      :	Optional[int]							,					_a      :	List[Any]							,					_a      :	Dict )	->    Tuple:





       '''simple docstring'''






       if pipeline_test_casse_name == "TextGenerationPipelineTests":
            return True

       return False





  def 						A  (		self      :	Any )	->    List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerModelTester(self )
       _SCREAMING_SNAKE_CASE							    =ConfigTester(self							,					config_class=_a							,					hidden_size=37 )





  def 						A  (		self      :	List[str] )	->    Optional[Any]:





       '''simple docstring'''






       self.config_tester.run_common_tests()





  def 						A  (		self      :	Optional[int] )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_a )





  def 						A  (		self      :	int )	->    Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_a )





  def 						A  (		self      :	Tuple )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_lm_head(*_a )





  def 						A  (		self      :	List[str] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_a )





  def 						A  (		self      :	Optional[int] )	->    List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_a )





  def 						A  (		self      :	int )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_a )





  def 						A  (		self      :	Any )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_a )





  @slow
  def 						A  (		self      :	Dict )	->    Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base' )
       self.assertIsNotNone(_a )







@require_tf
class 							A__    (       unittest.TestCase  ):





  @slow
  def 						A  (		self      :	int )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base' )
       _SCREAMING_SNAKE_CASE							    =tf.constant([[0, 1, 2, 3, 4, 5]] )
       _SCREAMING_SNAKE_CASE							    =model(_a )[0]

       # TODO Replace vocab size
       _SCREAMING_SNAKE_CASE							    =5_0000

       _SCREAMING_SNAKE_CASE							    =[1, 6, vocab_size]
       self.assertEqual(output.shape							,					_a )

       print(output[:, :3, :3] )

       # TODO Replace values below with what was printed above.
       _SCREAMING_SNAKE_CASE							    =tf.constant(
           [
               [
                   [-0.12_05_33_41, -1.0_26_49_01, 0.29_22_19_46],
                   [-1.5_13_37_83, 0.19_74_33, 0.15_19_06_07],
                   [-5.0_13_54_03, -3.90_02_56, -0.84_03_87_64],
               ]
           ] )
       tf.debugging.assert_near(output[:, :3, :3]							,					_a							,					atol=1e-4 )







@require_tf
class 							A__    (       unittest.TestCase  ):
  A__		 =				1E-4





  def 						A  (		self      :	Dict )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =tf.constant([[4, 10]] )
       _SCREAMING_SNAKE_CASE							    =TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							,					embedding_dim=6 )

       _SCREAMING_SNAKE_CASE							    =emba(input_ids.shape )
       _SCREAMING_SNAKE_CASE							    =tf.constant(
           [[0.00_00, 0.00_00, 0.00_00, 1.00_00, 1.00_00, 1.00_00], [0.84_15, 0.04_64, 0.00_22, 0.54_03, 0.99_89, 1.00_00]] )

       tf.debugging.assert_near(_a							,					_a							,					atol=self.tolerance )





  def 						A  (		self      :	Optional[Any] )	->    int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =tf.constant(
           [
               [0.00_00, 0.00_00, 0.00_00, 0.00_00, 0.00_00],
               [0.84_15, 0.82_19, 0.80_20, 0.78_19, 0.76_17],
               [0.90_93, 0.93_64, 0.95_81, 0.97_49, 0.98_70],
           ] )
       _SCREAMING_SNAKE_CASE							    =TFRoFormerSinusoidalPositionalEmbedding(num_positions=512							,					embedding_dim=512 )
       emba([2, 16, 512] )
       _SCREAMING_SNAKE_CASE							    =emba.weight[:3, :5]

       tf.debugging.assert_near(_a							,					_a							,					atol=self.tolerance )







@require_tf
class 							A__    (       unittest.TestCase  ):
  A__		 =				1E-4





  def 						A  (		self      :	Tuple )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =tf.reshape(tf.range(2 * 12 * 16 * 64							,					dtype=tf.floataa )							,					shape=(2, 12, 16, 64) ) / 100

       _SCREAMING_SNAKE_CASE							    =-tf.reshape(tf.range(2 * 12 * 16 * 64							,					dtype=tf.floataa )							,					shape=(2, 12, 16, 64) ) / 100

       _SCREAMING_SNAKE_CASE							    =TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							,					embedding_dim=64 )
       _SCREAMING_SNAKE_CASE							    =embed_positions([2, 16, 768] )[None, None, :, :]

       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =TFRoFormerSelfAttention.apply_rotary_position_embeddings(
           _a							,					_a							,					_a )

       _SCREAMING_SNAKE_CASE							    =tf.constant(
           [
               [0.00_00, 0.01_00, 0.02_00, 0.03_00, 0.04_00, 0.05_00, 0.06_00, 0.07_00],
               [-0.20_12, 0.88_97, 0.02_63, 0.94_01, 0.20_74, 0.94_63, 0.34_81, 0.93_43],
               [-1.70_57, 0.62_71, -1.21_45, 1.38_97, -0.63_03, 1.76_47, -0.11_73, 1.89_85],
               [-2.17_31, -1.63_97, -2.73_58, 0.28_54, -2.18_40, 1.71_83, -1.30_18, 2.48_71],
               [0.27_17, -3.61_73, -2.92_06, -2.19_88, -3.66_38, 0.38_58, -2.91_55, 2.29_80],
               [3.98_59, -2.15_80, -0.79_84, -4.49_04, -4.11_81, -2.02_52, -4.47_82, 1.12_53],
           ] )
       _SCREAMING_SNAKE_CASE							    =tf.constant(
           [
               [0.00_00, -0.01_00, -0.02_00, -0.03_00, -0.04_00, -0.05_00, -0.06_00, -0.07_00],
               [0.20_12, -0.88_97, -0.02_63, -0.94_01, -0.20_74, -0.94_63, -0.34_81, -0.93_43],
               [1.70_57, -0.62_71, 1.21_45, -1.38_97, 0.63_03, -1.76_47, 0.11_73, -1.89_85],
               [2.17_31, 1.63_97, 2.73_58, -0.28_54, 2.18_40, -1.71_83, 1.30_18, -2.48_71],
               [-0.27_17, 3.61_73, 2.92_06, 2.19_88, 3.66_38, -0.38_58, 2.91_55, -2.29_80],
               [-3.98_59, 2.15_80, 0.79_84, 4.49_04, 4.11_81, 2.02_52, 4.47_82, -1.12_53],
           ] )

       tf.debugging.assert_near(query_layer[0, 0, :6, :8]							,					_a							,					atol=self.tolerance )
       tf.debugging.assert_near(key_layer[0, 0, :6, :8]							,					_a							,					atol=self.tolerance )



'''simple docstring'''
import numpy as np
from PIL import Image


def        _lowerCAmelCase					(						_UpperCamelCase						:     np.ndarray							, _UpperCamelCase						:     int							, _UpperCamelCase						:     int				)      ->			np.ndarray:
     """simple docstring"""




     _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        _lowerCAmelCase					(						_UpperCamelCase						:     np.ndarray							, _UpperCamelCase						:     int							, _UpperCamelCase						:     int				)      ->			np.ndarray:
     """simple docstring"""




     _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 :      Optional[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()
