

'''simple docstring'''






from dataclasses import dataclass
from typing import Optional

import numpy as np
import torch
import torch.nn as nn

from ..utils import BaseOutput, is_torch_version, randn_tensor
from .attention_processor import SpatialNorm
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block






@dataclass
class 			lowercase_	(lowerCamelCase__      ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE    :  torch.FloatTensor






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Tuple=3					,lowercase__   :     List[str]=3					,lowercase__   :     str=("DownEncoderBlock2D",)					,lowercase__   :     List[str]=(6_4,)					,lowercase__   :     List[str]=2					,lowercase__   :     Optional[Any]=3_2					,lowercase__   :     List[str]="silu"					,lowercase__   :     List[str]=True					,):
   super().__init__()
   __lowercase							  = layers_per_block

   __lowercase							  = torch.nn.Convad(
       lowercase__					,block_out_channels[0]					,kernel_size=3					,stride=1					,padding=1					,)

   __lowercase							  = None
   __lowercase							  = nn.ModuleList([]			)

   # down
   __lowercase							  = block_out_channels[0]
   for i, down_block_type in enumerate(lowercase__			):
    __lowercase							  = output_channel
    __lowercase							  = block_out_channels[i]
    __lowercase							  = i == len(lowercase__			) - 1

    __lowercase							  = get_down_block(
        lowercase__					,num_layers=self.layers_per_block					,in_channels=lowercase__					,out_channels=lowercase__					,add_downsample=not is_final_block					,resnet_eps=1e-6					,downsample_padding=0					,resnet_act_fn=lowercase__					,resnet_groups=lowercase__					,attention_head_dim=lowercase__					,temb_channels=lowercase__					,)
    self.down_blocks.append(lowercase__			)

   # mid
   __lowercase							  = UNetMidBlockaD(
       in_channels=block_out_channels[-1]					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,output_scale_factor=1					,resnet_time_scale_shift='''default'''					,attention_head_dim=block_out_channels[-1]					,resnet_groups=lowercase__					,temb_channels=lowercase__					,)

   # out
   __lowercase							  = nn.GroupNorm(num_channels=block_out_channels[-1]					,num_groups=lowercase__					,eps=1e-6			)
   __lowercase							  = nn.SiLU()

   __lowercase							  = 2 * out_channels if double_z else out_channels
   __lowercase							  = nn.Convad(block_out_channels[-1]					,lowercase__					,3					,padding=1			)

   __lowercase							  = False






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any					,lowercase__   :     Any			):
   __lowercase							  = x
   __lowercase							  = self.conv_in(lowercase__			)

   if self.training and self.gradient_checkpointing:

    def create_custom_forward(lowercase__   :     List[Any]			):
     def custom_forward(*lowercase__   :     Dict			):
      return module(*lowercase__			)

     return custom_forward

    # down
    if is_torch_version('''>='''					,'''1.11.0'''			):
     for down_block in self.down_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(
          create_custom_forward(lowercase__			)					,lowercase__					,use_reentrant=lowercase__			)
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,use_reentrant=lowercase__			)
    else:
     for down_block in self.down_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase__			)					,lowercase__			)
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block			)					,lowercase__			)

   else:
    # down
    for down_block in self.down_blocks:
     __lowercase							  = down_block(lowercase__			)

    # middle
    __lowercase							  = self.mid_block(lowercase__			)

   # post-process
   __lowercase							  = self.conv_norm_out(lowercase__			)
   __lowercase							  = self.conv_act(lowercase__			)
   __lowercase							  = self.conv_out(lowercase__			)

   return sample






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Optional[Any]=3					,lowercase__   :     Any=3					,lowercase__   :     Union[str, Any]=("UpDecoderBlock2D",)					,lowercase__   :     Any=(6_4,)					,lowercase__   :     str=2					,lowercase__   :     Optional[int]=3_2					,lowercase__   :     Tuple="silu"					,lowercase__   :     Union[str, Any]="group"					,):
   super().__init__()
   __lowercase							  = layers_per_block

   __lowercase							  = nn.Convad(
       lowercase__					,block_out_channels[-1]					,kernel_size=3					,stride=1					,padding=1					,)

   __lowercase							  = None
   __lowercase							  = nn.ModuleList([]			)

   __lowercase							  = in_channels if norm_type == '''spatial''' else None

   # mid
   __lowercase							  = UNetMidBlockaD(
       in_channels=block_out_channels[-1]					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,output_scale_factor=1					,resnet_time_scale_shift='''default''' if norm_type == '''group''' else norm_type					,attention_head_dim=block_out_channels[-1]					,resnet_groups=lowercase__					,temb_channels=lowercase__					,)

   # up
   __lowercase							  = list(reversed(lowercase__			)			)
   __lowercase							  = reversed_block_out_channels[0]
   for i, up_block_type in enumerate(lowercase__			):
    __lowercase							  = output_channel
    __lowercase							  = reversed_block_out_channels[i]

    __lowercase							  = i == len(lowercase__			) - 1

    __lowercase							  = get_up_block(
        lowercase__					,num_layers=self.layers_per_block + 1					,in_channels=lowercase__					,out_channels=lowercase__					,prev_output_channel=lowercase__					,add_upsample=not is_final_block					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,resnet_groups=lowercase__					,attention_head_dim=lowercase__					,temb_channels=lowercase__					,resnet_time_scale_shift=lowercase__					,)
    self.up_blocks.append(lowercase__			)
    __lowercase							  = output_channel

   # out
   if norm_type == "spatial":
    __lowercase							  = SpatialNorm(block_out_channels[0]					,lowercase__			)
   else:
    __lowercase							  = nn.GroupNorm(num_channels=block_out_channels[0]					,num_groups=lowercase__					,eps=1e-6			)
   __lowercase							  = nn.SiLU()
   __lowercase							  = nn.Convad(block_out_channels[0]					,lowercase__					,3					,padding=1			)

   __lowercase							  = False






  def 					SCREAMING_SNAKE_CASE      (      self   :     str					,lowercase__   :     Optional[Any]					,lowercase__   :     List[Any]=None			):
   __lowercase							  = z
   __lowercase							  = self.conv_in(lowercase__			)

   __lowercase							  = next(iter(self.up_blocks.parameters()			)			).dtype
   if self.training and self.gradient_checkpointing:

    def create_custom_forward(lowercase__   :     str			):
     def custom_forward(*lowercase__   :     List[Any]			):
      return module(*lowercase__			)

     return custom_forward

    if is_torch_version('''>='''					,'''1.11.0'''			):
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,lowercase__					,use_reentrant=lowercase__			)
     __lowercase							  = sample.to(lowercase__			)

     # up
     for up_block in self.up_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(
          create_custom_forward(lowercase__			)					,lowercase__					,lowercase__					,use_reentrant=lowercase__			)
    else:
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,lowercase__			)
     __lowercase							  = sample.to(lowercase__			)

     # up
     for up_block in self.up_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase__			)					,lowercase__					,lowercase__			)
   else:
    # middle
    __lowercase							  = self.mid_block(lowercase__					,lowercase__			)
    __lowercase							  = sample.to(lowercase__			)

    # up
    for up_block in self.up_blocks:
     __lowercase							  = up_block(lowercase__					,lowercase__			)

        # post-process
   if latent_embeds is None:
    __lowercase							  = self.conv_norm_out(lowercase__			)
   else:
    __lowercase							  = self.conv_norm_out(lowercase__					,lowercase__			)
   __lowercase							  = self.conv_act(lowercase__			)
   __lowercase							  = self.conv_out(lowercase__			)

   return sample






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     int					,lowercase__   :     str					,lowercase__   :     List[Any]					,lowercase__   :     str					,lowercase__   :     int=None					,lowercase__   :     int="random"					,lowercase__   :     Tuple=False					,lowercase__   :     List[str]=True			):
   super().__init__()
   __lowercase							  = n_e
   __lowercase							  = vq_embed_dim
   __lowercase							  = beta
   __lowercase							  = legacy

   __lowercase							  = nn.Embedding(self.n_e					,self.vq_embed_dim			)
   self.embedding.weight.data.uniform_(-1.0 / self.n_e					,1.0 / self.n_e			)

   __lowercase							  = remap
   if self.remap is not None:
    self.register_buffer('''used'''					,torch.tensor(np.load(self.remap			)			)			)
    __lowercase							  = self.used.shape[0]
    __lowercase							  = unknown_index  # "random" or "extra" or integer
    if self.unknown_index == "extra":
     __lowercase							  = self.re_embed
     __lowercase							  = self.re_embed + 1
    print(
        F"Remapping {self.n_e} indices to {self.re_embed} indices. "
        F"Using {self.unknown_index} for unknown indices."			)
   else:
    __lowercase							  = n_e

   __lowercase							  = sane_index_shape






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]					,lowercase__   :     List[Any]			):
   __lowercase							  = inds.shape
   assert len(lowercase__			) > 1
   __lowercase							  = inds.reshape(ishape[0]					,-1			)
   __lowercase							  = self.used.to(lowercase__			)
   __lowercase							  = (inds[:, :, None] == used[None, None, ...]).long()
   __lowercase							  = match.argmax(-1			)
   __lowercase							  = match.sum(2			) < 1
   if self.unknown_index == "random":
    __lowercase							  = torch.randint(0					,self.re_embed					,size=new[unknown].shape			).to(device=new.device			)
   else:
    __lowercase							  = self.unknown_index
   return new.reshape(lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     Any			):
   __lowercase							  = inds.shape
   assert len(lowercase__			) > 1
   __lowercase							  = inds.reshape(ishape[0]					,-1			)
   __lowercase							  = self.used.to(lowercase__			)
   if self.re_embed > self.used.shape[0]:  # extra token
    __lowercase							  = 0  # simply set to zero
   __lowercase							  = torch.gather(used[None, :][inds.shape[0] * [0], :]					,1					,lowercase__			)
   return back.reshape(lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]					,lowercase__   :     Tuple			):
   # reshape z -> (batch, height, width, channel) and flatten
   __lowercase							  = z.permute(0					,2					,3					,1			).contiguous()
   __lowercase							  = z.view(-1					,self.vq_embed_dim			)

   # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
   __lowercase							  = torch.argmin(torch.cdist(lowercase__					,self.embedding.weight			)					,dim=1			)

   __lowercase							  = self.embedding(lowercase__			).view(z.shape			)
   __lowercase							  = None
   __lowercase							  = None

   # compute loss for embedding
   if not self.legacy:
    __lowercase							  = self.beta * torch.mean((z_q.detach() - z) ** 2			) + torch.mean((z_q - z.detach()) ** 2			)
   else:
    __lowercase							  = torch.mean((z_q.detach() - z) ** 2			) + self.beta * torch.mean((z_q - z.detach()) ** 2			)

   # preserve gradients
   __lowercase							  = z + (z_q - z).detach()

   # reshape back to match original input shape
   __lowercase							  = z_q.permute(0					,3					,1					,2			).contiguous()

   if self.remap is not None:
    __lowercase							  = min_encoding_indices.reshape(z.shape[0]					,-1			)  # add batch axis
    __lowercase							  = self.remap_to_used(lowercase__			)
    __lowercase							  = min_encoding_indices.reshape(-1					,1			)  # flatten

   if self.sane_index_shape:
    __lowercase							  = min_encoding_indices.reshape(z_q.shape[0]					,z_q.shape[2]					,z_q.shape[3]			)

   return z_q, loss, (perplexity, min_encodings, min_encoding_indices)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     List[Any]					,lowercase__   :     List[str]			):
   # shape specifying (batch, height, width, channel)
   if self.remap is not None:
    __lowercase							  = indices.reshape(shape[0]					,-1			)  # add batch axis
    __lowercase							  = self.unmap_to_all(lowercase__			)
    __lowercase							  = indices.reshape(-1			)  # flatten again

   # get quantized latent vectors
   __lowercase							  = self.embedding(lowercase__			)

   if shape is not None:
    __lowercase							  = z_q.view(lowercase__			)
    # reshape back to match original input shape
    __lowercase							  = z_q.permute(0					,3					,1					,2			).contiguous()

   return z_q






class 			lowercase_	(lowerCamelCase__      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Union[str, Any]					,lowercase__   :     Union[str, Any]=False			):
   __lowercase							  = parameters
   __lowercase  ,	__lowercase							  = torch.chunk(lowercase__					,2					,dim=1			)
   __lowercase							  = torch.clamp(self.logvar					,-3_0.0					,2_0.0			)
   __lowercase							  = deterministic
   __lowercase							  = torch.exp(0.5 * self.logvar			)
   __lowercase							  = torch.exp(self.logvar			)
   if self.deterministic:
    __lowercase							  = __lowercase							  = torch.zeros_like(
        self.mean					,device=self.parameters.device					,dtype=self.parameters.dtype			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]					,lowercase__   :     Optional[torch.Generator] = None			):
   # make sure sample is on the same device as the parameters and has same dtype
   __lowercase							  = randn_tensor(
       self.mean.shape					,generator=lowercase__					,device=self.parameters.device					,dtype=self.parameters.dtype			)
   __lowercase							  = self.mean + self.std * sample
   return x






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     Any=None			):
   if self.deterministic:
    return torch.Tensor([0.0]			)
   else:
    if other is None:
     return 0.5 * torch.sum(torch.pow(self.mean					,2			) + self.var - 1.0 - self.logvar					,dim=[1, 2, 3]			)
    else:
     return 0.5 * torch.sum(
         torch.pow(self.mean - other.mean					,2			) / other.var
         + self.var / other.var
         - 1.0
         - self.logvar
         + other.logvar					,dim=[1, 2, 3]					,)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     List[str]					,lowercase__   :     str=[1, 2, 3]			):
   if self.deterministic:
    return torch.Tensor([0.0]			)
   __lowercase							  = np.log(2.0 * np.pi			)
   return 0.5 * torch.sum(logtwopi + self.logvar + torch.pow(sample - self.mean					,2			) / self.var					,dim=lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   return self.mean




'''simple docstring'''






from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_torch_available
from ...utils import OptionalDependencyNotAvailable


lowerCAmelCase__											=	{
    '''configuration_gpt_neox_japanese''': ['''GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTNeoXJapaneseConfig'''],
    '''tokenization_gpt_neox_japanese''': ['''GPTNeoXJapaneseTokenizer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase__											=	[
     '''GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''GPTNeoXJapaneseForCausalLM''',
     '''GPTNeoXJapaneseLayer''',
     '''GPTNeoXJapaneseModel''',
     '''GPTNeoXJapanesePreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_gpt_neox_japanese import GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXJapaneseConfig
 from .tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_gpt_neox_japanese import (
      GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
      GPTNeoXJapaneseForCausalLM,
      GPTNeoXJapaneseLayer,
      GPTNeoXJapaneseModel,
      GPTNeoXJapanesePreTrainedModel,
  )


else:
 import sys

 lowerCAmelCase__											=	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

