


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       _UpperCamelCase    :

				"""simple docstring"""







				@property
				def      _UpperCAmelCase					(						self   )	->				Any:
					return self.get_dummy_input()

				@property
				def      _UpperCAmelCase					(						self   )	->				Union[str, Any]:
					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      _UpperCAmelCase					(						self				,   a__=True				,   a__=False				,   a__=False				,   a__=False				,   )	->				Optional[Any]:
					A								=				4
					A								=				32
					A								=				(32, 32)

					A								=				torch.manual_seed(0   )
					A								=				torch.device(a__   )
					A								=				(batch_size, num_channels) + sizes
					A								=				randn_tensor(a__				,   generator=a__				,   device=a__   )
					A								=				{"""hidden_states""": hidden_states}

					if include_temb:
						A								=				128
						A								=				randn_tensor((batch_size, temb_channels)				,   generator=a__				,   device=a__   )

					if include_res_hidden_states_tuple:
						A								=				torch.manual_seed(1   )
						A								=				(randn_tensor(a__				,   generator=a__				,   device=a__   ),)

					if include_encoder_hidden_states:
						A								=				floats_tensor((batch_size, 32, 32)   ).to(a__   )

					if include_skip_sample:
						A								=				randn_tensor(((batch_size, 3) + sizes)				,   generator=a__				,   device=a__   )

					return dummy_input

				def      _UpperCAmelCase					(						self   )	->				int:
					A								=				{
					    """in_channels""": 32,
					    """out_channels""": 32,
					    """temb_channels""": 128,
					}
					if self.block_type == "up":
						A								=				32

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

					A								=				self.dummy_input
					return init_dict, inputs_dict

				def      _UpperCAmelCase					(						self				,   a__   )	->				Optional[int]:
					A					,			A								=				self.prepare_init_args_and_inputs_for_common()
					A								=				self.block_class(**a__   )
					unet_block.to(a__   )
					unet_block.eval()

					with torch.no_grad():
						A								=				unet_block(**a__   )

					if isinstance(a__				,   a__   ):
						A								=				output[0]

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

					A								=				output[0, -1, -3:, -3:]
					A								=				torch.tensor(a__   ).to(a__   )
					assert torch_all_close(output_slice.flatten()				,   a__				,   atol=5e-3   )

				@unittest.skipIf(torch_device == """mps"""				,   """Training is not supported in mps"""   )
				def      _UpperCAmelCase					(						self   )	->				str:
					A					,			A								=				self.prepare_init_args_and_inputs_for_common()
					A								=				self.block_class(**a__   )
					model.to(a__   )
					model.train()
					A								=				model(**a__   )

					if isinstance(a__				,   a__   ):
						A								=				output[0]

					A								=				torch.device(a__   )
					A								=				randn_tensor(output.shape				,   device=a__   )
					A								=				torch.nn.functional.mse_loss(a__				,   a__   )
					loss.backward()







from typing import List, Optional, Union

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


_lowercase       :      Optional[Any]	=	logging.get_logger(__name__)

_lowercase       :      List[str]	=	{
    "huggingface/informer-tourism-monthly": (
        "https://huggingface.co/huggingface/informer-tourism-monthly/resolve/main/config.json"
    ),
    # See all Informer models at https://huggingface.co/models?filter=informer
}






class       _UpperCamelCase    (					__snake_case				):

				"""simple docstring"""







				lowerCAmelCase 		= 'informer'
				lowerCAmelCase 		= {
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'encoder_attention_heads',
				    'num_hidden_layers': 'encoder_layers',
				}

				def __init__(						self				,   a__ = None				,   a__ = None				,   a__ = "student_t"				,   a__ = "nll"				,   a__ = 1				,   a__ = None				,   a__ = "mean"				,   a__ = 0				,   a__ = 0				,   a__ = 0				,   a__ = 0				,   a__ = None				,   a__ = None				,   a__ = 64				,   a__ = 32				,   a__ = 32				,   a__ = 2				,   a__ = 2				,   a__ = 2				,   a__ = 2				,   a__ = True				,   a__ = "gelu"				,   a__ = 0.05				,   a__ = 0.1				,   a__ = 0.1				,   a__ = 0.1				,   a__ = 0.1				,   a__ = 100				,   a__ = 0.02				,   a__=True				,   a__ = "prob"				,   a__ = 5				,   a__ = True				,   **a__				,   )	->				Union[str, Any]:
					# time series specific configuration
					A								=				prediction_length
					A								=				context_length or prediction_length
					A								=				distribution_output
					A								=				loss
					A								=				input_size
					A								=				num_time_features
					A								=				lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
					A								=				scaling
					A								=				num_dynamic_real_features
					A								=				num_static_real_features
					A								=				num_static_categorical_features

					# set cardinality
					if cardinality and num_static_categorical_features > 0:
						if len(a__   ) != num_static_categorical_features:
							raise ValueError(
							    """The cardinality should be a list of the same length as `num_static_categorical_features`"""   )
						A								=				cardinality
					else:
						A								=				[0]

					# set embedding_dimension
					if embedding_dimension and num_static_categorical_features > 0:
						if len(a__   ) != num_static_categorical_features:
							raise ValueError(
							    """The embedding dimension should be a list of the same length as `num_static_categorical_features`"""   )
						A								=				embedding_dimension
					else:
						A								=				[min(50				,   (cat + 1) // 2   ) for cat in self.cardinality]

					A								=				num_parallel_samples

					# Transformer architecture configuration
					A								=				input_size * len(self.lags_sequence   ) + self._number_of_features
					A								=				d_model
					A								=				encoder_attention_heads
					A								=				decoder_attention_heads
					A								=				encoder_ffn_dim
					A								=				decoder_ffn_dim
					A								=				encoder_layers
					A								=				decoder_layers

					A								=				dropout
					A								=				attention_dropout
					A								=				activation_dropout
					A								=				encoder_layerdrop
					A								=				decoder_layerdrop

					A								=				activation_function
					A								=				init_std

					A								=				use_cache

					# Informer
					A								=				attention_type
					A								=				sampling_factor
					A								=				distil

					super().__init__(is_encoder_decoder=a__				,   **a__   )

				@property
				def      _UpperCAmelCase					(						self   )	->				int:
					return (
					    sum(self.embedding_dimension   )
					    + self.num_dynamic_real_features
					    + self.num_time_features
					    + self.num_static_real_features
					    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
					)



