


'''simple docstring'''
from math import factorial





def    a__			(   lowerCAmelCase__    ,   lowerCAmelCase__    ,   lowerCAmelCase__		)       ->      float:
    if successes > trials:
        raise ValueError('''successes must be lower or equal to trials'''		)
    if trials < 0 or successes < 0:
        raise ValueError('''the function is defined for non-negative integers'''		)
    if not isinstance(lowerCAmelCase__    ,   lowerCAmelCase__		) or not isinstance(lowerCAmelCase__    ,   lowerCAmelCase__		):
        raise ValueError('''the function is defined for non-negative integers'''		)
    if not 0 < prob < 1:
        raise ValueError('''prob has to be in range of 1 - 0'''		)
    UpperCAmelCase__     :						Any						=							(prob**successes) * ((1 - prob) ** (trials - successes))
    # Calculate the binomial coefficient: n! / k!(n-k)!
    UpperCAmelCase__     :						Any						=							float(factorial(lowerCAmelCase__		)		)
    coefficient /= factorial(lowerCAmelCase__		) * factorial(trials - successes		)
    return probability * coefficient


if __name__ == "__main__":
  from doctest import testmod

  testmod()
  print('''Probability of 2 successes out of 4 trails''')
  print('''with probability of 0.75 is:''', end=''' ''')
  print(binomial_distribution(2, 4, 0.75))


import torch
from torch import nn

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





class     lowerCamelCase      (       __lowerCamelCase ,		__lowerCamelCase					):







	@register_to_config
	def __init__(     self      :Tuple   ,     *,
	    lowercase      :int = 4   ,     lowercase      :int = 7_6_8   ,     lowercase      :int   ,     lowercase      :Any   ,     )		->      Optional[Any]:







				"""simple docstring"""






				super().__init__()

				SCREAMING_SNAKE_CASE     						= nn.Parameter(torch.zeros(lowercase			)			)

				# parameters for additional clip time embeddings
				SCREAMING_SNAKE_CASE     						= nn.Linear(lowercase   ,     lowercase			)
				SCREAMING_SNAKE_CASE     						= nn.Linear(lowercase   ,     lowercase			)

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







	def  snake_case__     (     self      :Union[str, Any]   ,     *, lowercase      :Optional[int]   ,     lowercase      :Union[str, Any]   ,     lowercase      :Union[str, Any]   ,     lowercase      :Optional[Any]			)		->      Union[str, Any]:







				"""simple docstring"""






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

				SCREAMING_SNAKE_CASE     						= 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, ...
				SCREAMING_SNAKE_CASE     						= self.embedding_proj(lowercase			)
				SCREAMING_SNAKE_CASE     						= self.clip_image_embeddings_project_to_time_embeddings(lowercase			)
				SCREAMING_SNAKE_CASE     						= 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"
				SCREAMING_SNAKE_CASE     						= self.clip_extra_context_tokens_proj(lowercase			)
				SCREAMING_SNAKE_CASE     						= clip_extra_context_tokens.reshape(lowercase   ,     -1   ,     self.clip_extra_context_tokens			)
				SCREAMING_SNAKE_CASE     						= clip_extra_context_tokens.permute(0   ,     2   ,     1			)

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

				return text_encoder_hidden_states, additive_clip_time_embeddings