

"""simple docstring"""






import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import SPIECE_UNDERLINE, logging


_lowerCAmelCase						=		logging.get_logger(__name__)

_lowerCAmelCase						=		{"""vocab_file""": """spiece.model"""}

_lowerCAmelCase						=		{
    """vocab_file""": {
        """xlnet-base-cased""": """https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model""",
        """xlnet-large-cased""": """https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model""",
    }
}

_lowerCAmelCase						=		{
    """xlnet-base-cased""": None,
    """xlnet-large-cased""": None,
}

# Segments (not really needed)
_lowerCAmelCase						=		0
_lowerCAmelCase						=		1
_lowerCAmelCase						=		2
_lowerCAmelCase						=		3
_lowerCAmelCase						=		4







class 	__UpperCamelCase    (    a__						):
  _UpperCAmelCase          =		VOCAB_FILES_NAMES
  _UpperCAmelCase          =		PRETRAINED_VOCAB_FILES_MAP
  _UpperCAmelCase          =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  _UpperCAmelCase          =		"left"

  def __init__(		self    ,_A    ,_A=False    ,_A=True    ,_A=False    ,_A="<s>"    ,_A="</s>"    ,_A="<unk>"    ,_A="<sep>"    ,_A="<pad>"    ,_A="<cls>"    ,_A="<mask>"    ,_A=["<eop>", "<eod>"]    ,_A = None    ,**_A    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    AddedToken(_A    ,lstrip=_A    ,rstrip=_A      ) if isinstance(_A    ,_A      ) else mask_token

      _lowerCAmelCase       :   Union[str, Any]  =    {} if sp_model_kwargs is None else sp_model_kwargs

      super().__init__(
          do_lower_case=_A    ,remove_space=_A    ,keep_accents=_A    ,bos_token=_A    ,eos_token=_A    ,unk_token=_A    ,sep_token=_A    ,pad_token=_A    ,cls_token=_A    ,mask_token=_A    ,additional_special_tokens=_A    ,sp_model_kwargs=self.sp_model_kwargs    ,**_A    ,)

      _lowerCAmelCase       :   int  =    3

      _lowerCAmelCase       :   Union[str, Any]  =    do_lower_case
      _lowerCAmelCase       :   Dict  =    remove_space
      _lowerCAmelCase       :   int  =    keep_accents
      _lowerCAmelCase       :   List[str]  =    vocab_file

      _lowerCAmelCase       :   List[Any]  =    spm.SentencePieceProcessor(**self.sp_model_kwargs      )
      self.sp_model.Load(_A      )

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      return len(self.sp_model      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    {self.convert_ids_to_tokens(_A      ): i for i in range(self.vocab_size      )}
      vocab.update(self.added_tokens_encoder      )
      return vocab

  def __getstate__(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    self.__dict__.copy()
      _lowerCAmelCase       :   List[str]  =    None
      return state

  def __setstate__(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    d

      # for backward compatibility
      if not hasattr(self    ,'sp_model_kwargs'      ):
          _lowerCAmelCase       :   Union[str, Any]  =    {}

      _lowerCAmelCase       :   Optional[Any]  =    spm.SentencePieceProcessor(**self.sp_model_kwargs      )
      self.sp_model.Load(self.vocab_file      )

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      if self.remove_space:
          _lowerCAmelCase       :   str  =    ' '.join(inputs.strip().split()      )
      else:
          _lowerCAmelCase       :   Dict  =    inputs
      _lowerCAmelCase       :   List[str]  =    outputs.replace('``'    ,'"'      ).replace('\'\''    ,'"'      )

      if not self.keep_accents:
          _lowerCAmelCase       :   Optional[Any]  =    unicodedata.normalize('NFKD'    ,_A      )
          _lowerCAmelCase       :   Dict  =    ''.join([c for c in outputs if not unicodedata.combining(_A      )]      )
      if self.do_lower_case:
          _lowerCAmelCase       :   Tuple  =    outputs.lower()

      return outputs

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.preprocess_text(_A      )
      _lowerCAmelCase       :   int  =    self.sp_model.encode(_A    ,out_type=_A      )
      _lowerCAmelCase       :   int  =    []
      for piece in pieces:
          if len(_A      ) > 1 and piece[-1] == str(','      ) and piece[-2].isdigit():
              _lowerCAmelCase       :   Union[str, Any]  =    self.sp_model.EncodeAsPieces(piece[:-1].replace(_A    ,''      )      )
              if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
                  if len(cur_pieces[0]      ) == 1:
                      _lowerCAmelCase       :   int  =    cur_pieces[1:]
                  else:
                      _lowerCAmelCase       :   Any  =    cur_pieces[0][1:]
              cur_pieces.append(piece[-1]      )
              new_pieces.extend(_A      )
          else:
              new_pieces.append(_A      )

      return new_pieces

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      return self.sp_model.PieceToId(_A      )

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      return self.sp_model.IdToPiece(_A      )

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    ''.join(_A      ).replace(_A    ,' '      ).strip()
      return out_string

  def __lowerCamelCase		(		self    ,_A    ,_A = False    ,_A = None    ,_A = True    ,**_A    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    kwargs.pop('use_source_tokenizer'    ,_A      )

      _lowerCAmelCase       :   Dict  =    self.convert_ids_to_tokens(_A    ,skip_special_tokens=_A      )

      # To avoid mixing byte-level and unicode for byte-level BPT
      # we need to build string separately for added tokens and byte-level tokens
      # cf. https://github.com/huggingface/transformers/issues/1133
      _lowerCAmelCase       :   Optional[Any]  =    []
      _lowerCAmelCase       :   int  =    []
      for token in filtered_tokens:
          if skip_special_tokens and token in self.all_special_ids:
              continue
          if token in self.added_tokens_encoder:
              if current_sub_text:
                  sub_texts.append(self.convert_tokens_to_string(_A      )      )
                  _lowerCAmelCase       :   Tuple  =    []
              sub_texts.append(_A      )
          else:
              current_sub_text.append(_A      )
      if current_sub_text:
          sub_texts.append(self.convert_tokens_to_string(_A      )      )

      # Mimic the behavior of the Rust tokenizer:
      # By default, there are no spaces between special tokens
      _lowerCAmelCase       :   List[Any]  =    ''.join(_A      )

      _lowerCAmelCase       :   Tuple  =    (
          clean_up_tokenization_spaces
          if clean_up_tokenization_spaces is not None
          else self.clean_up_tokenization_spaces
      )
      if clean_up_tokenization_spaces:
          _lowerCAmelCase       :   int  =    self.clean_up_tokenization(_A      )
          return clean_text
      else:
          return text

  def __lowerCamelCase		(		self    ,_A    ,_A = None      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    [self.sep_token_id]
      _lowerCAmelCase       :   Union[str, Any]  =    [self.cls_token_id]
      if token_ids_a is None:
          return token_ids_a + sep + cls
      return token_ids_a + sep + token_ids_a + sep + cls

  def __lowerCamelCase		(		self    ,_A    ,_A = None    ,_A = False      ):
      '''simple docstring'''

      if already_has_special_tokens:
          return super().get_special_tokens_mask(
              token_ids_a=_A    ,token_ids_a=_A    ,already_has_special_tokens=_A      )

      if token_ids_a is not None:
          return ([0] * len(_A      )) + [1] + ([0] * len(_A      )) + [1, 1]
      return ([0] * len(_A      )) + [1, 1]

  def __lowerCamelCase		(		self    ,_A    ,_A = None      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    [self.sep_token_id]
      _lowerCAmelCase       :   Any  =    [2]

      if token_ids_a is None:
          return len(token_ids_a + sep      ) * [0] + cls_segment_id
      return len(token_ids_a + sep      ) * [0] + len(token_ids_a + sep      ) * [1] + cls_segment_id







  def __lowerCamelCase		(		self    ,_A    ,_A = None      ):
      '''simple docstring'''

      if not os.path.isdir(_A      ):
          logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""      )
          return
      _lowerCAmelCase       :   str  =    os.path.join(
          _A    ,(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']      )

      if os.path.abspath(self.vocab_file      ) != os.path.abspath(_A      ) and os.path.isfile(self.vocab_file      ):
          copyfile(self.vocab_file    ,_A      )
      elif not os.path.isfile(self.vocab_file      ):
          with open(_A    ,'wb'      ) as fi:
              _lowerCAmelCase       :   Optional[Any]  =    self.sp_model.serialized_model_proto()
              fi.write(_A      )

      return (out_vocab_file,)








"""simple docstring"""






import math

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin







class 	__UpperCamelCase    (    a__							,							a__						):

  @register_to_config
  def __init__(		self    ,_A = 128    ,_A = 256    ,_A = 2_0_0_0.0    ,_A = 768    ,_A = 12    ,_A = 12    ,_A = 64    ,_A = 2048    ,_A = 0.1    ,):
      '''simple docstring'''

      super().__init__()

      _lowerCAmelCase       :   int  =    nn.Sequential(
          nn.Linear(_A    ,d_model * 4    ,bias=_A      )    ,nn.SiLU()    ,nn.Linear(d_model * 4    ,d_model * 4    ,bias=_A      )    ,nn.SiLU()    ,)

      _lowerCAmelCase       :   Any  =    nn.Embedding(_A    ,_A      )
      _lowerCAmelCase       :   Tuple  =    False

      _lowerCAmelCase       :   Union[str, Any]  =    nn.Linear(_A    ,_A    ,bias=_A      )

      _lowerCAmelCase       :   int  =    nn.Dropout(p=_A      )

      _lowerCAmelCase       :   int  =    nn.ModuleList()
      for lyr_num in range(_A      ):
          # FiLM conditional T5 decoder
          _lowerCAmelCase       :   Any  =    DecoderLayer(d_model=_A    ,d_kv=_A    ,num_heads=_A    ,d_ff=_A    ,dropout_rate=_A      )
          self.decoders.append(_A      )

      _lowerCAmelCase       :   Optional[Any]  =    TaLayerNorm(_A      )

      _lowerCAmelCase       :   List[str]  =    nn.Dropout(p=_A      )
      _lowerCAmelCase       :   Optional[Any]  =    nn.Linear(_A    ,_A    ,bias=_A      )

  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    torch.mul(query_input.unsqueeze(-1      )    ,key_input.unsqueeze(-2      )      )
      return mask.unsqueeze(-3      )







  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase       :   Dict  =    decoder_input_tokens.shape
      assert decoder_noise_time.shape == (batch,)

      # decoder_noise_time is in [0, 1), so rescale to expected timing range.
      _lowerCAmelCase       :   Any  =    get_timestep_embedding(
          decoder_noise_time * self.config.max_decoder_noise_time    ,embedding_dim=self.config.d_model    ,max_period=self.config.max_decoder_noise_time    ,).to(dtype=self.dtype      )

      _lowerCAmelCase       :   Union[str, Any]  =    self.conditioning_emb(_A      ).unsqueeze(1      )

      assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)

      _lowerCAmelCase       :   str  =    decoder_input_tokens.shape[1]

      # If we want to use relative positions for audio context, we can just offset
      # this sequence by the length of encodings_and_masks.
      _lowerCAmelCase       :   Union[str, Any]  =    torch.broadcast_to(
          torch.arange(_A    ,device=decoder_input_tokens.device      )    ,(batch, seq_length)    ,)

      _lowerCAmelCase       :   Any  =    self.position_encoding(_A      )

      _lowerCAmelCase       :   str  =    self.continuous_inputs_projection(_A      )
      inputs += position_encodings
      _lowerCAmelCase       :   int  =    self.dropout(_A      )

      # decoder: No padding present.
      _lowerCAmelCase       :   Union[str, Any]  =    torch.ones(
          decoder_input_tokens.shape[:2]    ,device=decoder_input_tokens.device    ,dtype=inputs.dtype      )

      # Translate encoding masks to encoder-decoder masks.
      _lowerCAmelCase       :   Optional[Any]  =    [(x, self.encoder_decoder_mask(_A    ,_A      )) for x, y in encodings_and_masks]

      # cross attend style: concat encodings
      _lowerCAmelCase       :   Dict  =    torch.cat([x[0] for x in encodings_and_encdec_masks]    ,dim=1      )
      _lowerCAmelCase       :   Tuple  =    torch.cat([x[1] for x in encodings_and_encdec_masks]    ,dim=-1      )

      for lyr in self.decoders:
          _lowerCAmelCase       :   Tuple  =    lyr(
              _A    ,conditioning_emb=_A    ,encoder_hidden_states=_A    ,encoder_attention_mask=_A    ,)[0]

      _lowerCAmelCase       :   Any  =    self.decoder_norm(_A      )
      _lowerCAmelCase       :   List[Any]  =    self.post_dropout(_A      )

      _lowerCAmelCase       :   int  =    self.spec_out(_A      )
      return spec_out







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A=1E-6      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   Optional[Any]  =    nn.ModuleList()

      # cond self attention: layer 0
      self.layer.append(
          TaLayerSelfAttentionCond(d_model=_A    ,d_kv=_A    ,num_heads=_A    ,dropout_rate=_A      )      )

      # cross attention: layer 1
      self.layer.append(
          TaLayerCrossAttention(
              d_model=_A    ,d_kv=_A    ,num_heads=_A    ,dropout_rate=_A    ,layer_norm_epsilon=_A    ,)      )

      # Film Cond MLP + dropout: last layer
      self.layer.append(
          TaLayerFFCond(d_model=_A    ,d_ff=_A    ,dropout_rate=_A    ,layer_norm_epsilon=_A      )      )







  def __lowerCamelCase		(		self    ,_A    ,_A=None    ,_A=None    ,_A=None    ,_A=None    ,_A=None    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Any  =    self.layer[0](
          _A    ,conditioning_emb=_A    ,attention_mask=_A    ,)

      if encoder_hidden_states is not None:
          _lowerCAmelCase       :   Any  =    torch.where(encoder_attention_mask > 0    ,0    ,-1E10      ).to(
              encoder_hidden_states.dtype      )

          _lowerCAmelCase       :   str  =    self.layer[1](
              _A    ,key_value_states=_A    ,attention_mask=_A    ,)

      # Apply Film Conditional Feed Forward layer
      _lowerCAmelCase       :   Optional[Any]  =    self.layer[-1](_A    ,_A      )

      return (hidden_states,)







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   Union[str, Any]  =    TaLayerNorm(_A      )
      _lowerCAmelCase       :   Any  =    TaFiLMLayer(in_features=d_model * 4    ,out_features=_A      )
      _lowerCAmelCase       :   Dict  =    Attention(query_dim=_A    ,heads=_A    ,dim_head=_A    ,out_bias=_A    ,scale_qk=_A      )
      _lowerCAmelCase       :   Tuple  =    nn.Dropout(_A      )







  def __lowerCamelCase		(		self    ,_A    ,_A=None    ,_A=None    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    self.layer_norm(_A      )

      if conditioning_emb is not None:
          _lowerCAmelCase       :   Union[str, Any]  =    self.FiLMLayer(_A    ,_A      )

      # Self-attention block
      _lowerCAmelCase       :   Union[str, Any]  =    self.attention(_A      )

      _lowerCAmelCase       :   Optional[Any]  =    hidden_states + self.dropout(_A      )

      return hidden_states







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   List[str]  =    Attention(query_dim=_A    ,heads=_A    ,dim_head=_A    ,out_bias=_A    ,scale_qk=_A      )
      _lowerCAmelCase       :   Optional[int]  =    TaLayerNorm(_A    ,eps=_A      )
      _lowerCAmelCase       :   Tuple  =    nn.Dropout(_A      )







  def __lowerCamelCase		(		self    ,_A    ,_A=None    ,_A=None    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.layer_norm(_A      )
      _lowerCAmelCase       :   str  =    self.attention(
          _A    ,encoder_hidden_states=_A    ,attention_mask=attention_mask.squeeze(1      )    ,)
      _lowerCAmelCase       :   Any  =    hidden_states + self.dropout(_A      )
      return layer_output







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   Optional[int]  =    TaDenseGatedActDense(d_model=_A    ,d_ff=_A    ,dropout_rate=_A      )
      _lowerCAmelCase       :   Tuple  =    TaFiLMLayer(in_features=d_model * 4    ,out_features=_A      )
      _lowerCAmelCase       :   Any  =    TaLayerNorm(_A    ,eps=_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    nn.Dropout(_A      )







  def __lowerCamelCase		(		self    ,_A    ,_A=None      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    self.layer_norm(_A      )
      if conditioning_emb is not None:
          _lowerCAmelCase       :   Union[str, Any]  =    self.film(_A    ,_A      )

      _lowerCAmelCase       :   str  =    self.DenseReluDense(_A      )
      _lowerCAmelCase       :   Tuple  =    hidden_states + self.dropout(_A      )
      return hidden_states







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   Union[str, Any]  =    nn.Linear(_A    ,_A    ,bias=_A      )
      _lowerCAmelCase       :   Any  =    nn.Linear(_A    ,_A    ,bias=_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    nn.Linear(_A    ,_A    ,bias=_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    nn.Dropout(_A      )
      _lowerCAmelCase       :   int  =    NewGELUActivation()







  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Tuple  =    self.act(self.wi_a(_A      )      )
      _lowerCAmelCase       :   Optional[int]  =    self.wi_a(_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    hidden_gelu * hidden_linear
      _lowerCAmelCase       :   Dict  =    self.dropout(_A      )

      _lowerCAmelCase       :   Dict  =    self.wo(_A      )
      return hidden_states







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A=1E-6      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   Union[str, Any]  =    nn.Parameter(torch.ones(_A      )      )
      _lowerCAmelCase       :   Optional[int]  =    eps







  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    hidden_states.to(torch.floataa      ).pow(2      ).mean(-1    ,keepdim=_A      )
      _lowerCAmelCase       :   List[Any]  =    hidden_states * torch.rsqrt(variance + self.variance_epsilon      )

      # convert into half-precision if necessary
      if self.weight.dtype in [torch.floataa, torch.bfloataa]:
          _lowerCAmelCase       :   Optional[int]  =    hidden_states.to(self.weight.dtype      )

      return self.weight * hidden_states







class 	__UpperCamelCase    (    nn.Module						):

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi      ) * (input + 0.0_4_4_7_1_5 * torch.pow(_A    ,3.0      ))      ))







class 	__UpperCamelCase    (    nn.Module						):

  def __init__(		self    ,_A    ,_A      ):
      '''simple docstring'''

      super().__init__()
      _lowerCAmelCase       :   List[str]  =    nn.Linear(_A    ,out_features * 2    ,bias=_A      )







  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    self.scale_bias(_A      )
      _lowerCAmelCase,					_lowerCAmelCase       :   List[Any]  =    torch.chunk(_A    ,2    ,-1      )
      _lowerCAmelCase       :   List[Any]  =    x * (1 + scale) + shift
      return x





