




"""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 							UpperCAmelCase		(		):
					# Get the sagemaker specific mp parameters from smp_options variable.
					_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:List[Any]									=  json.loads(snake_case    )
										if "partitions" not in smp_options:
															return False
					except json.JSONDecodeError:
										return False

					# Get the sagemaker specific framework parameters from mpi_options variable.
					_lowerCAmelCase:str									=  os.getenv('''SM_FRAMEWORK_PARAMS'''      ,       '''{}'''    )
					try:
										# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
										_lowerCAmelCase:Tuple									=  json.loads(snake_case    )
										if not mpi_options.get('''sagemaker_mpi_enabled'''      ,       snake_case    ):
															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__			(       UpperCamelCase_  ):
						snake_case__             = field(
						    default=''''''					,	metadata={'''help''': '''Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'''}					,	)





						def       __UpperCamelCase     (							self      :	List[Any])						->       Optional[int]:




											"""simple docstring"""







											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       __UpperCamelCase     (							self      :	Any)						->       "torch.device":




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

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

											return device





						@property
						def       __UpperCamelCase     (							self      :	Tuple)						->       Optional[Any]:




											"""simple docstring"""







											if is_sagemaker_model_parallel_available():
																return smp.dp_size()

											return super().world_size





						@property
						def       __UpperCamelCase     (							self      :	Any)						->       Optional[int]:




											"""simple docstring"""







											return not is_sagemaker_model_parallel_available()







						@property
						def       __UpperCamelCase     (							self      :	Dict)						->       Dict:




											"""simple docstring"""







											return False












"""simple docstring"""






from typing import TYPE_CHECKING

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


UpperCamelCase__						=			{
    '''configuration_convbert''': ['''CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ConvBertConfig''', '''ConvBertOnnxConfig'''],
    '''tokenization_convbert''': ['''ConvBertTokenizer'''],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCamelCase__						=			['''ConvBertTokenizerFast''']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCamelCase__						=			[
				    '''CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''ConvBertForMaskedLM''',
				    '''ConvBertForMultipleChoice''',
				    '''ConvBertForQuestionAnswering''',
				    '''ConvBertForSequenceClassification''',
				    '''ConvBertForTokenClassification''',
				    '''ConvBertLayer''',
				    '''ConvBertModel''',
				    '''ConvBertPreTrainedModel''',
				    '''load_tf_weights_in_convbert''',
				]


try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCamelCase__						=			[
				    '''TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFConvBertForMaskedLM''',
				    '''TFConvBertForMultipleChoice''',
				    '''TFConvBertForQuestionAnswering''',
				    '''TFConvBertForSequenceClassification''',
				    '''TFConvBertForTokenClassification''',
				    '''TFConvBertLayer''',
				    '''TFConvBertModel''',
				    '''TFConvBertPreTrainedModel''',
				]


if TYPE_CHECKING:
				from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
				from .tokenization_convbert import ConvBertTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_convbert_fast import ConvBertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_convbert import (
								    CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    ConvBertForMaskedLM,
								    ConvBertForMultipleChoice,
								    ConvBertForQuestionAnswering,
								    ConvBertForSequenceClassification,
								    ConvBertForTokenClassification,
								    ConvBertLayer,
								    ConvBertModel,
								    ConvBertPreTrainedModel,
								    load_tf_weights_in_convbert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_convbert import (
								    TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFConvBertForMaskedLM,
								    TFConvBertForMultipleChoice,
								    TFConvBertForQuestionAnswering,
								    TFConvBertForSequenceClassification,
								    TFConvBertForTokenClassification,
								    TFConvBertLayer,
								    TFConvBertModel,
								    TFConvBertPreTrainedModel,
								)


else:
				import sys

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






