


"""simple docstring"""







import torch
from torch import nn

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


class       SCREAMING_SNAKE_CASE__				(		lowercase   ,    lowercase				):
       """simple docstring"""


       @register_to_config
       def __init__(						self		,     *,
           snake_case__ = 4		,     snake_case__ = 768		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         super().__init__()

         lowerCAmelCase     :     Union[str, Any]								=							nn.Parameter(torch.zeros(snake_case__						)						)

         # parameters for additional clip time embeddings
         lowerCAmelCase     :     Tuple								=							nn.Linear(snake_case__		,     snake_case__						)
         lowerCAmelCase     :     str								=							nn.Linear(snake_case__		,     snake_case__						)

         # parameters for encoder hidden states
         lowerCAmelCase     :     Optional[int]								=							clip_extra_context_tokens
         lowerCAmelCase     :     Union[str, Any]								=							nn.Linear(
             snake_case__		,     self.clip_extra_context_tokens * cross_attention_dim						)
         lowerCAmelCase     :     List[Any]								=							nn.Linear(snake_case__		,     snake_case__						)
         lowerCAmelCase     :     Tuple								=							nn.LayerNorm(snake_case__						)







       def        lowercase__							(						self		,     *, snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         if do_classifier_free_guidance:
           # Add the classifier free guidance embeddings to the image embeddings
           lowerCAmelCase     :     Dict								=							image_embeddings.shape[0]
           lowerCAmelCase     :     Optional[Any]								=							self.learned_classifier_free_guidance_embeddings.unsqueeze(0						)
           lowerCAmelCase     :     List[str]								=							classifier_free_guidance_embeddings.expand(
               snake_case__		,     -1						)
           lowerCAmelCase     :     str								=							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]

         lowerCAmelCase     :     List[str]								=							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, ...
         lowerCAmelCase     :     int								=							self.embedding_proj(snake_case__						)
         lowerCAmelCase     :     Optional[int]								=							self.clip_image_embeddings_project_to_time_embeddings(snake_case__						)
         lowerCAmelCase     :     Any								=							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"
         lowerCAmelCase     :     List[Any]								=							self.clip_extra_context_tokens_proj(snake_case__						)
         lowerCAmelCase     :     Any								=							clip_extra_context_tokens.reshape(snake_case__		,     -1		,     self.clip_extra_context_tokens						)
         lowerCAmelCase     :     List[str]								=							clip_extra_context_tokens.permute(0		,     2		,     1						)

         lowerCAmelCase     :     Dict								=							self.encoder_hidden_states_proj(snake_case__						)
         lowerCAmelCase     :     Union[str, Any]								=							self.text_encoder_hidden_states_norm(snake_case__						)
         lowerCAmelCase     :     Tuple								=							torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]		,     dim=1						)

         return text_encoder_hidden_states, additive_clip_time_embeddings












'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase					:     Optional[Any]												={
    '''configuration_nllb_moe''': [
        '''NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''NllbMoeConfig''',
    ]
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase					:     Tuple												=[
     '''NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''NllbMoeForConditionalGeneration''',
     '''NllbMoeModel''',
     '''NllbMoePreTrainedModel''',
     '''NllbMoeTop2Router''',
     '''NllbMoeSparseMLP''',
 ]


if TYPE_CHECKING:
 from .configuration_nllb_moe import (
     NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
     NllbMoeConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_nllb_moe import (
      NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
      NllbMoeForConditionalGeneration,
      NllbMoeModel,
      NllbMoePreTrainedModel,
      NllbMoeSparseMLP,
      NllbMoeTopaRouter,
  )


else:
 import sys

 lowerCAmelCase					:     Tuple												=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


