



"""simple docstring"""







import numpy as np
from PIL import Image

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






	"""simple docstring"""





	A__											=					np.array(UpperCAmelCase_     )
	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				(							UpperCAmelCase_ :       np.ndarray,	UpperCAmelCase_ :       int,	UpperCAmelCase_ :       int     )	-> np.ndarray:






	"""simple docstring"""





	A__											=					np.array(UpperCAmelCase_     )
	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
			UpperCamelCase     =							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()






"""simple docstring"""


import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402


SCREAMING_SNAKE_CASE			  =  {
    """return_dict""": False,
    """output_hidden_states""": True,
    """output_attentions""": True,
    """torchscript""": True,
    """torch_dtype""": """float16""",
    """use_bfloat16""": True,
    """tf_legacy_loss""": True,
    """pruned_heads""": {"""a""": 1},
    """tie_word_embeddings""": False,
    """is_decoder""": True,
    """cross_attention_hidden_size""": 128,
    """add_cross_attention""": True,
    """tie_encoder_decoder""": True,
    """max_length""": 50,
    """min_length""": 3,
    """do_sample""": True,
    """early_stopping""": True,
    """num_beams""": 3,
    """num_beam_groups""": 3,
    """diversity_penalty""": 0.5,
    """temperature""": 2.0,
    """top_k""": 10,
    """top_p""": 0.7,
    """typical_p""": 0.2,
    """repetition_penalty""": 0.8,
    """length_penalty""": 0.8,
    """no_repeat_ngram_size""": 5,
    """encoder_no_repeat_ngram_size""": 5,
    """bad_words_ids""": [1, 2, 3],
    """num_return_sequences""": 3,
    """chunk_size_feed_forward""": 5,
    """output_scores""": True,
    """return_dict_in_generate""": True,
    """forced_bos_token_id""": 2,
    """forced_eos_token_id""": 3,
    """remove_invalid_values""": True,
    """architectures""": ["""BertModel"""],
    """finetuning_task""": """translation""",
    """id2label""": {0: """label"""},
    """label2id""": {"""label""": """0"""},
    """tokenizer_class""": """BertTokenizerFast""",
    """prefix""": """prefix""",
    """bos_token_id""": 6,
    """pad_token_id""": 7,
    """eos_token_id""": 8,
    """sep_token_id""": 9,
    """decoder_start_token_id""": 10,
    """exponential_decay_length_penalty""": (5, 1.01),
    """suppress_tokens""": [0, 1],
    """begin_suppress_tokens""": 2,
    """task_specific_params""": {"""translation""": """some_params"""},
    """problem_type""": """regression""",
}



@is_staging_test
class 	__a	(   unittest.TestCase						):






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				Union[str, Any]      )->	List[Any]:







              """simple docstring"""
              UpperCamelCase       			=		TOKEN
              HfFolder.save_token(UpperCAmelCase_      )






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				str      )->	Dict:







              """simple docstring"""
              try:
                     delete_repo(token=cls._token							,   repo_id="test-config"      )
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token							,   repo_id="valid_org/test-config-org"      )
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token							,   repo_id="test-dynamic-config"      )
              except HTTPError:
                     pass






       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[Any]      )->	int:







              """simple docstring"""
              UpperCamelCase       			=		BertConfig(
                  vocab_size=99							,   hidden_size=32							,   num_hidden_layers=5							,   num_attention_heads=4							,   intermediate_size=37      )
              config.push_to_hub("test-config"							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained(f"{USER}/test-config"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )

        # Reset repo
              delete_repo(token=self._token							,   repo_id="test-config"      )

              # Push to hub via save_pretrained
              with tempfile.TemporaryDirectory() as tmp_dir:
                     config.save_pretrained(UpperCAmelCase_							,   repo_id="test-config"							,   push_to_hub=UpperCAmelCase_							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained(f"{USER}/test-config"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )






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







              """simple docstring"""
              UpperCamelCase       			=		BertConfig(
                  vocab_size=99							,   hidden_size=32							,   num_hidden_layers=5							,   num_attention_heads=4							,   intermediate_size=37      )
              config.push_to_hub("valid_org/test-config-org"							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained("valid_org/test-config-org"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )

        # Reset repo
              delete_repo(token=self._token							,   repo_id="valid_org/test-config-org"      )

              # Push to hub via save_pretrained
              with tempfile.TemporaryDirectory() as tmp_dir:
                     config.save_pretrained(
                         UpperCAmelCase_							,   repo_id="valid_org/test-config-org"							,   push_to_hub=UpperCAmelCase_							,   use_auth_token=self._token      )

              UpperCamelCase       			=		BertConfig.from_pretrained("valid_org/test-config-org"      )
              for k, v in config.to_dict().items():
                     if k != "transformers_version":
                            self.assertEqual(UpperCAmelCase_							,   getattr(UpperCAmelCase_							,   UpperCAmelCase_      )      )






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







              """simple docstring"""
              CustomConfig.register_for_auto_class()
              UpperCamelCase       			=		CustomConfig(attribute=42      )

              config.push_to_hub("test-dynamic-config"							,   use_auth_token=self._token      )

              # This has added the proper auto_map field to the config
              self.assertDictEqual(config.auto_map							,   {"AutoConfig": "custom_configuration.CustomConfig"}      )

              UpperCamelCase       			=		AutoConfig.from_pretrained(f"{USER}/test-dynamic-config"							,   trust_remote_code=UpperCAmelCase_      )
              # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
              self.assertEqual(new_config.__class__.__name__							,   "CustomConfig"      )
              self.assertEqual(new_config.attribute							,   42      )





class 	__a	(   unittest.TestCase						):






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		GPTaConfig()

              # attempt to modify each of int/float/bool/str config records and verify they were updated
              UpperCamelCase       			=		c.n_embd + 1  # int
              UpperCamelCase       			=		c.resid_pdrop + 1.0  # float
              UpperCamelCase       			=		not c.scale_attn_weights  # bool
              UpperCamelCase       			=		c.summary_type + "foo"  # str
              c.update_from_string(
                  f"n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"      )
              self.assertEqual(UpperCAmelCase_							,   c.n_embd							,   "mismatch for key: n_embd"      )
              self.assertEqual(UpperCAmelCase_							,   c.resid_pdrop							,   "mismatch for key: resid_pdrop"      )
              self.assertEqual(UpperCAmelCase_							,   c.scale_attn_weights							,   "mismatch for key: scale_attn_weights"      )
              self.assertEqual(UpperCAmelCase_							,   c.summary_type							,   "mismatch for key: summary_type"      )






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







              """simple docstring"""
              UpperCamelCase       			=		PretrainedConfig()
              UpperCamelCase       			=		[key for key in base_config.__dict__ if key not in config_common_kwargs]
              # If this part of the test fails, you have arguments to addin config_common_kwargs above.
              self.assertListEqual(
                  UpperCAmelCase_							,   ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]      )
              UpperCamelCase       			=		[key for key, value in config_common_kwargs.items() if value == getattr(UpperCAmelCase_							,   UpperCAmelCase_      )]
              if len(UpperCAmelCase_      ) > 0:
                     raise ValueError(
                         "The following keys are set with the default values in"
                         " `test_configuration_common.config_common_kwargs` pick another value for them:"
                         f" {', '.join(UpperCAmelCase_      )}."      )






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







              """simple docstring"""
              with self.assertRaises(UpperCAmelCase_      ):
                     # config is in subfolder, the following should not work without specifying the subfolder
                     UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"      )

              UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"							,   subfolder="bert"      )

              self.assertIsNotNone(UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Any:







              """simple docstring"""
              # A mock response for an HTTP head request to emulate server down
              UpperCamelCase       			=		mock.Mock()
              UpperCamelCase       			=		500
              UpperCamelCase       			=		{}
              UpperCamelCase       			=		HTTPError
              UpperCamelCase       			=		{}

              # Download this model to make sure it's in the cache.
              UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )

              # Under the mock environment we get a 500 error when trying to reach the model.
              with mock.patch("requests.Session.request"							,   return_value=UpperCAmelCase_      ) as mock_head:
                     UpperCamelCase       			=		BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )
                     # This check we did call the fake head request
                     mock_head.assert_called()






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple      )->	int:







              """simple docstring"""
              # This test is for deprecated behavior and can be removed in v5
              UpperCamelCase       			=		BertConfig.from_pretrained(
                  "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"      )






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







              """simple docstring"""
              UpperCamelCase       			=		AutoConfig.from_pretrained("bert-base-cased"      )
              UpperCamelCase       			=		["config.4.0.0.json"]

              with tempfile.TemporaryDirectory() as tmp_dir:
                     configuration.save_pretrained(UpperCAmelCase_      )
                     UpperCamelCase       			=		2
                     json.dump(configuration.to_dict()							,   open(os.path.join(UpperCAmelCase_							,   "config.4.0.0.json"      )							,   "w"      )      )

                     # This should pick the new configuration file as the version of Transformers is > 4.0.0
                     UpperCamelCase       			=		AutoConfig.from_pretrained(UpperCAmelCase_      )
                     self.assertEqual(new_configuration.hidden_size							,   2      )

                     # Will need to be adjusted if we reach v42 and this test is still here.
                     # Should pick the old configuration file as the version of Transformers is < 4.42.0
                     UpperCamelCase       			=		["config.42.0.0.json"]
                     UpperCamelCase       			=		768
                     configuration.save_pretrained(UpperCAmelCase_      )
                     shutil.move(os.path.join(UpperCAmelCase_							,   "config.4.0.0.json"      )							,   os.path.join(UpperCAmelCase_							,   "config.42.0.0.json"      )      )
                     UpperCamelCase       			=		AutoConfig.from_pretrained(UpperCAmelCase_      )
                     self.assertEqual(new_configuration.hidden_size							,   768      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]      )->	Dict:







              """simple docstring"""
              # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
              UpperCamelCase       			=		"hf-internal-testing/test-two-configs"

              import transformers as new_transformers

              UpperCamelCase       			=		"v4.0.0"
              UpperCamelCase			,							UpperCamelCase       			=		new_transformers.models.auto.AutoConfig.from_pretrained(
                  UpperCAmelCase_							,   return_unused_kwargs=UpperCAmelCase_      )
              self.assertEqual(new_configuration.hidden_size							,   2      )
              # This checks `_configuration_file` ia not kept in the kwargs by mistake.
              self.assertDictEqual(UpperCAmelCase_							,   {}      )

              # Testing an older version by monkey-patching the version in the module it's used.
              import transformers as old_transformers

              UpperCamelCase       			=		"v3.0.0"
              UpperCamelCase       			=		old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase_      )
              self.assertEqual(old_configuration.hidden_size							,   768      )





