


"""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"""







def 					a__			(				SCREAMING_SNAKE_CASE    :    int				,      SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  while b:
    lowerCAmelCase						,  lowerCAmelCase     :     Any								=							b, a % b
  return a
def 					a__			(				SCREAMING_SNAKE_CASE    :    int				,      SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  return a if b == 0 else euclidean_gcd_recursive(SCREAMING_SNAKE_CASE				,      a % b				)
def 					a__			(				):


  '''simple docstring'''







  print(f"""euclidean_gcd(3, 5) = {euclidean_gcd(3				,      5				)}"""				)
  print(f"""euclidean_gcd(5, 3) = {euclidean_gcd(5				,      3				)}"""				)
  print(f"""euclidean_gcd(1, 3) = {euclidean_gcd(1				,      3				)}"""				)
  print(f"""euclidean_gcd(3, 6) = {euclidean_gcd(3				,      6				)}"""				)
  print(f"""euclidean_gcd(6, 3) = {euclidean_gcd(6				,      3				)}"""				)

  print(f"""euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3				,      5				)}"""				)
  print(f"""euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5				,      3				)}"""				)
  print(f"""euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1				,      3				)}"""				)
  print(f"""euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3				,      6				)}"""				)
  print(f"""euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6				,      3				)}"""				)


if __name__ == "__main__":
     main()





