






'''simple docstring'''




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer


lowerCamelCase_												=					logging.get_logger(__name__)

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

lowerCamelCase_												=					[
    '''small''',
    '''small-base''',
    '''medium''',
    '''medium-base''',
    '''intermediate''',
    '''intermediate-base''',
    '''large''',
    '''large-base''',
    '''xlarge''',
    '''xlarge-base''',
]

lowerCamelCase_												=					{
    '''vocab_file''': {
        '''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt''',
        '''funnel-transformer/small-base''': '''https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt''',
        '''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt''',
        '''funnel-transformer/medium-base''': (
            '''https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/intermediate''': (
            '''https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/intermediate-base''': (
            '''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt''',
        '''funnel-transformer/large-base''': '''https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt''',
        '''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt''',
        '''funnel-transformer/xlarge-base''': (
            '''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json''',
        '''funnel-transformer/small-base''': (
            '''https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json''',
        '''funnel-transformer/medium-base''': (
            '''https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/intermediate''': (
            '''https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/intermediate-base''': (
            '''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json''',
        '''funnel-transformer/large-base''': (
            '''https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json''',
        '''funnel-transformer/xlarge-base''': (
            '''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'''
        ),
    },
}
lowerCamelCase_												=					{F"""funnel-transformer/{name}""": 5_12 for name in _model_names}
lowerCamelCase_												=					{F"""funnel-transformer/{name}""": {'''do_lower_case''': True} for name in _model_names}

class    _UpperCAmelCase			(     snake_case_						):




   """simple docstring"""

   snake_case    				=						VOCAB_FILES_NAMES
   snake_case    				=						PRETRAINED_VOCAB_FILES_MAP
   snake_case    				=						PRETRAINED_INIT_CONFIGURATION
   snake_case    				=						FunnelTokenizer
   snake_case    				=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   snake_case    				=						2

   def __init__(		self :	int      ,      __UpperCAmelCase :	Dict=None      ,      __UpperCAmelCase :	Union[str, Any]=None      ,      __UpperCAmelCase :	Tuple=True      ,      __UpperCAmelCase :	int="<unk>"      ,      __UpperCAmelCase :	int="<sep>"      ,      __UpperCAmelCase :	Union[str, Any]="<pad>"      ,      __UpperCAmelCase :	List[Any]="<cls>"      ,      __UpperCAmelCase :	Optional[int]="<mask>"      ,      __UpperCAmelCase :	Tuple="<s>"      ,      __UpperCAmelCase :	List[Any]="</s>"      ,      __UpperCAmelCase :	int=True      ,      __UpperCAmelCase :	Tuple=True      ,      __UpperCAmelCase :	Tuple=None      ,      __UpperCAmelCase :	Optional[int]="##"      ,      **__UpperCAmelCase :	Any      ,      ):





         '''simple docstring'''





         super().__init__(
             __UpperCAmelCase      ,      tokenizer_file=__UpperCAmelCase      ,      do_lower_case=__UpperCAmelCase      ,      unk_token=__UpperCAmelCase      ,      sep_token=__UpperCAmelCase      ,      pad_token=__UpperCAmelCase      ,      cls_token=__UpperCAmelCase      ,      mask_token=__UpperCAmelCase      ,      bos_token=__UpperCAmelCase      ,      eos_token=__UpperCAmelCase      ,      clean_text=__UpperCAmelCase      ,      tokenize_chinese_chars=__UpperCAmelCase      ,      strip_accents=__UpperCAmelCase      ,      wordpieces_prefix=__UpperCAmelCase      ,      **__UpperCAmelCase      ,      )

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

         _A			     =	do_lower_case

   def 						lowerCAmelCase (		self :	List[str]      ,      __UpperCAmelCase :	List[Any]      ,      __UpperCAmelCase :	Any=None		):





         '''simple docstring'''





         _A			     =	[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 						lowerCAmelCase (		self :	Optional[Any]      ,      __UpperCAmelCase :	List[int]      ,      __UpperCAmelCase :	Optional[List[int]] = None		):





         '''simple docstring'''





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

   def 						lowerCAmelCase (		self :	Optional[int]      ,      __UpperCAmelCase :	str      ,      __UpperCAmelCase :	Optional[str] = None		):





         '''simple docstring'''





         _A			     =	self._tokenizer.model.save(__UpperCAmelCase      ,      name=__UpperCAmelCase		)
         return tuple(__UpperCAmelCase		)









import numpy as np
import torch
from torch.utils.data import Dataset

from utils import logger





class   __a			(    __UpperCamelCase      ):
 def __init__(   self				, lowerCAmelCase__				, lowerCAmelCase__ )					->				Any:




        '''simple docstring'''
        lowercase__:   Any  			=   params

        lowercase__:   List[Any]  			=   np.array(lowerCAmelCase__ )
        lowercase__:   Optional[Any]  			=   np.array([len(lowerCAmelCase__ ) for t in data] )

        self.check()
        self.remove_long_sequences()
        self.remove_empty_sequences()
        self.remove_unknown_sequences()
        self.check()
        self.print_statistics()
 def __getitem__(   self				, lowerCAmelCase__ )					->				List[Any]:




        '''simple docstring'''
        return (self.token_ids[index], self.lengths[index])
 def __len__(   self )					->				List[Any]:




        '''simple docstring'''
        return len(self.lengths )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Tuple:




        '''simple docstring'''
        assert len(self.token_ids ) == len(self.lengths )
        assert all(self.lengths[i] == len(self.token_ids[i] ) for i in range(len(self.lengths ) ) )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Union[str, Any]:




        '''simple docstring'''
        lowercase__:   Any  			=   self.params.max_model_input_size
        lowercase__:   Dict  			=   self.lengths > max_len
        logger.info(F'Splitting {sum(lowerCAmelCase__ )} too long sequences.' )

        def divide_chunks(lowerCAmelCase__				, lowerCAmelCase__ ):
               return [l[i : i + n] for i in range(0				, len(lowerCAmelCase__ )				, lowerCAmelCase__ )]

        lowercase__:   str  			=   []
        lowercase__:   List[str]  			=   []
        if self.params.mlm:
               lowercase__			,						lowercase__:   str  			=   self.params.special_tok_ids['cls_token'], self.params.special_tok_ids['sep_token']
        else:
               lowercase__			,						lowercase__:   int  			=   self.params.special_tok_ids['bos_token'], self.params.special_tok_ids['eos_token']

        for seq_, len_ in zip(self.token_ids				, self.lengths ):
               assert (seq_[0] == cls_id) and (seq_[-1] == sep_id), seq_
               if len_ <= max_len:
                      new_tok_ids.append(seq_ )
                      new_lengths.append(len_ )
               else:
                      lowercase__:   Optional[Any]  			=   []
                      for sub_s in divide_chunks(seq_				, max_len - 2 ):
                             if sub_s[0] != cls_id:
                                    lowercase__:   int  			=   np.insert(lowerCAmelCase__				, 0				, lowerCAmelCase__ )
                             if sub_s[-1] != sep_id:
                                    lowercase__:   Union[str, Any]  			=   np.insert(lowerCAmelCase__				, len(lowerCAmelCase__ )				, lowerCAmelCase__ )
                             assert len(lowerCAmelCase__ ) <= max_len
                             assert (sub_s[0] == cls_id) and (sub_s[-1] == sep_id), sub_s
                             sub_seqs.append(lowerCAmelCase__ )

                      new_tok_ids.extend(lowerCAmelCase__ )
                      new_lengths.extend([len(lowerCAmelCase__ ) for l in sub_seqs] )

        lowercase__:   Union[str, Any]  			=   np.array(lowerCAmelCase__ )
        lowercase__:   Union[str, Any]  			=   np.array(lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Tuple:




        '''simple docstring'''
        lowercase__:   Dict  			=   len(self )
        lowercase__:   Union[str, Any]  			=   self.lengths > 11
        lowercase__:   List[Any]  			=   self.token_ids[indices]
        lowercase__:   Optional[Any]  			=   self.lengths[indices]
        lowercase__:   List[str]  			=   len(self )
        logger.info(F'Remove {init_size - new_size} too short (<=11 tokens) sequences.' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        if "unk_token" not in self.params.special_tok_ids:
               return
        else:
               lowercase__:   List[str]  			=   self.params.special_tok_ids['unk_token']
        lowercase__:   str  			=   len(self )
        lowercase__:   Tuple  			=   np.array([np.count_nonzero(a == unk_token_id ) for a in self.token_ids] )
        lowercase__:   Any  			=   (unk_occs / self.lengths) < 0.5
        lowercase__:   Tuple  			=   self.token_ids[indices]
        lowercase__:   str  			=   self.lengths[indices]
        lowercase__:   Dict  			=   len(self )
        logger.info(F'Remove {init_size - new_size} sequences with a high level of unknown tokens (50%).' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				str:




        '''simple docstring'''
        if not self.params.is_master:
               return
        logger.info(F'{len(self )} sequences' )
        # data_len = sum(self.lengths)
        # nb_unique_tokens = len(Counter(list(chain(*self.token_ids))))
        # logger.info(f'{data_len} tokens ({nb_unique_tokens} unique)')

        # unk_idx = self.params.special_tok_ids['unk_token']
        # nb_unknown = sum([(t==unk_idx).sum() for t in self.token_ids])
        # logger.info(f'{nb_unknown} unknown tokens (covering {100*nb_unknown/data_len:.2f}% of the data)')
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__ )					->				int:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   [t[0] for t in batch]
        lowercase__:   Dict  			=   [t[1] for t in batch]
        assert len(lowerCAmelCase__ ) == len(lowerCAmelCase__ )

        # Max for paddings
        lowercase__:   List[Any]  			=   max(lowerCAmelCase__ )

        # Pad token ids
        if self.params.mlm:
               lowercase__:   Dict  			=   self.params.special_tok_ids['pad_token']
        else:
               lowercase__:   Optional[Any]  			=   self.params.special_tok_ids['unk_token']
        lowercase__:   int  			=   [list(t.astype(lowerCAmelCase__ ) ) + [pad_idx] * (max_seq_len_ - len(lowerCAmelCase__ )) for t in token_ids]
        assert len(tk_ ) == len(lowerCAmelCase__ )
        assert all(len(lowerCAmelCase__ ) == max_seq_len_ for t in tk_ )

        lowercase__:   Tuple  			=   torch.tensor(tk_ )  # (bs, max_seq_len_)
        lowercase__:   Optional[Any]  			=   torch.tensor(lowerCAmelCase__ )  # (bs)
        return tk_t, lg_t


