


'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase							:Tuple       = logging.get_logger(__name__)

lowerCamelCase							:List[Any]       = {
    '''google/pegasus-large''': '''https://huggingface.co/google/pegasus-large/resolve/main/config.json''',
    # See all PEGASUS models at https://huggingface.co/models?filter=pegasus
}







class      _lowerCAmelCase							(      __UpperCAmelCase			):
	__SCREAMING_SNAKE_CASE       :		List[str]		      = 'pegasus'
	__SCREAMING_SNAKE_CASE       :		List[str]		      = ['past_key_values']
	__SCREAMING_SNAKE_CASE       :		str		      = {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}


	def __init__(self	,				lowercase=50265	,				lowercase=1024	,				lowercase=12	,				lowercase=4096	,				lowercase=16	,				lowercase=12	,				lowercase=4096	,				lowercase=16	,				lowercase=0.0	,				lowercase=0.0	,				lowercase=True	,				lowercase=True	,				lowercase="gelu"	,				lowercase=1024	,				lowercase=0.1	,				lowercase=0.0	,				lowercase=0.0	,				lowercase=0.02	,				lowercase=0	,				lowercase=False	,				lowercase=0	,				lowercase=1	,				lowercase=1	,				**lowercase	,				):
				A_     :						Union[str, Any]     =					vocab_size
				A_     :						List[str]     =					max_position_embeddings
				A_     :						Tuple     =					d_model
				A_     :						Optional[Any]     =					encoder_ffn_dim
				A_     :						List[Any]     =					encoder_layers
				A_     :						Dict     =					encoder_attention_heads
				A_     :						Dict     =					decoder_ffn_dim
				A_     :						Union[str, Any]     =					decoder_layers
				A_     :						List[str]     =					decoder_attention_heads
				A_     :						List[Any]     =					dropout
				A_     :						List[str]     =					attention_dropout
				A_     :						str     =					activation_dropout
				A_     :						Tuple     =					activation_function
				A_     :						List[Any]     =					init_std
				A_     :						List[str]     =					encoder_layerdrop
				A_     :						str     =					decoder_layerdrop
				A_     :						Optional[Any]     =					use_cache
				A_     :						Any     =					encoder_layers
				A_     :						Tuple     =					scale_embedding  # scale factor will be sqrt(d_model) if True
				super().__init__(
				    pad_token_id=lowercase	,				eos_token_id=lowercase	,				is_encoder_decoder=lowercase	,				decoder_start_token_id=lowercase	,				forced_eos_token_id=lowercase	,				**lowercase	,				)


	@property
	def    _a     (self							):
				return self.encoder_attention_heads


	@property
	def    _a     (self							):
				return self.d_model




'''simple docstring'''




import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch







@require_torch
class      _lowerCAmelCase							:


	@property
	def    _a     (self							):
				return self.get_dummy_input()


	@property
	def    _a     (self							):
				if self.block_type == "down":
							return (4, 32, 16, 16)
				elif self.block_type == "mid":
							return (4, 32, 32, 32)
				elif self.block_type == "up":
							return (4, 32, 64, 64)

				raise ValueError(F'\'{self.block_type}\' is not a supported block_type. Set it to \'up\', \'mid\', or \'down\'.'							)


	def    _a     (self	,				lowercase=True	,				lowercase=False	,				lowercase=False	,				lowercase=False	,				):
				A_     :						List[str]     =					4
				A_     :						int     =					32
				A_     :						Optional[int]     =					(32, 32)

				A_     :						Optional[Any]     =					torch.manual_seed(0							)
				A_     :						int     =					torch.device(lowercase							)
				A_     :						int     =					(batch_size, num_channels) + sizes
				A_     :						Optional[int]     =					randn_tensor(lowercase	,				generator=lowercase	,				device=lowercase							)
				A_     :						Union[str, Any]     =					{"""hidden_states""": hidden_states}

				if include_temb:
							A_     :						str     =					128
							A_     :						List[Any]     =					randn_tensor((batch_size, temb_channels)	,				generator=lowercase	,				device=lowercase							)

				if include_res_hidden_states_tuple:
							A_     :						List[str]     =					torch.manual_seed(1							)
							A_     :						int     =					(randn_tensor(lowercase	,				generator=lowercase	,				device=lowercase							),)

				if include_encoder_hidden_states:
							A_     :						List[str]     =					floats_tensor((batch_size, 32, 32)							).to(lowercase							)

				if include_skip_sample:
							A_     :						Dict     =					randn_tensor(((batch_size, 3) + sizes)	,				generator=lowercase	,				device=lowercase							)

				return dummy_input


	def    _a     (self							):
				A_     :						Tuple     =					{
				    """in_channels""": 32,
				    """out_channels""": 32,
				    """temb_channels""": 128,
				}
				if self.block_type == "up":
							A_     :						Any     =					32

				if self.block_type == "mid":
							init_dict.pop("""out_channels"""							)

				A_     :						Optional[int]     =					self.dummy_input
				return init_dict, inputs_dict


	def    _a     (self	,				lowercase							):
				A_,   A_     :						Optional[Any]     =					self.prepare_init_args_and_inputs_for_common()
				A_     :						int     =					self.block_class(**lowercase							)
				unet_block.to(lowercase							)
				unet_block.eval()

				with torch.no_grad():
							A_     :						List[str]     =					unet_block(**lowercase							)

				if isinstance(lowercase	,				lowercase							):
							A_     :						Union[str, Any]     =					output[0]

				self.assertEqual(output.shape	,				self.output_shape							)

				A_     :						int     =					output[0, -1, -3:, -3:]
				A_     :						List[Any]     =					torch.tensor(lowercase							).to(lowercase							)
				assert torch_all_close(output_slice.flatten()	,				lowercase	,				atol=5E-3							)


	@unittest.skipIf(torch_device == """mps"""	,				"""Training is not supported in mps"""							)
	def    _a     (self							):
				A_,   A_     :						Tuple     =					self.prepare_init_args_and_inputs_for_common()
				A_     :						List[str]     =					self.block_class(**lowercase							)
				model.to(lowercase							)
				model.train()
				A_     :						Any     =					model(**lowercase							)

				if isinstance(lowercase	,				lowercase							):
							A_     :						str     =					output[0]

				A_     :						Union[str, Any]     =					torch.device(lowercase							)
				A_     :						Tuple     =					randn_tensor(output.shape	,				device=lowercase							)
				A_     :						List[str]     =					torch.nn.functional.mse_loss(lowercase	,				lowercase							)
				loss.backward()