




'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging


a		:	Optional[Any]       =      logging.get_logger(__name__)

a		:	int       =      {
    '''uw-madison/yoso-4096''': '''https://huggingface.co/uw-madison/yoso-4096/resolve/main/config.json''',
    # See all YOSO models at https://huggingface.co/models?filter=yoso
}




class      UpperCamelCase       (	snake_case__       ):
  a     :int          =					'yoso'



  def __init__(			self		,     __lowerCAmelCase=5_0265		,     __lowerCAmelCase=768		,     __lowerCAmelCase=12		,     __lowerCAmelCase=12		,     __lowerCAmelCase=3072		,     __lowerCAmelCase="gelu"		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=4096		,     __lowerCAmelCase=1		,     __lowerCAmelCase=0.02		,     __lowerCAmelCase=1e-12		,     __lowerCAmelCase="absolute"		,     __lowerCAmelCase=True		,     __lowerCAmelCase=9		,     __lowerCAmelCase=64		,     __lowerCAmelCase=None		,     __lowerCAmelCase=True		,     __lowerCAmelCase=True		,     __lowerCAmelCase=1		,     __lowerCAmelCase=0		,     __lowerCAmelCase=2		,     **__lowerCAmelCase		,     ):







      '''simple docstring'''


      super().__init__(pad_token_id=__lowerCAmelCase		,     bos_token_id=__lowerCAmelCase		,     eos_token_id=__lowerCAmelCase		,     **__lowerCAmelCase )

      _a				:							Tuple							       =      vocab_size
      _a				:							List[Any]							       =      max_position_embeddings
      _a				:							int							       =      hidden_size
      _a				:							Optional[int]							       =      num_hidden_layers
      _a				:							Any							       =      num_attention_heads
      _a				:							Any							       =      intermediate_size
      _a				:							Optional[Any]							       =      hidden_act
      _a				:							Union[str, Any]							       =      hidden_dropout_prob
      _a				:							List[str]							       =      attention_probs_dropout_prob
      _a				:							Optional[Any]							       =      initializer_range
      _a				:							Optional[Any]							       =      type_vocab_size
      _a				:							str							       =      layer_norm_eps
      _a				:							str							       =      position_embedding_type
      _a				:							Optional[int]							       =      use_expectation
      _a				:							List[Any]							       =      hash_code_len
      _a				:							Optional[Any]							       =      num_hash
      _a				:							Optional[Any]							       =      conv_window
      _a				:							Optional[Any]							       =      use_fast_hash
      _a				:							Optional[Any]							       =      lsh_backward










'''simple docstring'''






from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block




@dataclass
class a_     (     UpperCamelCase_				):
   _snake_case	   =				42




class a_     (     UpperCamelCase_		,   UpperCamelCase_				):







   @register_to_config
   def __init__(self       , __a = None       , __a = 3       , __a = 3       , __a = False       , __a = "positional"       , __a = 0       , __a = True       , __a = ("DownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D")       , __a = ("AttnUpBlock2D", "AttnUpBlock2D", "AttnUpBlock2D", "UpBlock2D")       , __a = (2_2_4, 4_4_8, 6_7_2, 8_9_6)       , __a = 2       , __a = 1       , __a = 1       , __a = "conv"       , __a = "conv"       , __a = "silu"       , __a = 8       , __a = 3_2       , __a = 1E-5       , __a = "default"       , __a = True       , __a = None       , __a = None       , )      ->   List[str]:
      """simple docstring"""






      super().__init__()

      __snake_case					:   Optional[int]  				=			sample_size
      __snake_case					:   Union[str, Any]  				=			block_out_channels[0] * 4

      # Check inputs
      if len(__a) != len(__a):
         raise ValueError(
             F"""Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}.""")

      if len(__a) != len(__a):
         raise ValueError(
             F"""Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.""")

      # input
      __snake_case					:   Union[str, Any]  				=			nn.Convad(__a       , block_out_channels[0]       , kernel_size=3       , padding=(1, 1))

      # time
      if time_embedding_type == "fourier":
         __snake_case					:   str  				=			GaussianFourierProjection(embedding_size=block_out_channels[0]       , scale=1_6)
         __snake_case					:   Tuple  				=			2 * block_out_channels[0]
      elif time_embedding_type == "positional":
         __snake_case					:   List[str]  				=			Timesteps(block_out_channels[0]       , __a       , __a)
         __snake_case					:   Optional[Any]  				=			block_out_channels[0]

      __snake_case					:   List[Any]  				=			TimestepEmbedding(__a       , __a)

      # class embedding
      if class_embed_type is None and num_class_embeds is not None:
         __snake_case					:   Optional[Any]  				=			nn.Embedding(__a       , __a)
      elif class_embed_type == "timestep":
         __snake_case					:   int  				=			TimestepEmbedding(__a       , __a)
      elif class_embed_type == "identity":
         __snake_case					:   Any  				=			nn.Identity(__a       , __a)
      else:
         __snake_case					:   Dict  				=			None

      __snake_case					:   Union[str, Any]  				=			nn.ModuleList([])
      __snake_case					:   Dict  				=			None
      __snake_case					:   Union[str, Any]  				=			nn.ModuleList([])

      # down
      __snake_case					:   List[str]  				=			block_out_channels[0]
      for i, down_block_type in enumerate(__a):
         __snake_case					:   List[str]  				=			output_channel
         __snake_case					:   Tuple  				=			block_out_channels[i]
         __snake_case					:   Union[str, Any]  				=			i == len(__a) - 1

         __snake_case					:   Dict  				=			get_down_block(
             __a       , num_layers=__a       , in_channels=__a       , out_channels=__a       , temb_channels=__a       , add_downsample=not is_final_block       , resnet_eps=__a       , resnet_act_fn=__a       , resnet_groups=__a       , attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel       , downsample_padding=__a       , resnet_time_scale_shift=__a       , downsample_type=__a       , )
         self.down_blocks.append(__a)

      # mid
      __snake_case					:   List[str]  				=			UNetMidBlockaD(
          in_channels=block_out_channels[-1]       , temb_channels=__a       , resnet_eps=__a       , resnet_act_fn=__a       , output_scale_factor=__a       , resnet_time_scale_shift=__a       , attention_head_dim=attention_head_dim if attention_head_dim is not None else block_out_channels[-1]       , resnet_groups=__a       , add_attention=__a       , )

      # up
      __snake_case					:   List[Any]  				=			list(reversed(__a))
      __snake_case					:   Any  				=			reversed_block_out_channels[0]
      for i, up_block_type in enumerate(__a):
         __snake_case					:   str  				=			output_channel
         __snake_case					:   List[Any]  				=			reversed_block_out_channels[i]
         __snake_case					:   Optional[Any]  				=			reversed_block_out_channels[min(i + 1       , len(__a) - 1)]

         __snake_case					:   Optional[int]  				=			i == len(__a) - 1

         __snake_case					:   List[Any]  				=			get_up_block(
             __a       , num_layers=layers_per_block + 1       , in_channels=__a       , out_channels=__a       , prev_output_channel=__a       , temb_channels=__a       , add_upsample=not is_final_block       , resnet_eps=__a       , resnet_act_fn=__a       , resnet_groups=__a       , attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel       , resnet_time_scale_shift=__a       , upsample_type=__a       , )
         self.up_blocks.append(__a)
         __snake_case					:   Dict  				=			output_channel

      # out
      __snake_case					:   Tuple  				=			norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4       , 3_2)
      __snake_case					:   Tuple  				=			nn.GroupNorm(num_channels=block_out_channels[0]       , num_groups=__a       , eps=__a)
      __snake_case					:   List[str]  				=			nn.SiLU()
      __snake_case					:   List[Any]  				=			nn.Convad(block_out_channels[0]       , __a       , kernel_size=3       , padding=1)







   def      SCREAMING_SNAKE_CASE__       (self       , __a       , __a       , __a = None       , __a = True       , )      ->   Union[UNetaDOutput, Tuple]:
      """simple docstring"""






      if self.config.center_input_sample:
         __snake_case					:   Optional[Any]  				=			2 * sample - 1.0

      # 1. time
      __snake_case					:   Any  				=			timestep
      if not torch.is_tensor(__a):
         __snake_case					:   Dict  				=			torch.tensor([timesteps]       , dtype=torch.long       , device=sample.device)
      elif torch.is_tensor(__a) and len(timesteps.shape) == 0:
         __snake_case					:   Dict  				=			timesteps[None].to(sample.device)

      # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
      __snake_case					:   Optional[int]  				=			timesteps * torch.ones(sample.shape[0]       , dtype=timesteps.dtype       , device=timesteps.device)

      __snake_case					:   Dict  				=			self.time_proj(__a)

      # timesteps does not contain any weights and will always return f32 tensors
      # but time_embedding might actually be running in fp16. so we need to cast here.
      # there might be better ways to encapsulate this.
      __snake_case					:   Optional[Any]  				=			t_emb.to(dtype=self.dtype)
      __snake_case					:   List[Any]  				=			self.time_embedding(__a)

      if self.class_embedding is not None:
         if class_labels is None:
            raise ValueError('class_labels should be provided when doing class conditioning')

         if self.config.class_embed_type == "timestep":
            __snake_case					:   str  				=			self.time_proj(__a)

         __snake_case					:   List[str]  				=			self.class_embedding(__a).to(dtype=self.dtype)
         __snake_case					:   Optional[Any]  				=			emb + class_emb

      # 2. pre-process
      __snake_case					:   List[str]  				=			sample
      __snake_case					:   Optional[Any]  				=			self.conv_in(__a)

      # 3. down
      __snake_case					:   List[str]  				=			(sample,)
      for downsample_block in self.down_blocks:
         if hasattr(__a       , 'skip_conv'):
            __snake_case				,__snake_case				,__snake_case					:   List[str]  				=			downsample_block(
                hidden_states=__a       , temb=__a       , skip_sample=__a)
         else:
            __snake_case				,__snake_case					:   Dict  				=			downsample_block(hidden_states=__a       , temb=__a)

         down_block_res_samples += res_samples

      # 4. mid
      __snake_case					:   Any  				=			self.mid_block(__a       , __a)

      # 5. up
      __snake_case					:   Dict  				=			None
      for upsample_block in self.up_blocks:
         __snake_case					:   int  				=			down_block_res_samples[-len(upsample_block.resnets) :]
         __snake_case					:   Union[str, Any]  				=			down_block_res_samples[: -len(upsample_block.resnets)]

         if hasattr(__a       , 'skip_conv'):
            __snake_case				,__snake_case					:   List[str]  				=			upsample_block(__a       , __a       , __a       , __a)
         else:
            __snake_case					:   int  				=			upsample_block(__a       , __a       , __a)

        # 6. post-process
      __snake_case					:   List[str]  				=			self.conv_norm_out(__a)
      __snake_case					:   Optional[int]  				=			self.conv_act(__a)
      __snake_case					:   Optional[int]  				=			self.conv_out(__a)

      if skip_sample is not None:
         sample += skip_sample

      if self.config.time_embedding_type == "fourier":
         __snake_case					:   str  				=			timesteps.reshape((sample.shape[0], *([1] * len(sample.shape[1:]))))
         __snake_case					:   Union[str, Any]  				=			sample / timesteps

      if not return_dict:
         return (sample,)

      return UNetaDOutput(sample=__a)