





'''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


lowerCAmelCase       		=      logging.get_logger(__name__)






def      __A						(							):
		lowerCAmelCase     :    int						=   os.getenv("SM_HP_MP_PARAMETERS"      ,"{}"	)
		try:
				# Parse it and check the field "partitions" is included, it is required for model parallel.
				lowerCAmelCase     :    List[str]						=   json.loads(_lowerCamelCase	)
				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     :    Any						=   json.loads(_lowerCamelCase	)
				if not mpi_options.get("sagemaker_mpi_enabled"      ,_lowerCamelCase	):
						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 		lowerCamelCase  (      __lowercase       ):
	snake_case_      =   field(
	    default=""      ,   metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}      ,   )



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

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

			return device



	@property
	def   _lowerCamelCase    (   self	):
			if is_sagemaker_model_parallel_available():
					return smp.dp_size()

			return super().world_size



	@property
	def   _lowerCamelCase    (   self	):
			return not is_sagemaker_model_parallel_available()





	@property
	def   _lowerCamelCase    (   self	):
			return False










'''simple docstring'''






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class 		lowerCamelCase  (      _A       ):
	snake_case_      =   ["image_processor", "tokenizer"]
	snake_case_      =   "ChineseCLIPImageProcessor"
	snake_case_      =   ("BertTokenizer", "BertTokenizerFast")



	def __init__(   self		,      a_=None		,      a_=None		,      **a_	):
			lowerCAmelCase     :    Any						=   None
			if "feature_extractor" in kwargs:
					warnings.warn(
					    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
					    " instead."		,      a_		,      )
					lowerCAmelCase     :    Optional[Any]						=   kwargs.pop("feature_extractor"	)

			lowerCAmelCase     :    int						=   image_processor if image_processor is not None else feature_extractor
			if image_processor is None:
					raise ValueError("You need to specify an `image_processor`."	)
			if tokenizer is None:
					raise ValueError("You need to specify a `tokenizer`."	)

			super().__init__(a_		,      a_	)
			lowerCAmelCase     :    Dict						=   self.image_processor



	def __call__(   self		,      a_=None		,      a_=None		,      a_=None		,      **a_	):

			if text is None and images is None:
					raise ValueError("You have to specify either text or images. Both cannot be none."	)

			if text is not None:
					lowerCAmelCase     :    List[str]						=   self.tokenizer(a_		,      return_tensors=a_		,      **a_	)

			if images is not None:
					lowerCAmelCase     :    List[Any]						=   self.image_processor(a_		,      return_tensors=a_		,      **a_	)

			if text is not None and images is not None:
					lowerCAmelCase     :    str						=   image_features.pixel_values
					return encoding
			elif text is not None:
					return encoding
			else:
					return BatchEncoding(data=dict(**a_	)		,      tensor_type=a_	)



	def   _lowerCamelCase    (   self		,      *a_		,      **a_	):
			return self.tokenizer.batch_decode(*a_		,      **a_	)



	def   _lowerCamelCase    (   self		,      *a_		,      **a_	):
			return self.tokenizer.decode(*a_		,      **a_	)



	@property
	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    str						=   self.tokenizer.model_input_names
			lowerCAmelCase     :    List[Any]						=   self.image_processor.model_input_names
			return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names	)	)





	@property
	def   _lowerCamelCase    (   self	):
			warnings.warn(
			    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."		,      a_		,      )
			return self.image_processor_class



