






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


A_       :int       =						logging.get_logger(__name__)






def 							A     (       )     ->						Optional[int]:
					# Get the sagemaker specific mp parameters from smp_options variable.
					__UpperCamelCase      :					Optional[int]       		=os.getenv('SM_HP_MP_PARAMETERS'							,'{}'					)
					try:
										# Parse it and check the field "partitions" is included, it is required for model parallel.
										__UpperCamelCase      :					Any       		=json.loads(a_					)
										if "partitions" not in smp_options:
															return False
					except json.JSONDecodeError:
										return False

					# Get the sagemaker specific framework parameters from mpi_options variable.
					__UpperCamelCase      :					int       		=os.getenv('SM_FRAMEWORK_PARAMS'							,'{}'					)
					try:
										# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
										__UpperCamelCase      :					Dict       		=json.loads(a_					)
										if not mpi_options.get('sagemaker_mpi_enabled'							,a_					):
															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 				__A     (			a ):





				"""simple docstring"""







				UpperCamelCase__ :      str			 =field(
				    default=""""""      ,     metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""}      ,     )


				def       __lowercase							( self    ):




									"""simple docstring"""

									super().__post_init__()
									warnings.warn(
									    '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
									    '`TrainingArguments` instead.'							,  lowerCamelCase__							,  )


				@cached_property
				def       __lowercase							( self    ):




									"""simple docstring"""

									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:
														__UpperCamelCase      :					Dict       		=torch.device('cpu'    )
														__UpperCamelCase      :					Any       		=0
									elif is_sagemaker_model_parallel_available():
														__UpperCamelCase      :					Optional[Any]       		=smp.local_rank()
														__UpperCamelCase      :					Union[str, Any]       		=torch.device('cuda'							,  lowerCamelCase__    )
														__UpperCamelCase      :					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    )
														__UpperCamelCase      :					Union[str, Any]       		=int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'    )    )
														__UpperCamelCase      :					Union[str, Any]       		=torch.device('cuda'							,  self.local_rank    )
														__UpperCamelCase      :					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
														__UpperCamelCase      :					List[Any]       		=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.
														__UpperCamelCase      :					Optional[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    )
														__UpperCamelCase      :					str       		=torch.device('cuda'							,  self.local_rank    )
														__UpperCamelCase      :					Union[str, Any]       		=1

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

									return device


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									if is_sagemaker_model_parallel_available():
														return smp.dp_size()

									return super().world_size


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return not is_sagemaker_model_parallel_available()







				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return False




"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


__UpperCamelCase  :      Dict							      =		{
    '''configuration_clip''': [
        '''CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPConfig''',
        '''CLIPOnnxConfig''',
        '''CLIPTextConfig''',
        '''CLIPVisionConfig''',
    ],
    '''processing_clip''': ['''CLIPProcessor'''],
    '''tokenization_clip''': ['''CLIPTokenizer'''],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase  :      int							      =		['''CLIPTokenizerFast''']

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase  :      Optional[int]							      =		['''CLIPFeatureExtractor''']
							__UpperCamelCase  :      Optional[Any]							      =		['''CLIPImageProcessor''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase  :      Tuple							      =		[
							    '''CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''CLIPModel''',
							    '''CLIPPreTrainedModel''',
							    '''CLIPTextModel''',
							    '''CLIPTextModelWithProjection''',
							    '''CLIPVisionModel''',
							    '''CLIPVisionModelWithProjection''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase  :      Optional[int]							      =		[
							    '''TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFCLIPModel''',
							    '''TFCLIPPreTrainedModel''',
							    '''TFCLIPTextModel''',
							    '''TFCLIPVisionModel''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase  :      Optional[Any]							      =		[
							    '''FlaxCLIPModel''',
							    '''FlaxCLIPPreTrainedModel''',
							    '''FlaxCLIPTextModel''',
							    '''FlaxCLIPTextPreTrainedModel''',
							    '''FlaxCLIPVisionModel''',
							    '''FlaxCLIPVisionPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_clip import (
							    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    CLIPConfig,
							    CLIPOnnxConfig,
							    CLIPTextConfig,
							    CLIPVisionConfig,
							)
							from .processing_clip import CLIPProcessor
							from .tokenization_clip import CLIPTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_clip_fast import CLIPTokenizerFast

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_clip import CLIPFeatureExtractor
														from .image_processing_clip import CLIPImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_clip import (
														    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    CLIPModel,
														    CLIPPreTrainedModel,
														    CLIPTextModel,
														    CLIPTextModelWithProjection,
														    CLIPVisionModel,
														    CLIPVisionModelWithProjection,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_clip import (
														    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFCLIPModel,
														    TFCLIPPreTrainedModel,
														    TFCLIPTextModel,
														    TFCLIPVisionModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_clip import (
														    FlaxCLIPModel,
														    FlaxCLIPPreTrainedModel,
														    FlaxCLIPTextModel,
														    FlaxCLIPTextPreTrainedModel,
														    FlaxCLIPVisionModel,
														    FlaxCLIPVisionPreTrainedModel,
														)


else:
							import sys

							__UpperCamelCase  :      Tuple							      =		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




