


'''simple docstring'''





from typing import List, Optional, Union

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


UpperCAmelCase_   :				str						      = logging.get_logger(__name__)

UpperCAmelCase_   :				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 				SCREAMING_SNAKE_CASE__						(       lowercase__    ):
      snake_case__       :  Any       =		'''informer'''
      snake_case__       :  Tuple       =		{
          '''hidden_size''': '''d_model''',
          '''num_attention_heads''': '''encoder_attention_heads''',
          '''num_hidden_layers''': '''encoder_layers''',
      }
      def __init__( self       : Optional[Any]  ,							SCREAMING_SNAKE_CASE__       : Optional[int] = None  ,							SCREAMING_SNAKE_CASE__       : Optional[int] = None  ,							SCREAMING_SNAKE_CASE__       : str = "student_t"  ,							SCREAMING_SNAKE_CASE__       : str = "nll"  ,							SCREAMING_SNAKE_CASE__       : int = 1  ,							SCREAMING_SNAKE_CASE__       : List[int] = None  ,							SCREAMING_SNAKE_CASE__       : Optional[Union[str, bool]] = "mean"  ,							SCREAMING_SNAKE_CASE__       : int = 0  ,							SCREAMING_SNAKE_CASE__       : int = 0  ,							SCREAMING_SNAKE_CASE__       : int = 0  ,							SCREAMING_SNAKE_CASE__       : int = 0  ,							SCREAMING_SNAKE_CASE__       : Optional[List[int]] = None  ,							SCREAMING_SNAKE_CASE__       : Optional[List[int]] = None  ,							SCREAMING_SNAKE_CASE__       : int = 6_4  ,							SCREAMING_SNAKE_CASE__       : int = 3_2  ,							SCREAMING_SNAKE_CASE__       : int = 3_2  ,							SCREAMING_SNAKE_CASE__       : int = 2  ,							SCREAMING_SNAKE_CASE__       : int = 2  ,							SCREAMING_SNAKE_CASE__       : int = 2  ,							SCREAMING_SNAKE_CASE__       : int = 2  ,							SCREAMING_SNAKE_CASE__       : bool = True  ,							SCREAMING_SNAKE_CASE__       : str = "gelu"  ,							SCREAMING_SNAKE_CASE__       : float = 0.05  ,							SCREAMING_SNAKE_CASE__       : float = 0.1  ,							SCREAMING_SNAKE_CASE__       : float = 0.1  ,							SCREAMING_SNAKE_CASE__       : float = 0.1  ,							SCREAMING_SNAKE_CASE__       : float = 0.1  ,							SCREAMING_SNAKE_CASE__       : int = 1_0_0  ,							SCREAMING_SNAKE_CASE__       : float = 0.02  ,							SCREAMING_SNAKE_CASE__       : List[Any]=True  ,							SCREAMING_SNAKE_CASE__       : str = "prob"  ,							SCREAMING_SNAKE_CASE__       : int = 5  ,							SCREAMING_SNAKE_CASE__       : bool = True  ,							**SCREAMING_SNAKE_CASE__       : Union[str, Any]  ,							)	->    Any:
             # time series specific configuration
             a_      :	int							=						prediction_length
             a_      :	Any							=						context_length or prediction_length
             a_      :	List[Any]							=						distribution_output
             a_      :	Tuple							=						loss
             a_      :	str							=						input_size
             a_      :	int							=						num_time_features
             a_      :	Tuple							=						lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
             a_      :	Optional[int]							=						scaling
             a_      :	List[Any]							=						num_dynamic_real_features
             a_      :	str							=						num_static_real_features
             a_      :	int							=						num_static_categorical_features

             # set cardinality
             if cardinality 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`'  )
                    a_      :	Tuple							=						cardinality
             else:
                    a_      :	Union[str, Any]							=						[0]

             # set embedding_dimension
             if embedding_dimension 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`'  )
                    a_      :	Dict							=						embedding_dimension
             else:
                    a_      :	str							=						[min(5_0  ,							(cat + 1) // 2  ) for cat in self.cardinality]

             a_      :	Dict							=						num_parallel_samples

             # Transformer architecture configuration
             a_      :	int							=						input_size * len(self.lags_sequence  ) + self._number_of_features
             a_      :	Optional[Any]							=						d_model
             a_      :	Union[str, Any]							=						encoder_attention_heads
             a_      :	Dict							=						decoder_attention_heads
             a_      :	str							=						encoder_ffn_dim
             a_      :	int							=						decoder_ffn_dim
             a_      :	List[str]							=						encoder_layers
             a_      :	str							=						decoder_layers

             a_      :	int							=						dropout
             a_      :	List[Any]							=						attention_dropout
             a_      :	Union[str, Any]							=						activation_dropout
             a_      :	int							=						encoder_layerdrop
             a_      :	Dict							=						decoder_layerdrop

             a_      :	int							=						activation_function
             a_      :	Any							=						init_std

             a_      :	int							=						use_cache

             # Informer
             a_      :	List[Any]							=						attention_type
             a_      :	Tuple							=						sampling_factor
             a_      :	Union[str, Any]							=						distil

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

      @property
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    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
             )






import json
import os
import unittest

from transformers import BatchEncoding, MvpTokenizer, MvpTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin, filter_roberta_detectors
@require_tokenizers
class 				SCREAMING_SNAKE_CASE__						(       lowercase__		,					unittest.TestCase    ):
      snake_case__       :  List[str]       =		MvpTokenizer
      snake_case__       :  Dict       =		MvpTokenizerFast
      snake_case__       :  Any       =		True
      snake_case__       :  Optional[int]       =		filter_roberta_detectors
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    Optional[int]:
             super().setUp()
             a_      :	Any							=						[
                 'l',
                 'o',
                 'w',
                 'e',
                 'r',
                 's',
                 't',
                 'i',
                 'd',
                 'n',
                 '\u0120',
                 '\u0120l',
                 '\u0120n',
                 '\u0120lo',
                 '\u0120low',
                 'er',
                 '\u0120lowest',
                 '\u0120newer',
                 '\u0120wider',
                 '<unk>',
             ]
             a_      :	int							=						dict(zip(SCREAMING_SNAKE_CASE__  ,							range(len(SCREAMING_SNAKE_CASE__  )  )  )  )
             a_      :	int							=						['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
             a_      :	str							=						{'unk_token': '<unk>'}

             a_      :	Tuple							=						os.path.join(self.tmpdirname  ,							VOCAB_FILES_NAMES['vocab_file']  )
             a_      :	Optional[int]							=						os.path.join(self.tmpdirname  ,							VOCAB_FILES_NAMES['merges_file']  )
             with open(self.vocab_file  ,							'w'  ,							encoding='utf-8'  ) as fp:
                    fp.write(json.dumps(SCREAMING_SNAKE_CASE__  ) + '\n'  )
             with open(self.merges_file  ,							'w'  ,							encoding='utf-8'  ) as fp:
                    fp.write('\n'.join(SCREAMING_SNAKE_CASE__  )  )
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  ,							**SCREAMING_SNAKE_CASE__       : str  )	->    List[Any]:
             kwargs.update(self.special_tokens_map  )
             return self.tokenizer_class.from_pretrained(self.tmpdirname  ,							**SCREAMING_SNAKE_CASE__  )
      def  SCREAMING_SNAKE_CASE							( self       : Any  ,							**SCREAMING_SNAKE_CASE__       : Optional[Any]  )	->    List[str]:
             kwargs.update(self.special_tokens_map  )
             return self.rust_tokenizer_class.from_pretrained(self.tmpdirname  ,							**SCREAMING_SNAKE_CASE__  )
      def  SCREAMING_SNAKE_CASE							( self       : Optional[int]  ,							SCREAMING_SNAKE_CASE__       : Any  )	->    Union[str, Any]:
             return "lower newer", "lower newer"
      @cached_property
      def  SCREAMING_SNAKE_CASE							( self       : List[str]  )	->    str:
             return MvpTokenizer.from_pretrained('RUCAIBox/mvp'  )
      @cached_property
      def  SCREAMING_SNAKE_CASE							( self       : Any  )	->    Optional[int]:
             return MvpTokenizerFast.from_pretrained('RUCAIBox/mvp'  )
      @require_torch
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  )	->    Union[str, Any]:
             a_      :	Union[str, Any]							=						['A long paragraph for summarization.', 'Another paragraph for summarization.']
             a_      :	List[Any]							=						[0, 2_5_0, 2_5_1, 1_7_8_1_8, 1_3, 3_9_1_8_6, 1_9_3_8, 4, 2]

             for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                    a_      :	List[str]							=						tokenizer(SCREAMING_SNAKE_CASE__  ,							max_length=len(SCREAMING_SNAKE_CASE__  )  ,							padding=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  )
                    self.assertIsInstance(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )

                    self.assertEqual((2, 9)  ,							batch.input_ids.shape  )
                    self.assertEqual((2, 9)  ,							batch.attention_mask.shape  )
                    a_      :	Optional[Any]							=						batch.input_ids.tolist()[0]
                    self.assertListEqual(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )
                    # Test that special tokens are reset
      @require_torch
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    Optional[Any]:
             a_      :	Any							=						['A long paragraph for summarization.', 'Another paragraph for summarization.']
             for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                    a_      :	Optional[Any]							=						tokenizer(SCREAMING_SNAKE_CASE__  ,							padding=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  )
                    # check if input_ids are returned and no labels
                    self.assertIn('input_ids'  ,							SCREAMING_SNAKE_CASE__  )
                    self.assertIn('attention_mask'  ,							SCREAMING_SNAKE_CASE__  )
                    self.assertNotIn('labels'  ,							SCREAMING_SNAKE_CASE__  )
                    self.assertNotIn('decoder_attention_mask'  ,							SCREAMING_SNAKE_CASE__  )
      @require_torch
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    int:
             a_      :	Union[str, Any]							=						[
                 'Summary of the text.',
                 'Another summary.',
             ]
             for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                    a_      :	List[str]							=						tokenizer(text_target=SCREAMING_SNAKE_CASE__  ,							max_length=3_2  ,							padding='max_length'  ,							return_tensors='pt'  )
                    self.assertEqual(3_2  ,							targets['input_ids'].shape[1]  )
      @require_torch
      def  SCREAMING_SNAKE_CASE							( self       : Tuple  )	->    List[str]:
             for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                    a_      :	Dict							=						tokenizer(
                        ['I am a small frog' * 1_0_2_4, 'I am a small frog']  ,							padding=SCREAMING_SNAKE_CASE__  ,							truncation=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  )
                    self.assertIsInstance(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )
                    self.assertEqual(batch.input_ids.shape  ,							(2, 1_0_2_4)  )
      @require_torch
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Tuple:
             a_      :	Dict							=						['A long paragraph for summarization.']
             a_      :	Dict							=						[
                 'Summary of the text.',
             ]
             for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                    a_      :	Union[str, Any]							=						tokenizer(SCREAMING_SNAKE_CASE__  ,							text_target=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  )
                    a_      :	Dict							=						inputs['input_ids']
                    a_      :	str							=						inputs['labels']
                    self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()  )
                    self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()  )
                    self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()  )
                    self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()  )
      def  SCREAMING_SNAKE_CASE							( self       : Union[str, Any]  )	->    Union[str, Any]:
             pass

      def  SCREAMING_SNAKE_CASE							( self       : Any  )	->    int:
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
                           a_      :	List[str]							=						self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__  ,							**SCREAMING_SNAKE_CASE__  )
                           a_      :	Tuple							=						self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__  ,							**SCREAMING_SNAKE_CASE__  )
                           a_      :	int							=						'A, <mask> AllenNLP sentence.'
                           a_      :	Optional[Any]							=						tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE__  ,							add_special_tokens=SCREAMING_SNAKE_CASE__  ,							return_token_type_ids=SCREAMING_SNAKE_CASE__  )
                           a_      :	int							=						tokenizer_p.encode_plus(SCREAMING_SNAKE_CASE__  ,							add_special_tokens=SCREAMING_SNAKE_CASE__  ,							return_token_type_ids=SCREAMING_SNAKE_CASE__  )

                           # token_type_ids should put 0 everywhere
                           self.assertEqual(sum(tokens_r['token_type_ids']  )  ,							sum(tokens_p['token_type_ids']  )  )

                           # attention_mask should put 1 everywhere, so sum over length should be 1
                           self.assertEqual(
                               sum(tokens_r['attention_mask']  ) / len(tokens_r['attention_mask']  )  ,							sum(tokens_p['attention_mask']  ) / len(tokens_p['attention_mask']  )  ,							)

                           a_      :	str							=						tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']  )
                           a_      :	Any							=						tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']  )

                           # Rust correctly handles the space before the mask while python doesnt
                           self.assertSequenceEqual(tokens_p['input_ids']  ,							[0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]  )
                           self.assertSequenceEqual(tokens_r['input_ids']  ,							[0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]  )

                           self.assertSequenceEqual(
                               SCREAMING_SNAKE_CASE__  ,							['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']  )
                           self.assertSequenceEqual(
                               SCREAMING_SNAKE_CASE__  ,							['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']  )


