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 					_snake_case						(						A_				):
					lowerCamelCase__:		int  =     42




class 					_snake_case						(						A_					,      A_				):
					@register_to_config
					def __init__(  self:				Tuple	,  __lowerCamelCase:				int = 16	,  __lowerCamelCase:				int = 88	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				int = 1	,  __lowerCamelCase:				float = 0.0	,  __lowerCamelCase:				int = 32	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				bool = False	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				str = "geglu"	,  __lowerCamelCase:				Optional[int] = None	,  __lowerCamelCase:				bool = False	,  __lowerCamelCase:				bool = False	,  __lowerCamelCase:				bool = False	,  __lowerCamelCase:				str = "layer_norm"	,  __lowerCamelCase:				bool = True	,  )    ->				Optional[Any]:
												super().__init__()
												__UpperCAmelCase						:			str         =   use_linear_projection
												__UpperCAmelCase						:			Tuple         =   num_attention_heads
												__UpperCAmelCase						:			int         =   attention_head_dim
												__UpperCAmelCase						:			int         =   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
												__UpperCAmelCase						:			List[str]         =   (in_channels is not None) and (patch_size is None)
												__UpperCAmelCase						:			int         =   num_vector_embeds is not None
												__UpperCAmelCase						:			Optional[int]         =   in_channels is not None and patch_size is not None

												if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
																			__UpperCAmelCase						:			Tuple         =   (
																			    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"	,  __lowerCamelCase	,  standard_warn=__lowerCamelCase     )
																			__UpperCAmelCase						:			int         =   '''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:
																			__UpperCAmelCase						:			str         =   in_channels

																			__UpperCAmelCase						:			Any         =   torch.nn.GroupNorm(num_groups=__lowerCamelCase	,  num_channels=__lowerCamelCase	,  eps=1e-6	,  affine=__lowerCamelCase     )
																			if use_linear_projection:
																										__UpperCAmelCase						:			Optional[int]         =   nn.Linear(__lowerCamelCase	,  __lowerCamelCase     )
																			else:
																										__UpperCAmelCase						:			Optional[int]         =   nn.Convad(__lowerCamelCase	,  __lowerCamelCase	,  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"

																			__UpperCAmelCase						:			List[Any]         =   sample_size
																			__UpperCAmelCase						:			Union[str, Any]         =   sample_size
																			__UpperCAmelCase						:			Union[str, Any]         =   num_vector_embeds
																			__UpperCAmelCase						:			List[str]         =   self.height * self.width

																			__UpperCAmelCase						:			List[str]         =   ImagePositionalEmbeddings(
																			    num_embed=__lowerCamelCase	,  embed_dim=__lowerCamelCase	,  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"

																			__UpperCAmelCase						:			Union[str, Any]         =   sample_size
																			__UpperCAmelCase						:			Union[str, Any]         =   sample_size

																			__UpperCAmelCase						:			List[Any]         =   patch_size
																			__UpperCAmelCase						:			Optional[Any]         =   PatchEmbed(
																			    height=__lowerCamelCase	,  width=__lowerCamelCase	,  patch_size=__lowerCamelCase	,  in_channels=__lowerCamelCase	,  embed_dim=__lowerCamelCase	,  )

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

												# 4. Define output layers
												__UpperCAmelCase						:			Union[str, Any]         =   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:
																										__UpperCAmelCase						:			Optional[Any]         =   nn.Linear(__lowerCamelCase	,  __lowerCamelCase     )
																			else:
																										__UpperCAmelCase						:			Any         =   nn.Convad(__lowerCamelCase	,  __lowerCamelCase	,  kernel_size=1	,  stride=1	,  padding=0     )
												elif self.is_input_vectorized:
																			__UpperCAmelCase						:			Union[str, Any]         =   nn.LayerNorm(__lowerCamelCase     )
																			__UpperCAmelCase						:			Any         =   nn.Linear(__lowerCamelCase	,  self.num_vector_embeds - 1     )
												elif self.is_input_patches:
																			__UpperCAmelCase						:			Optional[int]         =   nn.LayerNorm(__lowerCamelCase	,  elementwise_affine=__lowerCamelCase	,  eps=1e-6     )
																			__UpperCAmelCase						:			Optional[int]         =   nn.Linear(__lowerCamelCase	,  2 * inner_dim     )
																			__UpperCAmelCase						:			List[str]         =   nn.Linear(__lowerCamelCase	,  patch_size * patch_size * self.out_channels     )





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



												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)
																			__UpperCAmelCase						:			Union[str, Any]         =   (1 - attention_mask.to(hidden_states.dtype     )) * -1_00_00.0
																			__UpperCAmelCase						:			Optional[Any]         =   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:
																			__UpperCAmelCase						:			Dict         =   (1 - encoder_attention_mask.to(hidden_states.dtype     )) * -1_00_00.0
																			__UpperCAmelCase						:			List[Any]         =   encoder_attention_mask.unsqueeze(1     )

												# 1. Input
												if self.is_input_continuous:
																			__UpperCAmelCase						:			Tuple         =   hidden_states.shape
																			__UpperCAmelCase						:			Optional[Any]         =   hidden_states

																			__UpperCAmelCase						:			List[Any]         =   self.norm(__lowerCamelCase     )
																			if not self.use_linear_projection:
																										__UpperCAmelCase						:			List[Any]         =   self.proj_in(__lowerCamelCase     )
																										__UpperCAmelCase						:			Any         =   hidden_states.shape[1]
																										__UpperCAmelCase						:			Tuple         =   hidden_states.permute(0	,  2	,  3	,  1     ).reshape(__lowerCamelCase	,  height * width	,  __lowerCamelCase     )
																			else:
																										__UpperCAmelCase						:			List[Any]         =   hidden_states.shape[1]
																										__UpperCAmelCase						:			List[str]         =   hidden_states.permute(0	,  2	,  3	,  1     ).reshape(__lowerCamelCase	,  height * width	,  __lowerCamelCase     )
																										__UpperCAmelCase						:			Optional[int]         =   self.proj_in(__lowerCamelCase     )
												elif self.is_input_vectorized:
																			__UpperCAmelCase						:			Optional[int]         =   self.latent_image_embedding(__lowerCamelCase     )
												elif self.is_input_patches:
																			__UpperCAmelCase						:			Optional[Any]         =   self.pos_embed(__lowerCamelCase     )

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

												# 3. Output
												if self.is_input_continuous:
																			if not self.use_linear_projection:
																										__UpperCAmelCase						:			Optional[int]         =   hidden_states.reshape(__lowerCamelCase	,  __lowerCamelCase	,  __lowerCamelCase	,  __lowerCamelCase     ).permute(0	,  3	,  1	,  2     ).contiguous()
																										__UpperCAmelCase						:			Optional[int]         =   self.proj_out(__lowerCamelCase     )
																			else:
																										__UpperCAmelCase						:			Union[str, Any]         =   self.proj_out(__lowerCamelCase     )
																										__UpperCAmelCase						:			int         =   hidden_states.reshape(__lowerCamelCase	,  __lowerCamelCase	,  __lowerCamelCase	,  __lowerCamelCase     ).permute(0	,  3	,  1	,  2     ).contiguous()

																			__UpperCAmelCase						:			Union[str, Any]         =   hidden_states + residual
												elif self.is_input_vectorized:
																			__UpperCAmelCase						:			int         =   self.norm_out(__lowerCamelCase     )
																			__UpperCAmelCase						:			List[Any]         =   self.out(__lowerCamelCase     )
																			# (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
																			__UpperCAmelCase						:			Optional[Any]         =   logits.permute(0	,  2	,  1     )

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

																			# unpatchify
																			__UpperCAmelCase						:			int         =   int(hidden_states.shape[1] ** 0.5     )
																			__UpperCAmelCase						:			Optional[int]         =   hidden_states.reshape(
																			    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)     )
																			__UpperCAmelCase						:			Optional[int]         =   torch.einsum("nhwpqc->nchpwq"	,  __lowerCamelCase     )
																			__UpperCAmelCase						:			Dict         =   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=__lowerCamelCase     )




import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


_snake_case			=						datasets.utils.logging.get_logger(__name__)




@dataclass
class 					_snake_case						(						datasets.BuilderConfig				):
					lowerCamelCase__:		Optional[datasets.Features]  =     None




class 					_snake_case						(						datasets.ArrowBasedBuilder				):
					lowerCamelCase__:		Union[str, Any]  =     ArrowConfig
					def    _lowerCamelCase (  self:				Optional[int]     )    ->				Optional[int]:
												return datasets.DatasetInfo(features=self.config.features     )
					def    _lowerCamelCase (  self:				List[Any]	,  __lowerCamelCase:				Tuple     )    ->				str:
												if not self.config.data_files:
																			raise ValueError(f'''At least one data file must be specified, but got data_files={self.config.data_files}'''     )
												__UpperCAmelCase						:			Dict         =   dl_manager.download_and_extract(self.config.data_files     )
												if isinstance(__lowerCamelCase	,  (str, list, tuple)     ):
																			__UpperCAmelCase						:			str         =   data_files
																			if isinstance(__lowerCamelCase	,  __lowerCamelCase     ):
																										__UpperCAmelCase						:			List[str]         =   [files]
																			# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
																			__UpperCAmelCase						:			List[Any]         =   [dl_manager.iter_files(__lowerCamelCase     ) for file in files]
																			return [datasets.SplitGenerator(name=datasets.Split.TRAIN	,  gen_kwargs={"files": files}     )]
												__UpperCAmelCase						:			Union[str, Any]         =   []
												for split_name, files in data_files.items():
																			if isinstance(__lowerCamelCase	,  __lowerCamelCase     ):
																										__UpperCAmelCase						:			Tuple         =   [files]
																			# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
																			__UpperCAmelCase						:			List[Any]         =   [dl_manager.iter_files(__lowerCamelCase     ) for file in files]
																			# Infer features is they are stoed in the arrow schema
																			if self.info.features is None:
																										for file in itertools.chain.from_iterable(__lowerCamelCase     ):
																																	with open(__lowerCamelCase	,  "rb"     ) as f:
																																								__UpperCAmelCase						:			Union[str, Any]         =   datasets.Features.from_arrow_schema(pa.ipc.open_stream(__lowerCamelCase     ).schema     )
																																	break
																			splits.append(datasets.SplitGenerator(name=__lowerCamelCase	,  gen_kwargs={"files": files}     )     )
												return splits
					def    _lowerCamelCase (  self:				str	,  __lowerCamelCase:				pa.Table     )    ->				pa.Table:
												if self.info.features is not None:
																			# more expensive cast to support nested features with keys in a different order
																			# allows str <-> int/float or str to Audio for example
																			__UpperCAmelCase						:			List[str]         =   table_cast(__lowerCamelCase	,  self.info.features.arrow_schema     )
												return pa_table





					def    _lowerCamelCase (  self:				Any	,  __lowerCamelCase:				Any     )    ->				Any:
												for file_idx, file in enumerate(itertools.chain.from_iterable(__lowerCamelCase     )     ):
																			with open(__lowerCamelCase	,  "rb"     ) as f:
																										try:
																																	for batch_idx, record_batch in enumerate(pa.ipc.open_stream(__lowerCamelCase     )     ):
																																								__UpperCAmelCase						:			Optional[int]         =   pa.Table.from_batches([record_batch]     )
																																								# Uncomment for debugging (will print the Arrow table size and elements)
																																								# logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
																																								# logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																																								yield f'''{file_idx}_{batch_idx}''', self._cast_table(__lowerCamelCase     )
																										except ValueError as e:
																																	logger.error(f'''Failed to read file \'{file}\' with error {type(__lowerCamelCase     )}: {e}'''     )
																																	raise




