





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_snake_case    :       Tuple		       =    {
    'configuration_swiftformer': [
        'SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SwiftFormerConfig',
        'SwiftFormerOnnxConfig',
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _snake_case    :       Any		       =    [
         'SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'SwiftFormerForImageClassification',
         'SwiftFormerModel',
         'SwiftFormerPreTrainedModel',
     ]

if TYPE_CHECKING:
     from .configuration_swiftformer import (
         SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
         SwiftFormerConfig,
         SwiftFormerOnnxConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_swiftformer import (
              SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              SwiftFormerForImageClassification,
              SwiftFormerModel,
              SwiftFormerPreTrainedModel,
          )

else:
     import sys

     _snake_case    :       Any		       =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



"""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, apply_forward_hook
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer



@dataclass
class 	__a	(   _lowerCAmelCase						):
       UpperCamelCase_		:       torch.FloatTensor





class 	__a	(   _lowerCAmelCase     ,  _lowerCAmelCase						):






       @register_to_config
       def __init__(	self			:				int							,   UpperCAmelCase_			:				int = 3							,   UpperCAmelCase_			:				int = 3							,   UpperCAmelCase_			:				Tuple[str] = ("DownEncoderBlock2D",)							,   UpperCAmelCase_			:				Tuple[str] = ("UpDecoderBlock2D",)							,   UpperCAmelCase_			:				Tuple[int] = (64,)							,   UpperCAmelCase_			:				int = 1							,   UpperCAmelCase_			:				str = "silu"							,   UpperCAmelCase_			:				int = 3							,   UpperCAmelCase_			:				int = 32							,   UpperCAmelCase_			:				int = 256							,   UpperCAmelCase_			:				int = 32							,   UpperCAmelCase_			:				Optional[int] = None							,   UpperCAmelCase_			:				float = 0.18215							,   UpperCAmelCase_			:				str = "group"							,   )->	Optional[Any]:







              """simple docstring"""
              super().__init__()

              # pass init params to Encoder
              UpperCamelCase       			=		Encoder(
                  in_channels=UpperCAmelCase_							,   out_channels=UpperCAmelCase_							,   down_block_types=UpperCAmelCase_							,   block_out_channels=UpperCAmelCase_							,   layers_per_block=UpperCAmelCase_							,   act_fn=UpperCAmelCase_							,   norm_num_groups=UpperCAmelCase_							,   double_z=UpperCAmelCase_							,   )

              UpperCamelCase       			=		vq_embed_dim if vq_embed_dim is not None else latent_channels

              UpperCamelCase       			=		nn.Convad(UpperCAmelCase_							,   UpperCAmelCase_							,   1      )
              UpperCamelCase       			=		VectorQuantizer(UpperCAmelCase_							,   UpperCAmelCase_							,   beta=0.25							,   remap=UpperCAmelCase_							,   sane_index_shape=UpperCAmelCase_      )
              UpperCamelCase       			=		nn.Convad(UpperCAmelCase_							,   UpperCAmelCase_							,   1      )

              # pass init params to Decoder
              UpperCamelCase       			=		Decoder(
                  in_channels=UpperCAmelCase_							,   out_channels=UpperCAmelCase_							,   up_block_types=UpperCAmelCase_							,   block_out_channels=UpperCAmelCase_							,   layers_per_block=UpperCAmelCase_							,   act_fn=UpperCAmelCase_							,   norm_num_groups=UpperCAmelCase_							,   norm_type=UpperCAmelCase_							,   )






       @apply_forward_hook
       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[str]							,   UpperCAmelCase_			:				torch.FloatTensor							,   UpperCAmelCase_			:				bool = True      )->	VQEncoderOutput:







              """simple docstring"""
              UpperCamelCase       			=		self.encoder(UpperCAmelCase_      )
              UpperCamelCase       			=		self.quant_conv(UpperCAmelCase_      )

              if not return_dict:
                     return (h,)

              return VQEncoderOutput(latents=UpperCAmelCase_      )






       @apply_forward_hook
       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]							,   UpperCAmelCase_			:				torch.FloatTensor							,   UpperCAmelCase_			:				bool = False							,   UpperCAmelCase_			:				bool = True      )->	Union[DecoderOutput, torch.FloatTensor]:







              """simple docstring"""
              # also go through quantization layer
              if not force_not_quantize:
                     UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase       			=		self.quantize(UpperCAmelCase_      )
              else:
                     UpperCamelCase       			=		h
              UpperCamelCase       			=		self.post_quant_conv(UpperCAmelCase_      )
              UpperCamelCase       			=		self.decoder(UpperCAmelCase_							,   quant if self.config.norm_type == "spatial" else None      )

              if not return_dict:
                     return (dec,)

              return DecoderOutput(sample=UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]							,   UpperCAmelCase_			:				torch.FloatTensor							,   UpperCAmelCase_			:				bool = True      )->	Union[DecoderOutput, torch.FloatTensor]:







              """simple docstring"""
              UpperCamelCase       			=		sample
              UpperCamelCase       			=		self.encode(UpperCAmelCase_      ).latents
              UpperCamelCase       			=		self.decode(UpperCAmelCase_      ).sample

              if not return_dict:
                     return (dec,)

              return DecoderOutput(sample=UpperCAmelCase_      )





