





"""simple docstring"""





import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


_UpperCamelCase					      =   logging.get_logger(__name__)



def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							__lowerCamelCase   :   List[str]       =os.getenv('''SM_HP_MP_PARAMETERS'''     ,    '''{}''' )
							try:
														# Parse it and check the field "partitions" is included, it is required for model parallel.
														__lowerCamelCase   :   Tuple       =json.loads(UpperCamelCase__ )
														if "partitions" not in smp_options:
																					return False
							except json.JSONDecodeError:
														return False

							# Get the sagemaker specific framework parameters from mpi_options variable.
							__lowerCamelCase   :   int       =os.getenv('''SM_FRAMEWORK_PARAMS'''     ,    '''{}''' )
							try:
														# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
														__lowerCamelCase   :   Optional[Any]       =json.loads(UpperCamelCase__ )
														if not mpi_options.get('''sagemaker_mpi_enabled'''     ,    UpperCamelCase__ ):
																					return False
							except json.JSONDecodeError:
														return False
							# Lastly, check if the `smdistributed` module is present.
							return importlib.util.find_spec('''smdistributed''' ) is not None


if is_sagemaker_model_parallel_available():
							import smdistributed.modelparallel.torch as smp

							smp.init()
@dataclass
class 		SCREAMING_SNAKE_CASE_				(     UpperCamelCase__ ):
				"""simple docstring"""
				__snake_case :							List[str]									=		field(
				    default=""""""							,	metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""}							,	)




				def        __lowercase	(  self	:Any      ):
											super().__post_init__()
											warnings.warn(
											    '''`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '''
											    '''`TrainingArguments` instead.'''    ,     __A    ,     )




				@cached_property
				def        __lowercase	(  self	:List[Any]      ):
											logger.info('''PyTorch: setting up devices'''      )
											if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
																		logger.warning(
																		    '''torch.distributed process group is initialized, but local_rank == -1. '''
																		    '''In order to use Torch DDP, launch your script with `python -m torch.distributed.launch'''      )
											if self.no_cuda:
																		__lowerCamelCase   :   str       =torch.device('''cpu'''      )
																		__lowerCamelCase   :   Any       =0
											elif is_sagemaker_model_parallel_available():
																		__lowerCamelCase   :   List[str]       =smp.local_rank()
																		__lowerCamelCase   :   List[Any]       =torch.device('''cuda'''    ,     __A      )
																		__lowerCamelCase   :   List[Any]       =1
											elif is_sagemaker_dp_enabled():
																		import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

																		torch.distributed.init_process_group(backend='''smddp'''    ,     timeout=self.ddp_timeout_delta      )
																		__lowerCamelCase   :   Any       =int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''      )      )
																		__lowerCamelCase   :   Optional[int]       =torch.device('''cuda'''    ,     self.local_rank      )
																		__lowerCamelCase   :   List[Any]       =1
											elif self.local_rank == -1:
																		# if n_gpu is > 1 we'll use nn.DataParallel.
																		# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																		# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
																		# trigger an error that a device index is missing. Index 0 takes into account the
																		# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
																		# will use the first GPU in that env, i.e. GPU#1
																		__lowerCamelCase   :   Dict       =torch.device('''cuda:0''' if torch.cuda.is_available() else '''cpu'''      )
																		# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
																		# the default value.
																		__lowerCamelCase   :   int       =torch.cuda.device_count()
											else:
																		# Here, we'll use torch.distributed.
																		# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
																		if not torch.distributed.is_initialized():
																									torch.distributed.init_process_group(backend='''nccl'''    ,     timeout=self.ddp_timeout_delta      )
																		__lowerCamelCase   :   Any       =torch.device('''cuda'''    ,     self.local_rank      )
																		__lowerCamelCase   :   Optional[int]       =1

											if device.type == "cuda":
																		torch.cuda.set_device(__A      )

											return device




				@property
				def        __lowercase	(  self	:Tuple      ):



											if is_sagemaker_model_parallel_available():
																		return smp.dp_size()

											return super().world_size




				@property
				def        __lowercase	(  self	:int      ):
											return not is_sagemaker_model_parallel_available()




				@property
				def        __lowercase	(  self	:Any      ):
											return False











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 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       42




class 	UpperCamelCase_							(  UpperCamelCase__					,	UpperCamelCase__     ):


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



									"""simple docstring"""



									super().__init__()

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

									SCREAMING_SNAKE_CASE__								=   vq_embed_dim if vq_embed_dim is not None else latent_channels

									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)
									SCREAMING_SNAKE_CASE__								=   VectorQuantizer(__A				,					__A				,					beta=0.2_5				,					remap=__A				,					sane_index_shape=__A		)
									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)

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


							@apply_forward_hook
							def   _snake_case	(				self     :Union[str, Any]				,					__A     :torch.FloatTensor				,					__A     :bool = True		) -> VQEncoderOutput:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.encoder(__A		)
									SCREAMING_SNAKE_CASE__								=   self.quant_conv(__A		)

									if not return_dict:
											return (h,)

									return VQEncoderOutput(latents=__A		)


							@apply_forward_hook
							def   _snake_case	(				self     :Tuple				,					__A     :torch.FloatTensor				,					__A     :bool = False				,					__A     :bool = True		) -> Union[DecoderOutput, torch.FloatTensor]:



									"""simple docstring"""



									if not force_not_quantize:
											SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self.quantize(__A		)
									else:
											SCREAMING_SNAKE_CASE__								=   h
									SCREAMING_SNAKE_CASE__								=   self.post_quant_conv(__A		)
									SCREAMING_SNAKE_CASE__								=   self.decoder(__A				,					quant if self.config.norm_type == """spatial""" else None		)

									if not return_dict:
											return (dec,)

									return DecoderOutput(sample=__A		)


							def   _snake_case	(				self     :int				,					__A     :torch.FloatTensor				,					__A     :bool = True		) -> Union[DecoderOutput, torch.FloatTensor]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   sample
									SCREAMING_SNAKE_CASE__								=   self.encode(__A		).latents
									SCREAMING_SNAKE_CASE__								=   self.decode(__A		).sample

									if not return_dict:
											return (dec,)

									return DecoderOutput(sample=__A		)