

"""simple docstring"""






from dataclasses import dataclass
from typing import Dict, Optional, Union

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .attention_processor import AttentionProcessor, AttnProcessor
from .embeddings import TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin







@dataclass
class 	__UpperCamelCase    (    a__						):
		_UpperCAmelCase          =		42







class 	__UpperCamelCase    (    a__							,							a__						):

		@register_to_config
		def __init__(		self    ,_A = 32    ,_A = 64    ,_A = 20    ,_A = 768    ,_A=77    ,_A=4    ,_A = 0.0    ,_A = "silu"    ,_A = None    ,_A = None    ,_A = "linear"    ,_A = "prd"    ,_A = None    ,_A = None    ,_A = None    ,):
						'''simple docstring'''

						super().__init__()
						_lowerCAmelCase       :   Any  =    num_attention_heads
						_lowerCAmelCase       :   Optional[int]  =    attention_head_dim
						_lowerCAmelCase       :   Tuple  =    num_attention_heads * attention_head_dim
						_lowerCAmelCase       :   Optional[Any]  =    additional_embeddings

						_lowerCAmelCase       :   Union[str, Any]  =    time_embed_dim or inner_dim
						_lowerCAmelCase       :   Union[str, Any]  =    embedding_proj_dim or embedding_dim
						_lowerCAmelCase       :   Optional[int]  =    clip_embed_dim or embedding_dim

						_lowerCAmelCase       :   int  =    Timesteps(_A    ,_A    ,0      )
						_lowerCAmelCase       :   int  =    TimestepEmbedding(_A    ,_A    ,out_dim=_A    ,act_fn=_A      )

						_lowerCAmelCase       :   List[Any]  =    nn.Linear(_A    ,_A      )

						if embedding_proj_norm_type is None:
										_lowerCAmelCase       :   Optional[Any]  =    None
						elif embedding_proj_norm_type == "layer":
										_lowerCAmelCase       :   List[Any]  =    nn.LayerNorm(_A      )
						else:
										raise ValueError(F"""unsupported embedding_proj_norm_type: {embedding_proj_norm_type}"""      )

						_lowerCAmelCase       :   Tuple  =    nn.Linear(_A    ,_A      )

						if encoder_hid_proj_type is None:
										_lowerCAmelCase       :   int  =    None
						elif encoder_hid_proj_type == "linear":
										_lowerCAmelCase       :   List[Any]  =    nn.Linear(_A    ,_A      )
						else:
										raise ValueError(F"""unsupported encoder_hid_proj_type: {encoder_hid_proj_type}"""      )

						_lowerCAmelCase       :   Dict  =    nn.Parameter(torch.zeros(1    ,num_embeddings + additional_embeddings    ,_A      )      )

						if added_emb_type == "prd":
										_lowerCAmelCase       :   Dict  =    nn.Parameter(torch.zeros(1    ,1    ,_A      )      )
						elif added_emb_type is None:
										_lowerCAmelCase       :   List[Any]  =    None
						else:
										raise ValueError(
										    F"""`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `'prd'` or `None`."""      )

						_lowerCAmelCase       :   List[Any]  =    nn.ModuleList(
						    [
						        BasicTransformerBlock(
						            _A    ,_A    ,_A    ,dropout=_A    ,activation_fn='gelu'    ,attention_bias=_A    ,)
						        for d in range(_A      )
						    ]      )

						if norm_in_type == "layer":
										_lowerCAmelCase       :   Any  =    nn.LayerNorm(_A      )
						elif norm_in_type is None:
										_lowerCAmelCase       :   Any  =    None
						else:
										raise ValueError(F"""Unsupported norm_in_type: {norm_in_type}."""      )

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

						_lowerCAmelCase       :   int  =    nn.Linear(_A    ,_A      )

						_lowerCAmelCase       :   Any  =    torch.full(
						    [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]    ,-1_0000.0      )
						causal_attention_mask.triu_(1      )
						_lowerCAmelCase       :   Tuple  =    causal_attention_mask[None, ...]
						self.register_buffer('causal_attention_mask'    ,_A    ,persistent=_A      )

						_lowerCAmelCase       :   Tuple  =    nn.Parameter(torch.zeros(1    ,_A      )      )
						_lowerCAmelCase       :   Dict  =    nn.Parameter(torch.zeros(1    ,_A      )      )

		@property
		# Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
		def __lowerCamelCase		(		self      ):
						'''simple docstring'''

						_lowerCAmelCase       :   List[Any]  =    {}

						def fn_recursive_add_processors(_A    ,_A    ,_A      ):
										if hasattr(_A    ,'set_processor'      ):
														_lowerCAmelCase       :   str  =    module.processor

										for sub_name, child in module.named_children():
														fn_recursive_add_processors(F"""{name}.{sub_name}"""    ,_A    ,_A      )

										return processors

						for name, module in self.named_children():
										fn_recursive_add_processors(_A    ,_A    ,_A      )

						return processors

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

						_lowerCAmelCase       :   Optional[int]  =    len(self.attn_processors.keys()      )

						if isinstance(_A    ,_A      ) and len(_A      ) != count:
										raise ValueError(
										    F"""A dict of processors was passed, but the number of processors {len(_A      )} does not match the"""
										    F""" number of attention layers: {count}. Please make sure to pass {count} processor classes."""      )

						def fn_recursive_attn_processor(_A    ,_A    ,_A      ):
										if hasattr(_A    ,'set_processor'      ):
														if not isinstance(_A    ,_A      ):
																		module.set_processor(_A      )
														else:
																		module.set_processor(processor.pop(F"""{name}.processor"""      )      )

										for sub_name, child in module.named_children():
														fn_recursive_attn_processor(F"""{name}.{sub_name}"""    ,_A    ,_A      )

						for name, module in self.named_children():
										fn_recursive_attn_processor(_A    ,_A    ,_A      )

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

						self.set_attn_processor(AttnProcessor()      )

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

						_lowerCAmelCase       :   str  =    hidden_states.shape[0]

						_lowerCAmelCase       :   int  =    timestep
						if not torch.is_tensor(_A      ):
										_lowerCAmelCase       :   str  =    torch.tensor([timesteps]    ,dtype=torch.long    ,device=hidden_states.device      )
						elif torch.is_tensor(_A      ) and len(timesteps.shape      ) == 0:
										_lowerCAmelCase       :   Dict  =    timesteps[None].to(hidden_states.device      )

						# broadcast to batch dimension in a way that's compatible with ONNX/Core ML
						_lowerCAmelCase       :   Optional[int]  =    timesteps * torch.ones(_A    ,dtype=timesteps.dtype    ,device=timesteps.device      )

						_lowerCAmelCase       :   Dict  =    self.time_proj(_A      )

						# timesteps does not contain any weights and will always return f32 tensors
						# but time_embedding might be fp16, so we need to cast here.
						_lowerCAmelCase       :   Any  =    timesteps_projected.to(dtype=self.dtype      )
						_lowerCAmelCase       :   Optional[Any]  =    self.time_embedding(_A      )

						if self.embedding_proj_norm is not None:
										_lowerCAmelCase       :   int  =    self.embedding_proj_norm(_A      )

						_lowerCAmelCase       :   str  =    self.embedding_proj(_A      )
						if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
										_lowerCAmelCase       :   str  =    self.encoder_hidden_states_proj(_A      )
						elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
										raise ValueError('`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set'      )

						_lowerCAmelCase       :   Any  =    self.proj_in(_A      )

						_lowerCAmelCase       :   Dict  =    self.positional_embedding.to(hidden_states.dtype      )

						_lowerCAmelCase       :   List[Any]  =    []
						_lowerCAmelCase       :   Optional[Any]  =    0

						if encoder_hidden_states is not None:
										additional_embeds.append(_A      )
										additional_embeddings_len += encoder_hidden_states.shape[1]

						if len(proj_embeddings.shape      ) == 2:
										_lowerCAmelCase       :   int  =    proj_embeddings[:, None, :]

						if len(hidden_states.shape      ) == 2:
										_lowerCAmelCase       :   Any  =    hidden_states[:, None, :]

						_lowerCAmelCase       :   int  =    additional_embeds + [
						    proj_embeddings,
						    time_embeddings[:, None, :],
						    hidden_states,
						]

						if self.prd_embedding is not None:
										_lowerCAmelCase       :   List[str]  =    self.prd_embedding.to(hidden_states.dtype      ).expand(_A    ,-1    ,-1      )
										additional_embeds.append(_A      )

						_lowerCAmelCase       :   List[str]  =    torch.cat(
						    _A    ,dim=1    ,)

						# Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
						_lowerCAmelCase       :   Tuple  =    additional_embeddings_len + proj_embeddings.shape[1] + 1
						if positional_embeddings.shape[1] < hidden_states.shape[1]:
										_lowerCAmelCase       :   Any  =    F.pad(
										    _A    ,(
										        0,
										        0,
										        additional_embeddings_len,
										        self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
										    )    ,value=0.0    ,)

						_lowerCAmelCase       :   int  =    hidden_states + positional_embeddings

						if attention_mask is not None:
										_lowerCAmelCase       :   Optional[Any]  =    (1 - attention_mask.to(hidden_states.dtype      )) * -1_0000.0
										_lowerCAmelCase       :   Union[str, Any]  =    F.pad(_A    ,(0, self.additional_embeddings)    ,value=0.0      )
										_lowerCAmelCase       :   Tuple  =    (attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype      )
										_lowerCAmelCase       :   Optional[Any]  =    attention_mask.repeat_interleave(self.config.num_attention_heads    ,dim=0      )

						if self.norm_in is not None:
										_lowerCAmelCase       :   Any  =    self.norm_in(_A      )

						for block in self.transformer_blocks:
										_lowerCAmelCase       :   int  =    block(_A    ,attention_mask=_A      )

						_lowerCAmelCase       :   Union[str, Any]  =    self.norm_out(_A      )

						if self.prd_embedding is not None:
										_lowerCAmelCase       :   Optional[int]  =    hidden_states[:, -1]
						else:
										_lowerCAmelCase       :   Any  =    hidden_states[:, additional_embeddings_len:]

						_lowerCAmelCase       :   Optional[int]  =    self.proj_to_clip_embeddings(_A      )

						if not return_dict:
										return (predicted_image_embedding,)

						return PriorTransformerOutput(predicted_image_embedding=_A      )







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

						_lowerCAmelCase       :   Optional[Any]  =    (prior_latents * self.clip_std) + self.clip_mean
						return prior_latents








"""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_bert import BertTokenizer


_lowerCAmelCase						=		logging.get_logger(__name__)

_lowerCAmelCase						=		{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

_lowerCAmelCase						=		{
    """vocab_file""": {
        """bert-base-uncased""": """https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt""",
        """bert-large-uncased""": """https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt""",
        """bert-base-cased""": """https://huggingface.co/bert-base-cased/resolve/main/vocab.txt""",
        """bert-large-cased""": """https://huggingface.co/bert-large-cased/resolve/main/vocab.txt""",
        """bert-base-multilingual-uncased""": (
            """https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt"""
        ),
        """bert-base-multilingual-cased""": """https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt""",
        """bert-base-chinese""": """https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt""",
        """bert-base-german-cased""": """https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt""",
        """bert-large-uncased-whole-word-masking""": (
            """https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt"""
        ),
        """bert-large-cased-whole-word-masking""": (
            """https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt"""
        ),
        """bert-large-uncased-whole-word-masking-finetuned-squad""": (
            """https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"""
        ),
        """bert-large-cased-whole-word-masking-finetuned-squad""": (
            """https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"""
        ),
        """bert-base-cased-finetuned-mrpc""": (
            """https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt"""
        ),
        """bert-base-german-dbmdz-cased""": """https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt""",
        """bert-base-german-dbmdz-uncased""": (
            """https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt"""
        ),
        """TurkuNLP/bert-base-finnish-cased-v1""": (
            """https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt"""
        ),
        """TurkuNLP/bert-base-finnish-uncased-v1""": (
            """https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt"""
        ),
        """wietsedv/bert-base-dutch-cased""": (
            """https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """bert-base-uncased""": """https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json""",
        """bert-large-uncased""": """https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json""",
        """bert-base-cased""": """https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json""",
        """bert-large-cased""": """https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json""",
        """bert-base-multilingual-uncased""": (
            """https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json"""
        ),
        """bert-base-multilingual-cased""": (
            """https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json"""
        ),
        """bert-base-chinese""": """https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json""",
        """bert-base-german-cased""": """https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json""",
        """bert-large-uncased-whole-word-masking""": (
            """https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json"""
        ),
        """bert-large-cased-whole-word-masking""": (
            """https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json"""
        ),
        """bert-large-uncased-whole-word-masking-finetuned-squad""": (
            """https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"""
        ),
        """bert-large-cased-whole-word-masking-finetuned-squad""": (
            """https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"""
        ),
        """bert-base-cased-finetuned-mrpc""": (
            """https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json"""
        ),
        """bert-base-german-dbmdz-cased""": (
            """https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json"""
        ),
        """bert-base-german-dbmdz-uncased""": (
            """https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json"""
        ),
        """TurkuNLP/bert-base-finnish-cased-v1""": (
            """https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json"""
        ),
        """TurkuNLP/bert-base-finnish-uncased-v1""": (
            """https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json"""
        ),
        """wietsedv/bert-base-dutch-cased""": (
            """https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json"""
        ),
    },
}

_lowerCAmelCase						=		{
    """bert-base-uncased""": 5_1_2,
    """bert-large-uncased""": 5_1_2,
    """bert-base-cased""": 5_1_2,
    """bert-large-cased""": 5_1_2,
    """bert-base-multilingual-uncased""": 5_1_2,
    """bert-base-multilingual-cased""": 5_1_2,
    """bert-base-chinese""": 5_1_2,
    """bert-base-german-cased""": 5_1_2,
    """bert-large-uncased-whole-word-masking""": 5_1_2,
    """bert-large-cased-whole-word-masking""": 5_1_2,
    """bert-large-uncased-whole-word-masking-finetuned-squad""": 5_1_2,
    """bert-large-cased-whole-word-masking-finetuned-squad""": 5_1_2,
    """bert-base-cased-finetuned-mrpc""": 5_1_2,
    """bert-base-german-dbmdz-cased""": 5_1_2,
    """bert-base-german-dbmdz-uncased""": 5_1_2,
    """TurkuNLP/bert-base-finnish-cased-v1""": 5_1_2,
    """TurkuNLP/bert-base-finnish-uncased-v1""": 5_1_2,
    """wietsedv/bert-base-dutch-cased""": 5_1_2,
}

_lowerCAmelCase						=		{
    """bert-base-uncased""": {"""do_lower_case""": True},
    """bert-large-uncased""": {"""do_lower_case""": True},
    """bert-base-cased""": {"""do_lower_case""": False},
    """bert-large-cased""": {"""do_lower_case""": False},
    """bert-base-multilingual-uncased""": {"""do_lower_case""": True},
    """bert-base-multilingual-cased""": {"""do_lower_case""": False},
    """bert-base-chinese""": {"""do_lower_case""": False},
    """bert-base-german-cased""": {"""do_lower_case""": False},
    """bert-large-uncased-whole-word-masking""": {"""do_lower_case""": True},
    """bert-large-cased-whole-word-masking""": {"""do_lower_case""": False},
    """bert-large-uncased-whole-word-masking-finetuned-squad""": {"""do_lower_case""": True},
    """bert-large-cased-whole-word-masking-finetuned-squad""": {"""do_lower_case""": False},
    """bert-base-cased-finetuned-mrpc""": {"""do_lower_case""": False},
    """bert-base-german-dbmdz-cased""": {"""do_lower_case""": False},
    """bert-base-german-dbmdz-uncased""": {"""do_lower_case""": True},
    """TurkuNLP/bert-base-finnish-cased-v1""": {"""do_lower_case""": False},
    """TurkuNLP/bert-base-finnish-uncased-v1""": {"""do_lower_case""": True},
    """wietsedv/bert-base-dutch-cased""": {"""do_lower_case""": False},
}







class 	__UpperCamelCase    (    a__						):
  _UpperCAmelCase          =		VOCAB_FILES_NAMES
  _UpperCAmelCase          =		PRETRAINED_VOCAB_FILES_MAP
  _UpperCAmelCase          =		PRETRAINED_INIT_CONFIGURATION
  _UpperCAmelCase          =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  _UpperCAmelCase          =		BertTokenizer

  def __init__(		self    ,_A=None    ,_A=None    ,_A=True    ,_A="[UNK]"    ,_A="[SEP]"    ,_A="[PAD]"    ,_A="[CLS]"    ,_A="[MASK]"    ,_A=True    ,_A=None    ,**_A    ,):
      '''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    ,)

      _lowerCAmelCase       :   Tuple  =    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
      ):
          _lowerCAmelCase       :   Dict  =    getattr(_A    ,normalizer_state.pop('type'      )      )
          _lowerCAmelCase       :   Dict  =    do_lower_case
          _lowerCAmelCase       :   Optional[int]  =    strip_accents
          _lowerCAmelCase       :   Union[str, Any]  =    tokenize_chinese_chars
          _lowerCAmelCase       :   Dict  =    normalizer_class(**_A      )

      _lowerCAmelCase       :   Union[str, Any]  =    do_lower_case

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

      _lowerCAmelCase       :   Tuple  =    [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    ,_A    ,_A = None      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    [self.sep_token_id]
      _lowerCAmelCase       :   str  =    [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 __lowerCamelCase		(		self    ,_A    ,_A = None      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    self._tokenizer.model.save(_A    ,name=_A      )
      return tuple(_A      )





