'''simple docstring'''


import argparse
import copy


def  _lowerCamelCase   (				lowerCamelCase_ :							Union[str, Any]       ):



     """simple docstring"""





     UpperCAmelCase_							:       Union[str, Any]       =				{}

     with open(__lowerCamelCase       ) as f:
          for line in f:
               if line.split()[0] not in dict_of_neighbours:
                    UpperCAmelCase_							:       str       =				[]
                    _list.append([line.split()[1], line.split()[2]]       )
                    UpperCAmelCase_							:       List[Any]       =				_list
               else:
                    dict_of_neighbours[line.split()[0]].append(
                        [line.split()[1], line.split()[2]]       )
               if line.split()[1] not in dict_of_neighbours:
                    UpperCAmelCase_							:       Optional[Any]       =				[]
                    _list.append([line.split()[0], line.split()[2]]       )
                    UpperCAmelCase_							:       List[Any]       =				_list
               else:
                    dict_of_neighbours[line.split()[1]].append(
                        [line.split()[0], line.split()[2]]       )

     return dict_of_neighbours


def  _lowerCamelCase   (				lowerCamelCase_ :							int     ,					lowerCamelCase_ :							Optional[int]       ):



     """simple docstring"""





     with open(__lowerCamelCase       ) as f:
          UpperCAmelCase_							:       List[Any]       =				f.read(1       )
     UpperCAmelCase_							:       List[str]       =				start_node

     UpperCAmelCase_							:       Optional[Any]       =				[]

     UpperCAmelCase_							:       Dict       =				start_node

     UpperCAmelCase_							:       Dict       =				0
     while visiting not in first_solution:
          UpperCAmelCase_							:       Optional[Any]       =				10000
          for k in dict_of_neighbours[visiting]:
               if int(k[1]       ) < int(__lowerCamelCase       ) and k[0] not in first_solution:
                    UpperCAmelCase_							:       Optional[int]       =				k[1]
                    UpperCAmelCase_							:       List[Any]       =				k[0]

          first_solution.append(__lowerCamelCase       )
          UpperCAmelCase_							:       Optional[Any]       =				distance_of_first_solution + int(__lowerCamelCase       )
          UpperCAmelCase_							:       int       =				best_node

     first_solution.append(__lowerCamelCase       )

     UpperCAmelCase_							:       Optional[Any]       =				0
     for k in dict_of_neighbours[first_solution[-2]]:
          if k[0] == start_node:
               break
          position += 1

     UpperCAmelCase_							:       Any       =				(
         distance_of_first_solution
         + int(dict_of_neighbours[first_solution[-2]][position][1]       )
         - 10000
     )
     return first_solution, distance_of_first_solution


def  _lowerCamelCase   (				lowerCamelCase_ :							int     ,					lowerCamelCase_ :							List[Any]       ):



     """simple docstring"""





     UpperCAmelCase_							:       Tuple       =				[]

     for n in solution[1:-1]:
          UpperCAmelCase_							:       Any       =				solution.index(__lowerCamelCase       )
          for kn in solution[1:-1]:
               UpperCAmelCase_							:       Dict       =				solution.index(__lowerCamelCase       )
               if n == kn:
                    continue

               UpperCAmelCase_							:       int       =				copy.deepcopy(__lowerCamelCase       )
               UpperCAmelCase_							:       Dict       =				kn
               UpperCAmelCase_							:       Tuple       =				n

               UpperCAmelCase_							:       Tuple       =				0

               for k in _tmp[:-1]:
                    UpperCAmelCase_							:       Tuple       =				_tmp[_tmp.index(__lowerCamelCase       ) + 1]
                    for i in dict_of_neighbours[k]:
                         if i[0] == next_node:
                              UpperCAmelCase_							:       Any       =				distance + int(i[1]       )
               _tmp.append(__lowerCamelCase       )

               if _tmp not in neighborhood_of_solution:
                    neighborhood_of_solution.append(_tmp       )

     UpperCAmelCase_							:       Optional[Any]       =				len(neighborhood_of_solution[0]       ) - 1

     neighborhood_of_solution.sort(key=lambda lowerCamelCase_       : x[index_of_last_item_in_the_list]       )
     return neighborhood_of_solution


def  _lowerCamelCase   (				lowerCamelCase_ :							Union[str, Any]     ,					lowerCamelCase_ :							str     ,					lowerCamelCase_ :							Union[str, Any]     ,					lowerCamelCase_ :							List[str]     ,					lowerCamelCase_ :							Union[str, Any]       ):



     """simple docstring"""





     UpperCAmelCase_							:       Dict       =				1
     UpperCAmelCase_							:       List[str]       =				first_solution
     UpperCAmelCase_							:       List[str]       =				[]
     UpperCAmelCase_							:       List[Any]       =				distance_of_first_solution
     UpperCAmelCase_							:       List[str]       =				solution

     while count <= iters:
          UpperCAmelCase_							:       Optional[Any]       =				find_neighborhood(__lowerCamelCase     ,					__lowerCamelCase       )
          UpperCAmelCase_							:       Optional[Any]       =				0
          UpperCAmelCase_							:       Union[str, Any]       =				neighborhood[index_of_best_solution]
          UpperCAmelCase_							:       List[str]       =				len(__lowerCamelCase       ) - 1

          UpperCAmelCase_							:       Union[str, Any]       =				False
          while not found:
               UpperCAmelCase_							:       str       =				0
               while i < len(__lowerCamelCase       ):
                    if best_solution[i] != solution[i]:
                         UpperCAmelCase_							:       Optional[Any]       =				best_solution[i]
                         UpperCAmelCase_							:       Optional[Any]       =				solution[i]
                         break
                    UpperCAmelCase_							:       int       =				i + 1

               if [first_exchange_node, second_exchange_node] not in tabu_list and [
                   second_exchange_node,
                   first_exchange_node,
               ] not in tabu_list:
                    tabu_list.append([first_exchange_node, second_exchange_node]       )
                    UpperCAmelCase_							:       Union[str, Any]       =				True
                    UpperCAmelCase_							:       Dict       =				best_solution[:-1]
                    UpperCAmelCase_							:       List[str]       =				neighborhood[index_of_best_solution][best_cost_index]
                    if cost < best_cost:
                         UpperCAmelCase_							:       str       =				cost
                         UpperCAmelCase_							:       int       =				solution
               else:
                    UpperCAmelCase_							:       Optional[Any]       =				index_of_best_solution + 1
                    UpperCAmelCase_							:       List[str]       =				neighborhood[index_of_best_solution]

          if len(__lowerCamelCase       ) >= size:
               tabu_list.pop(0       )

          UpperCAmelCase_							:       Optional[Any]       =				count + 1

     return best_solution_ever, best_cost


def  _lowerCamelCase   (				lowerCamelCase_ :							Optional[int]=None       ):



     """simple docstring"""





     UpperCAmelCase_							:       Optional[Any]       =				generate_neighbours(args.File       )

     UpperCAmelCase_       ,      UpperCAmelCase_							:       List[Any]       =				generate_first_solution(
         args.File     ,					__lowerCamelCase       )

     UpperCAmelCase_       ,      UpperCAmelCase_							:       int       =				tabu_search(
         __lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					args.Iterations     ,					args.Size     ,					)

     print(F'''Best solution: {best_sol}, with total distance: {best_cost}.'''       )


if __name__ == "__main__":
 snake_case__					:      Tuple				      =  argparse.ArgumentParser(description='''Tabu Search''')
 parser.add_argument(
     '''-f''',
     '''--File''',
     type=str,
     help='''Path to the file containing the data''',
     required=True,
 )
 parser.add_argument(
     '''-i''',
     '''--Iterations''',
     type=int,
     help='''How many iterations the algorithm should perform''',
     required=True,
 )
 parser.add_argument(
     '''-s''', '''--Size''', type=int, help='''Size of the tabu list''', required=True
 )

 # Pass the arguments to main method
 main(parser.parse_args())







'''simple docstring'''


from typing import List, Optional

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


snake_case__					:      List[Any]				      =  logging.get_logger(__name__)

snake_case__					:      Optional[Any]				      =  {
    '''huggingface/autoformer-tourism-monthly''': '''https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json''',
}






class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_	):







  '''simple docstring'''






  lowerCamelCase_		:List[str]						   =		'''autoformer'''
  lowerCamelCase_		:Optional[Any]						   =		{
      '''hidden_size''': '''d_model''',
      '''num_attention_heads''': '''encoder_attention_heads''',
      '''num_hidden_layers''': '''encoder_layers''',
  }


  def __init__(			self				,		snake_case_ = None				,		snake_case_ = None				,		snake_case_ = "student_t"				,		snake_case_ = "nll"				,		snake_case_ = 1				,		snake_case_ = [1, 2, 3, 4, 5, 6, 7]				,		snake_case_ = True				,		snake_case_ = 0				,		snake_case_ = 0				,		snake_case_ = 0				,		snake_case_ = 0				,		snake_case_ = None				,		snake_case_ = None				,		snake_case_ = 6_4				,		snake_case_ = 2				,		snake_case_ = 2				,		snake_case_ = 2				,		snake_case_ = 2				,		snake_case_ = 3_2				,		snake_case_ = 3_2				,		snake_case_ = "gelu"				,		snake_case_ = 0.1				,		snake_case_ = 0.1				,		snake_case_ = 0.1				,		snake_case_ = 0.1				,		snake_case_ = 0.1				,		snake_case_ = 1_0_0				,		snake_case_ = 0.02				,		snake_case_ = True				,		snake_case_=True				,		snake_case_ = 1_0				,		snake_case_ = 2_5				,		snake_case_ = 3				,		**snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       List[Any]       =				prediction_length
       UpperCAmelCase_							:       List[str]       =				context_length if context_length is not None else prediction_length
       UpperCAmelCase_							:       Optional[int]       =				distribution_output
       UpperCAmelCase_							:       Optional[int]       =				loss
       UpperCAmelCase_							:       Union[str, Any]       =				input_size
       UpperCAmelCase_							:       int       =				num_time_features
       UpperCAmelCase_							:       List[str]       =				lags_sequence
       UpperCAmelCase_							:       Any       =				scaling
       UpperCAmelCase_							:       Any       =				num_dynamic_real_features
       UpperCAmelCase_							:       int       =				num_static_real_features
       UpperCAmelCase_							:       Optional[Any]       =				num_static_categorical_features
       if cardinality is not None and num_static_categorical_features > 0:
            if len(snake_case_						) != num_static_categorical_features:
                 raise ValueError(
                     'The cardinality should be a list of the same length as `num_static_categorical_features`'						)
            UpperCAmelCase_							:       List[Any]       =				cardinality
       else:
            UpperCAmelCase_							:       Optional[int]       =				[0]
       if embedding_dimension is not None and num_static_categorical_features > 0:
            if len(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_							:       List[str]       =				embedding_dimension
       else:
            UpperCAmelCase_							:       List[Any]       =				[min(5_0				,		(cat + 1) // 2						) for cat in self.cardinality]
       UpperCAmelCase_							:       List[str]       =				num_parallel_samples

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

       UpperCAmelCase_							:       str       =				dropout
       UpperCAmelCase_							:       Optional[int]       =				attention_dropout
       UpperCAmelCase_							:       Tuple       =				activation_dropout
       UpperCAmelCase_							:       Any       =				encoder_layerdrop
       UpperCAmelCase_							:       Tuple       =				decoder_layerdrop

       UpperCAmelCase_							:       List[str]       =				activation_function
       UpperCAmelCase_							:       Tuple       =				init_std

       UpperCAmelCase_							:       Union[str, Any]       =				use_cache

       # Autoformer
       UpperCAmelCase_							:       Any       =				label_length
       UpperCAmelCase_							:       Union[str, Any]       =				moving_average
       UpperCAmelCase_							:       Tuple       =				autocorrelation_factor

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






  @property
  def _UpperCamelCase					(			self						):




       '''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
       )






