from __future__ import annotations

import unittest

from transformers import LEDConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TFLEDForConditionalGeneration, TFLEDModel



@require_tf
class   lowerCAmelCase_    :



				"""simple docstring"""
				_lowerCAmelCase     :    Union[str, Any]			  =						LEDConfig
				_lowerCAmelCase     :    str			  =						{}
				_lowerCAmelCase     :    Optional[Any]			  =						"""gelu"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase=13		,    lowerCAmelCase=7		,    lowerCAmelCase=True		,    lowerCAmelCase=False		,    lowerCAmelCase=99		,    lowerCAmelCase=32		,    lowerCAmelCase=2		,    lowerCAmelCase=4		,    lowerCAmelCase=37		,    lowerCAmelCase=0.1		,    lowerCAmelCase=0.1		,    lowerCAmelCase=20		,    lowerCAmelCase=2		,    lowerCAmelCase=1		,    lowerCAmelCase=0		,    lowerCAmelCase=4		,    ):






										"""simple docstring"""

										snake_case								=			parent
										snake_case								=			batch_size
										snake_case								=			seq_length
										snake_case								=			is_training
										snake_case								=			use_labels
										snake_case								=			vocab_size
										snake_case								=			hidden_size
										snake_case								=			num_hidden_layers
										snake_case								=			num_attention_heads
										snake_case								=			intermediate_size

										snake_case								=			hidden_dropout_prob
										snake_case								=			attention_probs_dropout_prob
										snake_case								=			max_position_embeddings
										snake_case								=			eos_token_id
										snake_case								=			pad_token_id
										snake_case								=			bos_token_id
										snake_case								=			attention_window

										# `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
										# [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
										# returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
										# because its local attention only attends to `self.attention_window` and one before and one after
										snake_case								=			self.attention_window + 2

										# because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
										# the `test_attention_outputs` and `test_hidden_states_output` tests
										snake_case								=			(
										    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
										)

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			ids_tensor([self.batch_size, self.seq_length - 1]		,    self.vocab_size    )
										snake_case								=			tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size    )		,    1    )
										snake_case								=			tf.concat([input_ids, eos_tensor]		,    axis=1    )

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

										snake_case								=			self.config_cls(
										    vocab_size=self.vocab_size		,    d_model=self.hidden_size		,    encoder_layers=self.num_hidden_layers		,    decoder_layers=self.num_hidden_layers		,    encoder_attention_heads=self.num_attention_heads		,    decoder_attention_heads=self.num_attention_heads		,    encoder_ffn_dim=self.intermediate_size		,    decoder_ffn_dim=self.intermediate_size		,    dropout=self.hidden_dropout_prob		,    attention_dropout=self.attention_probs_dropout_prob		,    max_position_embeddings=self.max_position_embeddings		,    eos_token_ids=[2]		,    bos_token_id=self.bos_token_id		,    pad_token_id=self.pad_token_id		,    decoder_start_token_id=self.pad_token_id		,    attention_window=self.attention_window		,    **self.config_updates		,    )
										snake_case								=			prepare_led_inputs_dict(__UpperCamelCase		,    __UpperCamelCase		,    __UpperCamelCase    )
										snake_case								=			tf.concat(
										    [tf.zeros_like(__UpperCamelCase    )[:, :-1], tf.ones_like(__UpperCamelCase    )[:, -1:]]		,    axis=-1		,    )
										snake_case								=			global_attention_mask
										return config, inputs_dict

				def 		snake_case (				self		,    lowerCAmelCase		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			TFLEDModel(config=__UpperCamelCase    ).get_decoder()
										snake_case								=			inputs_dict['input_ids']

										snake_case								=			input_ids[:1, :]
										snake_case								=			inputs_dict['attention_mask'][:1, :]
										snake_case								=			1

										# first forward pass
										snake_case								=			model(__UpperCamelCase		,    attention_mask=__UpperCamelCase		,    use_cache=__UpperCamelCase    )

										snake_case					,snake_case								=			outputs.to_tuple()

										# create hypothetical next token and extent to next_input_ids
										snake_case								=			ids_tensor((self.batch_size, 3)		,    config.vocab_size    )
										snake_case								=			tf.cast(ids_tensor((self.batch_size, 3)		,    2    )		,    tf.inta    )

										# append to next input_ids and
										snake_case								=			tf.concat([input_ids, next_tokens]		,    axis=-1    )
										snake_case								=			tf.concat([attention_mask, next_attn_mask]		,    axis=-1    )

										snake_case								=			model(__UpperCamelCase		,    attention_mask=__UpperCamelCase    )[0]
										snake_case								=			model(__UpperCamelCase		,    attention_mask=__UpperCamelCase		,    past_key_values=__UpperCamelCase    )[0]

										self.parent.assertEqual(next_tokens.shape[1]		,    output_from_past.shape[1]    )

										# select random slice
										snake_case								=			int(ids_tensor((1,)		,    output_from_past.shape[-1]    )    )
										snake_case								=			output_from_no_past[:, -3:, random_slice_idx]
										snake_case								=			output_from_past[:, :, random_slice_idx]

										# test that outputs are equal for slice
										tf.debugging.assert_near(__UpperCamelCase		,    __UpperCamelCase		,    rtol=1E-3    )





def    lowerCAmelCase__    (			_UpperCamelCase       :				List[str] ,			_UpperCamelCase       :				Optional[int] ,			_UpperCamelCase       :				Dict ,			_UpperCamelCase       :				List[Any]=None ,			_UpperCamelCase       :				Optional[Any]=None ,			_UpperCamelCase       :				List[str]=None ,			_UpperCamelCase       :				Any=None ,			)					->				Tuple:





						"""simple docstring"""






						if attention_mask is None:
												snake_case								=			tf.cast(tf.math.not_equal(lowercase__ ,			config.pad_token_id					) ,			tf.inta					)
						if decoder_attention_mask is None:
												snake_case								=			tf.concat(
												    [
												        tf.ones(decoder_input_ids[:, :1].shape ,			dtype=tf.inta					),
												        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] ,			config.pad_token_id					) ,			tf.inta					),
												    ] ,			axis=-1 ,			)
						if head_mask is None:
												snake_case								=			tf.ones((config.encoder_layers, config.encoder_attention_heads)					)
						if decoder_head_mask is None:
												snake_case								=			tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
						return {
						    "input_ids": input_ids,
						    "attention_mask": attention_mask,
						    "decoder_input_ids": decoder_input_ids,
						    "decoder_attention_mask": decoder_attention_mask,
						    "head_mask": head_mask,
						    "decoder_head_mask": decoder_head_mask,
						}



@require_tf
class   lowerCAmelCase_    (			__snake_case     ,    __snake_case     ,    unittest.TestCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    List[Any]			  =						(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
				_lowerCAmelCase     :    Optional[int]			  =						(TFLEDForConditionalGeneration,) if is_tf_available() else ()
				_lowerCAmelCase     :    Dict			  =						(
				    {
				        """conversational""": TFLEDForConditionalGeneration,
				        """feature-extraction""": TFLEDModel,
				        """summarization""": TFLEDForConditionalGeneration,
				        """text2text-generation""": TFLEDForConditionalGeneration,
				        """translation""": TFLEDForConditionalGeneration,
				    }
				    if is_tf_available()
				    else {}
				)
				_lowerCAmelCase     :    Optional[int]			  =						True
				_lowerCAmelCase     :    int			  =						False
				_lowerCAmelCase     :    Union[str, Any]			  =						False
				_lowerCAmelCase     :    List[str]			  =						False

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			TFLEDModelTester(self    )
										snake_case								=			ConfigTester(self		,    config_class=__UpperCamelCase    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										self.config_tester.run_common_tests()

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.check_decoder_model_past_large_inputs(*__UpperCamelCase    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case					,snake_case								=			self.model_tester.prepare_config_and_inputs_for_common()
										snake_case								=			tf.zeros_like(inputs_dict['attention_mask']    )
										snake_case								=			2
										snake_case								=			tf.where(
										    tf.range(self.model_tester.seq_length    )[None, :] < num_global_attn_indices		,    1		,    inputs_dict['global_attention_mask']		,    )

										snake_case								=			True
										snake_case								=			self.model_tester.seq_length
										snake_case								=			self.model_tester.encoder_seq_length

										def check_decoder_attentions_output(lowerCAmelCase    ):
																snake_case								=			outputs.decoder_attentions
																self.assertEqual(len(__UpperCamelCase    )		,    self.model_tester.num_hidden_layers    )
																self.assertListEqual(
																    list(decoder_attentions[0].shape[-3:]    )		,    [self.model_tester.num_attention_heads, seq_length, seq_length]		,    )

										def check_encoder_attentions_output(lowerCAmelCase    ):
																snake_case								=			[t.numpy() for t in outputs.encoder_attentions]
																snake_case								=			[t.numpy() for t in outputs.encoder_global_attentions]
																self.assertEqual(len(__UpperCamelCase    )		,    self.model_tester.num_hidden_layers    )
																self.assertEqual(len(__UpperCamelCase    )		,    self.model_tester.num_hidden_layers    )
																self.assertListEqual(
																    list(attentions[0].shape[-3:]    )		,    [self.model_tester.num_attention_heads, seq_length, seq_length]		,    )
																self.assertListEqual(
																    list(global_attentions[0].shape[-3:]    )		,    [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]		,    )

										for model_class in self.all_model_classes:
																snake_case								=			True
																snake_case								=			False
																snake_case								=			False
																snake_case								=			model_class(__UpperCamelCase    )
																snake_case								=			model(self._prepare_for_class(__UpperCamelCase		,    __UpperCamelCase    )    )
																snake_case								=			len(__UpperCamelCase    )
																self.assertEqual(config.output_hidden_states		,    __UpperCamelCase    )
																check_encoder_attentions_output(__UpperCamelCase    )

																if self.is_encoder_decoder:
																						snake_case								=			model_class(__UpperCamelCase    )
																						snake_case								=			model(self._prepare_for_class(__UpperCamelCase		,    __UpperCamelCase    )    )
																						self.assertEqual(config.output_hidden_states		,    __UpperCamelCase    )
																						check_decoder_attentions_output(__UpperCamelCase    )

																# Check that output attentions can also be changed via the config
																del inputs_dict["output_attentions"]
																snake_case								=			True
																snake_case								=			model_class(__UpperCamelCase    )
																snake_case								=			model(self._prepare_for_class(__UpperCamelCase		,    __UpperCamelCase    )    )
																self.assertEqual(config.output_hidden_states		,    __UpperCamelCase    )
																check_encoder_attentions_output(__UpperCamelCase    )

																# Check attention is always last and order is fine
																snake_case								=			True
																snake_case								=			True
																snake_case								=			model_class(__UpperCamelCase    )
																snake_case								=			model(self._prepare_for_class(__UpperCamelCase		,    __UpperCamelCase    )    )

																self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)		,    len(__UpperCamelCase    )    )
																self.assertEqual(model.config.output_hidden_states		,    __UpperCamelCase    )
																check_encoder_attentions_output(__UpperCamelCase    )

				@unittest.skip('LED keeps using potentially symbolic tensors in conditionals and breaks tracing.'    )
				def 		snake_case (				self    ):






										"""simple docstring"""

										pass

				def 		snake_case (				self    ):






										"""simple docstring"""

										pass





def    lowerCAmelCase__    (			_UpperCamelCase       :				Union[str, Any]					)					->				List[Any]:





						"""simple docstring"""






						return tf.constant(lowercase__ ,			dtype=tf.intaa					)


SCREAMING_SNAKE_CASE__      						=  1E-4



@slow
@require_tf
class   lowerCAmelCase_    (			unittest.TestCase					):



				"""simple docstring"""

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'    ).led

										# change to intended input here
										snake_case								=			_long_tensor([5_12 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]]    )
										snake_case								=			_long_tensor([1_28 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]]    )
										snake_case								=			prepare_led_inputs_dict(model.config		,    __UpperCamelCase		,    __UpperCamelCase    )
										snake_case								=			model(**__UpperCamelCase    )[0]
										snake_case								=			(1, 10_24, 7_68)
										self.assertEqual(output.shape		,    __UpperCamelCase    )
										# change to expected output here
										snake_case								=			tf.convert_to_tensor(
										    [[2.30_50, 2.82_79, 0.65_31], [-1.84_57, -0.14_55, -3.56_61], [-1.01_86, 0.45_86, -2.20_43]]		,    )
										tf.debugging.assert_near(output[:, :3, :3]		,    __UpperCamelCase		,    atol=1E-3    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'    )

										# change to intended input here
										snake_case								=			_long_tensor([5_12 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]]    )
										snake_case								=			_long_tensor([1_28 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]]    )
										snake_case								=			prepare_led_inputs_dict(model.config		,    __UpperCamelCase		,    __UpperCamelCase    )
										snake_case								=			model(**__UpperCamelCase    )[0]
										snake_case								=			(1, 10_24, model.config.vocab_size)
										self.assertEqual(output.shape		,    __UpperCamelCase    )
										# change to expected output here
										snake_case								=			tf.convert_to_tensor(
										    [[33.65_07, 6.45_72, 16.80_89], [5.87_39, -2.42_38, 11.29_02], [-3.21_39, -4.31_49, 4.27_83]]		,    )
										tf.debugging.assert_near(output[:, :3, :3]		,    __UpperCamelCase		,    atol=1E-3		,    rtol=1E-3    )



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





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






						snake_case								=			np.array(_UpperCamelCase					)
						if arr.shape[0] != arr.shape[1]:
												raise ValueError('The input array is not a square matrix'					)
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0

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

						return updated_arr





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






						snake_case								=			np.array(_UpperCamelCase					)
						if arr.shape[0] != arr.shape[1]:
												raise ValueError('The input array is not a square matrix'					)
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0

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

						return updated_arr


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

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

					# Loading the image
					SCREAMING_SNAKE_CASE__      						=  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()


