
import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin




class        UpperCAmelCase_			( _A  ,       _A     ):


  '''simple docstring'''







  @register_to_config
  def __init__( self			: List[str]			,							*,
      UpperCamelCase__			: int = 4			,							UpperCamelCase__			: int = 768			,							UpperCamelCase__			: int			,							UpperCamelCase__			: str			,							)			->	Optional[Any]:







    """simple docstring"""






    super().__init__()

    __magic_name__				     =       nn.Parameter(torch.zeros(UpperCamelCase__    )    )

    # parameters for additional clip time embeddings
    __magic_name__				     =       nn.Linear(UpperCamelCase__			,							UpperCamelCase__    )
    __magic_name__				     =       nn.Linear(UpperCamelCase__			,							UpperCamelCase__    )

    # parameters for encoder hidden states
    __magic_name__				     =       clip_extra_context_tokens
    __magic_name__				     =       nn.Linear(
        UpperCamelCase__			,							self.clip_extra_context_tokens * cross_attention_dim    )
    __magic_name__				     =       nn.Linear(UpperCamelCase__			,							UpperCamelCase__    )
    __magic_name__				     =       nn.LayerNorm(UpperCamelCase__    )





  def 							_lowercase							( self			: Optional[int]			,							*, UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: str			,							UpperCamelCase__			: List[str]    )			->	Optional[int]:







    """simple docstring"""






    if do_classifier_free_guidance:
      # Add the classifier free guidance embeddings to the image embeddings
      __magic_name__				     =       image_embeddings.shape[0]
      __magic_name__				     =       self.learned_classifier_free_guidance_embeddings.unsqueeze(0    )
      __magic_name__				     =       classifier_free_guidance_embeddings.expand(
          UpperCamelCase__			,							-1    )
      __magic_name__				     =       torch.cat([classifier_free_guidance_embeddings, image_embeddings]			,							dim=0    )

    # The image embeddings batch size and the text embeddings batch size are equal
    assert image_embeddings.shape[0] == prompt_embeds.shape[0]

    __magic_name__				     =       prompt_embeds.shape[0]

    # "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
    # adding CLIP embeddings to the existing timestep embedding, ...
    __magic_name__				     =       self.embedding_proj(UpperCamelCase__    )
    __magic_name__				     =       self.clip_image_embeddings_project_to_time_embeddings(UpperCamelCase__    )
    __magic_name__				     =       time_projected_image_embeddings + time_projected_prompt_embeds

    # ... and by projecting CLIP embeddings into four
    # extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
    __magic_name__				     =       self.clip_extra_context_tokens_proj(UpperCamelCase__    )
    __magic_name__				     =       clip_extra_context_tokens.reshape(UpperCamelCase__			,							-1			,							self.clip_extra_context_tokens    )
    __magic_name__				     =       clip_extra_context_tokens.permute(0			,							2			,							1    )

    __magic_name__				     =       self.encoder_hidden_states_proj(UpperCamelCase__    )
    __magic_name__				     =       self.text_encoder_hidden_states_norm(UpperCamelCase__    )
    __magic_name__				     =       torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]			,							dim=1    )

    return text_encoder_hidden_states, additive_clip_time_embeddings



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__lowerCAmelCase			:     List[str]           =   {
    'configuration_xlm': ['XLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLMConfig', 'XLMOnnxConfig'],
    'tokenization_xlm': ['XLMTokenizer'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCAmelCase			:     str           =   [
        'XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
        'XLMForMultipleChoice',
        'XLMForQuestionAnswering',
        'XLMForQuestionAnsweringSimple',
        'XLMForSequenceClassification',
        'XLMForTokenClassification',
        'XLMModel',
        'XLMPreTrainedModel',
        'XLMWithLMHeadModel',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCAmelCase			:     Dict           =   [
        'TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
        'TFXLMForMultipleChoice',
        'TFXLMForQuestionAnsweringSimple',
        'TFXLMForSequenceClassification',
        'TFXLMForTokenClassification',
        'TFXLMMainLayer',
        'TFXLMModel',
        'TFXLMPreTrainedModel',
        'TFXLMWithLMHeadModel',
    ]


if TYPE_CHECKING:
    from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
    from .tokenization_xlm import XLMTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_xlm import (
            XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
            XLMForMultipleChoice,
            XLMForQuestionAnswering,
            XLMForQuestionAnsweringSimple,
            XLMForSequenceClassification,
            XLMForTokenClassification,
            XLMModel,
            XLMPreTrainedModel,
            XLMWithLMHeadModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_xlm import (
            TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFXLMForMultipleChoice,
            TFXLMForQuestionAnsweringSimple,
            TFXLMForSequenceClassification,
            TFXLMForTokenClassification,
            TFXLMMainLayer,
            TFXLMModel,
            TFXLMPreTrainedModel,
            TFXLMWithLMHeadModel,
        )

else:
    import sys

    __lowerCAmelCase			:     Any           =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

