


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


__snake_case   							=						{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

__snake_case   							=						{
    '''vocab_file''': {
        '''unc-nlp/lxmert-base-uncased''': '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt''',
    },
    '''tokenizer_file''': {
        '''unc-nlp/lxmert-base-uncased''': (
            '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json'''
        ),
    },
}

__snake_case   							=						{
    '''unc-nlp/lxmert-base-uncased''': 5_1_2,
}

__snake_case   							=						{
    '''unc-nlp/lxmert-base-uncased''': {'''do_lower_case''': True},
}



class 	__lowerCamelCase			(_a						):
       _lowercase											=     VOCAB_FILES_NAMES
       _lowercase											=     PRETRAINED_VOCAB_FILES_MAP
       _lowercase											=     PRETRAINED_INIT_CONFIGURATION
       _lowercase											=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       _lowercase											=     LxmertTokenizer







       def __init__(			self: Tuple,A_: str=None,A_: Any=None,A_: List[Any]=True,A_: int="[UNK]",A_: Union[str, Any]="[SEP]",A_: str="[PAD]",A_: Dict="[CLS]",A_: int="[MASK]",A_: int=True,A_: Optional[int]=None,**A_: Union[str, Any],):






            '''simple docstring'''




            super().__init__(
                A_,tokenizer_file=A_,do_lower_case=A_,unk_token=A_,sep_token=A_,pad_token=A_,cls_token=A_,mask_token=A_,tokenize_chinese_chars=A_,strip_accents=A_,**A_,)

            __UpperCamelCase =			json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
            if (
                normalizer_state.get('lowercase',A_					) != do_lower_case
                or normalizer_state.get('strip_accents',A_					) != strip_accents
                or normalizer_state.get('handle_chinese_chars',A_					) != tokenize_chinese_chars
            ):
                 __UpperCamelCase =			getattr(A_,normalizer_state.pop('type'					)					)
                 __UpperCamelCase =			do_lower_case
                 __UpperCamelCase =			strip_accents
                 __UpperCamelCase =			tokenize_chinese_chars
                 __UpperCamelCase =			normalizer_class(**A_					)

            __UpperCamelCase =			do_lower_case







       def 		snake_case_	(			self: Tuple,A_: List[str],A_: Tuple=None					):






            '''simple docstring'''




            __UpperCamelCase =			[self.cls_token_id] + token_ids_a + [self.sep_token_id]

            if token_ids_a:
                 output += token_ids_a + [self.sep_token_id]

            return output







       def 		snake_case_	(			self: Dict,A_: List[int],A_: Optional[List[int]] = None					):






            '''simple docstring'''




            __UpperCamelCase =			[self.sep_token_id]
            __UpperCamelCase =			[self.cls_token_id]
            if token_ids_a is None:
                 return len(cls + token_ids_a + sep					) * [0]
            return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]







       def 		snake_case_	(			self: Any,A_: str,A_: Optional[str] = None					):






            '''simple docstring'''




            __UpperCamelCase =			self._tokenizer.model.save(A_,name=A_					)
            return tuple(A_					)




import math




class   __lowercase						:






	def       _a(self				: Dict      ,	snake_case				: list[list[float]]      ,	snake_case				: list[int]    ) ->			int:
							_lowercase       :	List[Any]           =   0.0
							_lowercase       :	Any           =   0.0
							for i in range(len(snake_case    )    ):
													da += math.pow((sample[i] - weights[0][i])      ,	2    )
													da += math.pow((sample[i] - weights[1][i])      ,	2    )
													return 0 if da > da else 1
							return 0






	def       _a(self				: Dict      ,	snake_case				: list[list[int | float]]      ,	snake_case				: list[int]      ,	snake_case				: int      ,	snake_case				: float    ) ->			list[list[int | float]]:
							for i in range(len(snake_case    )    ):
													weights[j][i] += alpha * (sample[i] - weights[j][i])
							return weights



def 		UpperCamelCase     (       )   ->			None:






						'''simple docstring'''

						_lowercase       :	Union[str, Any]           =   [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

						# weight initialization ( n, C )
						_lowercase       :	Tuple           =   [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

						# training
						_lowercase       :	List[Any]           =   SelfOrganizingMap()
						_lowercase       :	Any           =   3
						_lowercase       :	Optional[Any]           =   0.5

						for _ in range(_UpperCAmelCase  ):
												for j in range(len(_UpperCAmelCase  )  ):
																		# training sample
																		_lowercase       :	Optional[int]           =   training_samples[j]

																		# Compute the winning vector
																		_lowercase       :	Tuple           =   self_organizing_map.get_winner(_UpperCAmelCase ,			_UpperCAmelCase  )

																		# Update the winning vector
																		_lowercase       :	str           =   self_organizing_map.update(_UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase  )

    # classify test sample
						_lowercase       :	Any           =   [0, 0, 0, 1]
						_lowercase       :	Dict           =   self_organizing_map.get_winner(_UpperCAmelCase ,			_UpperCAmelCase  )

						# results
						print(f"""Clusters that the test sample belongs to : {winner}"""  )
						print(f"""Weights that have been trained : {weights}"""  )


# running the main() function
if __name__ == "__main__":
							main()




