

"""simple docstring"""






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

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

from ..configuration_utils import ConfigMixin, register_to_config
from ..models.embeddings import ImagePositionalEmbeddings
from ..utils import BaseOutput, deprecate
from .attention import BasicTransformerBlock
from .embeddings import PatchEmbed
from .modeling_utils import ModelMixin
@dataclass
class 	_lowerCAmelCase    (      __snake_case       ):
							__lowerCAmelCase					:    torch.FloatTensor




class 	_lowerCAmelCase    (      __snake_case       ,       __snake_case       ):

							@register_to_config
							def __init__( self       :    int ,		a       :    int = 16 ,		a       :    int = 88 ,		a       :    Optional[int] = None ,		a       :    Optional[int] = None ,		a       :    int = 1 ,		a       :    float = 0.0 ,		a       :    int = 32 ,		a       :    Optional[int] = None ,		a       :    bool = False ,		a       :    Optional[int] = None ,		a       :    Optional[int] = None ,		a       :    Optional[int] = None ,		a       :    str = "geglu" ,		a       :    Optional[int] = None ,		a       :    bool = False ,		a       :    bool = False ,		a       :    bool = False ,		a       :    str = "layer_norm" ,		a       :    bool = True ,		)   ->    str:

									"""simple docstring"""
									super().__init__()
									lowercase										=							use_linear_projection
									lowercase										=							num_attention_heads
									lowercase										=							attention_head_dim
									lowercase										=							num_attention_heads * attention_head_dim

									# 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
									# Define whether input is continuous or discrete depending on configuration
									lowercase										=							(in_channels is not None) and (patch_size is None)
									lowercase										=							num_vector_embeds is not None
									lowercase										=							in_channels is not None and patch_size is not None

									if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
											lowercase										=							(
											    f"""The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"""
											    ''' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'''
											    ''' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'''
											    ''' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'''
											    ''' would be very nice if you could open a Pull request for the `transformer/config.json` file'''
											)
											deprecate('''norm_type!=num_embeds_ada_norm''' ,		'''1.0.0''' ,		a ,		standard_warn=a    )
											lowercase										=							'''ada_norm'''

									if self.is_input_continuous and self.is_input_vectorized:
											raise ValueError(
											    f"""Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"""
											    ''' sure that either `in_channels` or `num_vector_embeds` is None.'''    )
									elif self.is_input_vectorized and self.is_input_patches:
											raise ValueError(
											    f"""Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"""
											    ''' sure that either `num_vector_embeds` or `num_patches` is None.'''    )
									elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
											raise ValueError(
											    f"""Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"""
											    f""" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None."""    )

									# 2. Define input layers
									if self.is_input_continuous:
											lowercase										=							in_channels

											lowercase										=							torch.nn.GroupNorm(num_groups=a ,		num_channels=a ,		eps=1E-6 ,		affine=a    )
											if use_linear_projection:
													lowercase										=							nn.Linear(a ,		a    )
											else:
													lowercase										=							nn.Convad(a ,		a ,		kernel_size=1 ,		stride=1 ,		padding=0    )
									elif self.is_input_vectorized:
											assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
											assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"

											lowercase										=							sample_size
											lowercase										=							sample_size
											lowercase										=							num_vector_embeds
											lowercase										=							self.height * self.width

											lowercase										=							ImagePositionalEmbeddings(
											    num_embed=a ,		embed_dim=a ,		height=self.height ,		width=self.width    )
									elif self.is_input_patches:
											assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"

											lowercase										=							sample_size
											lowercase										=							sample_size

											lowercase										=							patch_size
											lowercase										=							PatchEmbed(
											    height=a ,		width=a ,		patch_size=a ,		in_channels=a ,		embed_dim=a ,		)

									# 3. Define transformers blocks
									lowercase										=							nn.ModuleList(
									    [
									        BasicTransformerBlock(
									            a ,		a ,		a ,		dropout=a ,		cross_attention_dim=a ,		activation_fn=a ,		num_embeds_ada_norm=a ,		attention_bias=a ,		only_cross_attention=a ,		upcast_attention=a ,		norm_type=a ,		norm_elementwise_affine=a ,		)
									        for d in range(a    )
									    ]    )

									# 4. Define output layers
									lowercase										=							in_channels if out_channels is None else out_channels
									if self.is_input_continuous:
											# TODO: should use out_channels for continuous projections
											if use_linear_projection:
													lowercase										=							nn.Linear(a ,		a    )
											else:
													lowercase										=							nn.Convad(a ,		a ,		kernel_size=1 ,		stride=1 ,		padding=0    )
									elif self.is_input_vectorized:
											lowercase										=							nn.LayerNorm(a    )
											lowercase										=							nn.Linear(a ,		self.num_vector_embeds - 1    )
									elif self.is_input_patches:
											lowercase										=							nn.LayerNorm(a ,		elementwise_affine=a ,		eps=1E-6    )
											lowercase										=							nn.Linear(a ,		2 * inner_dim    )
											lowercase										=							nn.Linear(a ,		patch_size * patch_size * self.out_channels    )

							def 					_lowerCAmelCase  ( self       :    Dict ,		a       :    torch.Tensor ,		a       :    Optional[torch.Tensor] = None ,		a       :    Optional[torch.LongTensor] = None ,		a       :    Optional[torch.LongTensor] = None ,		a       :    Dict[str, Any] = None ,		a       :    Optional[torch.Tensor] = None ,		a       :    Optional[torch.Tensor] = None ,		a       :    bool = True ,		)   ->    List[Any]:

									"""simple docstring"""
									# ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
									#   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
									#   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
									# expects mask of shape:
									#   [batch, key_tokens]
									# adds singleton query_tokens dimension:
									#   [batch,                    1, key_tokens]
									# this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
									#   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
									#   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
									if attention_mask is not None and attention_mask.ndim == 2:
											# assume that mask is expressed as:
											#   (1 = keep,      0 = discard)
											# convert mask into a bias that can be added to attention scores:
											#       (keep = +0,     discard = -10000.0)
											lowercase										=							(1 - attention_mask.to(hidden_states.dtype    )) * -10_000.0
											lowercase										=							attention_mask.unsqueeze(1    )

									# convert encoder_attention_mask to a bias the same way we do for attention_mask
									if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
											lowercase										=							(1 - encoder_attention_mask.to(hidden_states.dtype    )) * -10_000.0
											lowercase										=							encoder_attention_mask.unsqueeze(1    )

									# 1. Input
									if self.is_input_continuous:
											lowercase					,  lowercase					,  lowercase					,  lowercase										=							hidden_states.shape
											lowercase										=							hidden_states

											lowercase										=							self.norm(a    )
											if not self.use_linear_projection:
													lowercase										=							self.proj_in(a    )
													lowercase										=							hidden_states.shape[1]
													lowercase										=							hidden_states.permute(0 ,		2 ,		3 ,		1    ).reshape(a ,		height * width ,		a    )
											else:
													lowercase										=							hidden_states.shape[1]
													lowercase										=							hidden_states.permute(0 ,		2 ,		3 ,		1    ).reshape(a ,		height * width ,		a    )
													lowercase										=							self.proj_in(a    )
									elif self.is_input_vectorized:
											lowercase										=							self.latent_image_embedding(a    )
									elif self.is_input_patches:
											lowercase										=							self.pos_embed(a    )

									# 2. Blocks
									for block in self.transformer_blocks:
											lowercase										=							block(
											    a ,		attention_mask=a ,		encoder_hidden_states=a ,		encoder_attention_mask=a ,		timestep=a ,		cross_attention_kwargs=a ,		class_labels=a ,		)

									# 3. Output
									if self.is_input_continuous:
											if not self.use_linear_projection:
													lowercase										=							hidden_states.reshape(a ,		a ,		a ,		a    ).permute(0 ,		3 ,		1 ,		2    ).contiguous()
													lowercase										=							self.proj_out(a    )
											else:
													lowercase										=							self.proj_out(a    )
													lowercase										=							hidden_states.reshape(a ,		a ,		a ,		a    ).permute(0 ,		3 ,		1 ,		2    ).contiguous()

											lowercase										=							hidden_states + residual
									elif self.is_input_vectorized:
											lowercase										=							self.norm_out(a    )
											lowercase										=							self.out(a    )
											# (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
											lowercase										=							logits.permute(0 ,		2 ,		1    )

											# log(p(x_0))
											lowercase										=							F.log_softmax(logits.double() ,		dim=1    ).float()
									elif self.is_input_patches:
											# TODO: cleanup!
											lowercase										=							self.transformer_blocks[0].norma.emb(
											    a ,		a ,		hidden_dtype=hidden_states.dtype    )
											lowercase					,  lowercase										=							self.proj_out_a(F.silu(a    )    ).chunk(2 ,		dim=1    )
											lowercase										=							self.norm_out(a    ) * (1 + scale[:, None]) + shift[:, None]
											lowercase										=							self.proj_out_a(a    )

											# unpatchify
											lowercase										=							lowercase										=							int(hidden_states.shape[1] ** 0.5    )
											lowercase										=							hidden_states.reshape(
											    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)    )
											lowercase										=							torch.einsum('''nhwpqc->nchpwq''' ,		a    )
											lowercase										=							hidden_states.reshape(
											    shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)    )

									if not return_dict:
											return (output,)

									return TransformeraDModelOutput(sample=a    )


"""simple docstring"""






import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


__lowerCAmelCase				      =   logging.get_logger(__name__)
class 	_lowerCAmelCase    (      __snake_case       ):

							def __init__( self       :    Dict ,		*a       :    Any ,		**a       :    List[str]    )   ->    None:

									"""simple docstring"""
									warnings.warn(
									    '''The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
									    ''' Please use ConvNextImageProcessor instead.''' ,		a ,		)
									super().__init__(*a ,		**a    )