


from typing import List, Optional

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


lowerCAmelCase__  :Tuple             =							logging.get_logger(__name__)

lowerCAmelCase__  :List[str]             =							{
    '''huggingface/autoformer-tourism-monthly''': '''https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json''',
}

class 		__a				(    UpperCAmelCase      ):
		_a     :  Dict           =     'autoformer'
		_a     :  int           =     {
		    'hidden_size': 'd_model',
		    'num_attention_heads': 'encoder_attention_heads',
		    'num_hidden_layers': 'encoder_layers',
		}
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = "student_t"      ,   _SCREAMING_SNAKE_CASE = "nll"      ,   _SCREAMING_SNAKE_CASE = 1      ,   _SCREAMING_SNAKE_CASE = [1, 2, 3, 4, 5, 6, 7]      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE = 0      ,   _SCREAMING_SNAKE_CASE = 0      ,   _SCREAMING_SNAKE_CASE = 0      ,   _SCREAMING_SNAKE_CASE = 0      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = 64      ,   _SCREAMING_SNAKE_CASE = 2      ,   _SCREAMING_SNAKE_CASE = 2      ,   _SCREAMING_SNAKE_CASE = 2      ,   _SCREAMING_SNAKE_CASE = 2      ,   _SCREAMING_SNAKE_CASE = 32      ,   _SCREAMING_SNAKE_CASE = 32      ,   _SCREAMING_SNAKE_CASE = "gelu"      ,   _SCREAMING_SNAKE_CASE = 0.1      ,   _SCREAMING_SNAKE_CASE = 0.1      ,   _SCREAMING_SNAKE_CASE = 0.1      ,   _SCREAMING_SNAKE_CASE = 0.1      ,   _SCREAMING_SNAKE_CASE = 0.1      ,   _SCREAMING_SNAKE_CASE = 100      ,   _SCREAMING_SNAKE_CASE = 0.02      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE = 10      ,   _SCREAMING_SNAKE_CASE = 25      ,   _SCREAMING_SNAKE_CASE = 3      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      prediction_length
									_UpperCAmelCase					=      context_length if context_length is not None else prediction_length
									_UpperCAmelCase					=      distribution_output
									_UpperCAmelCase					=      loss
									_UpperCAmelCase					=      input_size
									_UpperCAmelCase					=      num_time_features
									_UpperCAmelCase					=      lags_sequence
									_UpperCAmelCase					=      scaling
									_UpperCAmelCase					=      num_dynamic_real_features
									_UpperCAmelCase					=      num_static_real_features
									_UpperCAmelCase					=      num_static_categorical_features
									if cardinality is not None and num_static_categorical_features > 0:
																if len(_SCREAMING_SNAKE_CASE						) != num_static_categorical_features:
																							raise ValueError(
																							    'The cardinality should be a list of the same length as `num_static_categorical_features`'						)
																_UpperCAmelCase					=      cardinality
									else:
																_UpperCAmelCase					=      [0]
									if embedding_dimension is not None and num_static_categorical_features > 0:
																if len(_SCREAMING_SNAKE_CASE						) != num_static_categorical_features:
																							raise ValueError(
																							    'The embedding dimension should be a list of the same length as `num_static_categorical_features`'						)
																_UpperCAmelCase					=      embedding_dimension
									else:
																_UpperCAmelCase					=      [min(50      ,   (cat + 1) // 2						) for cat in self.cardinality]
									_UpperCAmelCase					=      num_parallel_samples

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

									_UpperCAmelCase					=      dropout
									_UpperCAmelCase					=      attention_dropout
									_UpperCAmelCase					=      activation_dropout
									_UpperCAmelCase					=      encoder_layerdrop
									_UpperCAmelCase					=      decoder_layerdrop

									_UpperCAmelCase					=      activation_function
									_UpperCAmelCase					=      init_std

									_UpperCAmelCase					=      use_cache

									# Autoformer
									_UpperCAmelCase					=      label_length
									_UpperCAmelCase					=      moving_average
									_UpperCAmelCase					=      autocorrelation_factor

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






		@property
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									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
									)




from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
		import PIL


lowerCAmelCase__  :List[str]             =							logging.get_logger(__name__)

class 		__a				(    UpperCAmelCase      ):
		_a     :  Optional[int]           =     ['pixel_values']
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = PIL.Image.BICUBIC      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = 1 / 255      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE = True      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	None:




									"""simple docstring"""





									super().__init__(**_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      size if size is not None else {'height': 256, 'width': 256}
									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      crop_size if crop_size is not None else {'height': 224, 'width': 224}
									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE      ,   param_name='crop_size'						)

									_UpperCAmelCase					=      do_resize
									_UpperCAmelCase					=      size
									_UpperCAmelCase					=      resample
									_UpperCAmelCase					=      do_center_crop
									_UpperCAmelCase					=      crop_size
									_UpperCAmelCase					=      do_rescale
									_UpperCAmelCase					=      rescale_factor
									_UpperCAmelCase					=      do_normalize
									_UpperCAmelCase					=      image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
									_UpperCAmelCase					=      image_std if image_std is not None else IMAGENET_STANDARD_STD
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = PIL.Image.BICUBIC      ,   _SCREAMING_SNAKE_CASE = None      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	np.ndarray:




									"""simple docstring"""





									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE						)
									if "height" not in size or "width" not in size:
																raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''						)
									return resize(
									    _SCREAMING_SNAKE_CASE      ,   size=(size['height'], size['width'])      ,   resample=_SCREAMING_SNAKE_CASE      ,   data_format=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = None      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	np.ndarray:




									"""simple docstring"""





									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE						)
									if "height" not in size or "width" not in size:
																raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''						)
									return center_crop(_SCREAMING_SNAKE_CASE      ,   size=(size['height'], size['width'])      ,   data_format=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = None      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	str:




									"""simple docstring"""





									return rescale(_SCREAMING_SNAKE_CASE      ,   scale=_SCREAMING_SNAKE_CASE      ,   data_format=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = None      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	np.ndarray:




									"""simple docstring"""





									return normalize(_SCREAMING_SNAKE_CASE      ,   mean=_SCREAMING_SNAKE_CASE      ,   std=_SCREAMING_SNAKE_CASE      ,   data_format=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)






		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = None      ,   _SCREAMING_SNAKE_CASE = ChannelDimension.FIRST      ,   **_SCREAMING_SNAKE_CASE      ,   )			->	PIL.Image.Image:




									"""simple docstring"""





									_UpperCAmelCase					=      do_resize if do_resize is not None else self.do_resize
									_UpperCAmelCase					=      resample if resample is not None else self.resample
									_UpperCAmelCase					=      do_center_crop if do_center_crop is not None else self.do_center_crop
									_UpperCAmelCase					=      do_rescale if do_rescale is not None else self.do_rescale
									_UpperCAmelCase					=      rescale_factor if rescale_factor is not None else self.rescale_factor
									_UpperCAmelCase					=      do_normalize if do_normalize is not None else self.do_normalize
									_UpperCAmelCase					=      image_mean if image_mean is not None else self.image_mean
									_UpperCAmelCase					=      image_std if image_std is not None else self.image_std

									_UpperCAmelCase					=      size if size is not None else self.size
									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      crop_size if crop_size is not None else self.crop_size
									_UpperCAmelCase					=      get_size_dict(_SCREAMING_SNAKE_CASE      ,   param_name='crop_size'						)

									_UpperCAmelCase					=      make_list_of_images(_SCREAMING_SNAKE_CASE						)

									if not valid_images(_SCREAMING_SNAKE_CASE						):
																raise ValueError(
																    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
																    'torch.Tensor, tf.Tensor or jax.ndarray.'						)

									if do_resize and size is None or resample is None:
																raise ValueError('Size and resample must be specified if do_resize is True.'						)

									if do_center_crop and crop_size is None:
																raise ValueError('Crop size must be specified if do_center_crop is True.'						)

									if do_rescale and rescale_factor is None:
																raise ValueError('Rescale factor must be specified if do_rescale is True.'						)

									if do_normalize and (image_mean is None or image_std is None):
																raise ValueError('Image mean and std must be specified if do_normalize is True.'						)

									# All transformations expect numpy arrays.
									_UpperCAmelCase					=      [to_numpy_array(_SCREAMING_SNAKE_CASE						) for image in images]

									if do_resize:
																_UpperCAmelCase					=      [self.resize(image=_SCREAMING_SNAKE_CASE      ,   size=_SCREAMING_SNAKE_CASE      ,   resample=_SCREAMING_SNAKE_CASE						) for image in images]

									if do_center_crop:
																_UpperCAmelCase					=      [self.center_crop(image=_SCREAMING_SNAKE_CASE      ,   size=_SCREAMING_SNAKE_CASE						) for image in images]

									if do_rescale:
																_UpperCAmelCase					=      [self.rescale(image=_SCREAMING_SNAKE_CASE      ,   scale=_SCREAMING_SNAKE_CASE						) for image in images]

									if do_normalize:
																_UpperCAmelCase					=      [self.normalize(image=_SCREAMING_SNAKE_CASE      ,   mean=_SCREAMING_SNAKE_CASE      ,   std=_SCREAMING_SNAKE_CASE						) for image in images]

									_UpperCAmelCase					=      [to_channel_dimension_format(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						) for image in images]

									_UpperCAmelCase					=      {'pixel_values': images}
									return BatchFeature(data=_SCREAMING_SNAKE_CASE      ,   tensor_type=_SCREAMING_SNAKE_CASE						)
