

"""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       SCREAMING_SNAKE_CASE							( )			->						str:
 # Get the sagemaker specific mp parameters from smp_options variable.
 lowerCAmelCase__   :				Tuple 			=				os.getenv("SM_HP_MP_PARAMETERS"					,					"{}"   )
 try:
  # Parse it and check the field "partitions" is included, it is required for model parallel.
  lowerCAmelCase__   :				Dict 			=				json.loads(lowercase__   )
  if "partitions" not in smp_options:
   return False
 except json.JSONDecodeError:
  return False

 # Get the sagemaker specific framework parameters from mpi_options variable.
 lowerCAmelCase__   :				List[Any] 			=				os.getenv("SM_FRAMEWORK_PARAMS"					,					"{}"   )
 try:
  # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
  lowerCAmelCase__   :				Optional[Any] 			=				json.loads(lowercase__   )
  if not mpi_options.get("sagemaker_mpi_enabled"					,					lowercase__   ):
   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					(						__magic_name__       ):





       """simple docstring"""


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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

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






       @cached_property
       def 			SCREAMING_SNAKE_CASE_	(   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:
         lowerCAmelCase__   :				Union[str, Any] 			=				torch.device("cpu"   )
         lowerCAmelCase__   :				int 			=				0
        elif is_sagemaker_model_parallel_available():
         lowerCAmelCase__   :				Optional[Any] 			=				smp.local_rank()
         lowerCAmelCase__   :				List[Any] 			=				torch.device("cuda"			,					snake_case   )
         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__   :				List[Any] 			=				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__   :				Union[str, 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__   :				Union[str, 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__   :				str 			=				torch.device("cuda"			,					self.local_rank   )
         lowerCAmelCase__   :				Optional[Any] 			=				1

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

        return device






       @property
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        if is_sagemaker_model_parallel_available():
         return smp.dp_size()

        return super().world_size






       @property
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        return not is_sagemaker_model_parallel_available()






       @property
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        return False









"""simple docstring"""

from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
    from PIL import Image

    from ..image_utils import load_image

if is_torch_available():
    from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

_UpperCamelCase		     =    logging.get_logger(__name__)






@add_end_docstrings(__magic_name__       )
class 			__a					(						__magic_name__       ):





       """simple docstring"""


       def __init__(   self			,					*snake_case			,					**snake_case   ):





        """simple docstring"""

        super().__init__(*snake_case			,					**snake_case   )
        self.check_model_type(snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case=None			,					snake_case=None			,					snake_case=None			,					**snake_case   ):





        """simple docstring"""

        lowerCAmelCase__			,						lowerCAmelCase__   :				List[Any] 			=				{}, {}
        if padding is not None:
         lowerCAmelCase__   :				Dict 			=				padding
        if truncation is not None:
         lowerCAmelCase__   :				Tuple 			=				truncation
        if top_k is not None:
         lowerCAmelCase__   :				str 			=				top_k
        return preprocess_params, {}, postprocess_params






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





        """simple docstring"""

        if isinstance(snake_case			,					(Image.Image, str)   ) and isinstance(snake_case			,					snake_case   ):
         lowerCAmelCase__   :				int 			=				{"image": image, "question": question}
        else:
         lowerCAmelCase__   :				Optional[int] 			=				image
        lowerCAmelCase__   :				Optional[Any] 			=				super().__call__(snake_case			,					**snake_case   )
        return results






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case=False			,					snake_case=False   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				load_image(inputs["image"]   )
        lowerCAmelCase__   :				str 			=				self.tokenizer(
            inputs["question"]			,					return_tensors=self.framework			,					padding=snake_case			,					truncation=snake_case   )
        lowerCAmelCase__   :				int 			=				self.image_processor(images=snake_case			,					return_tensors=self.framework   )
        model_inputs.update(snake_case   )
        return model_inputs






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[int] 			=				self.model(**snake_case   )
        return model_outputs






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case=5   ):





        """simple docstring"""

        if top_k > self.model.config.num_labels:
         lowerCAmelCase__   :				List[Any] 			=				self.model.config.num_labels

        if self.framework == "pt":
         lowerCAmelCase__   :				Optional[int] 			=				model_outputs.logits.sigmoid()[0]
         lowerCAmelCase__			,						lowerCAmelCase__   :				Optional[int] 			=				probs.topk(snake_case   )
        else:
         raise ValueError(F"""Unsupported framework: {self.framework}"""   )

        lowerCAmelCase__   :				int 			=				scores.tolist()
        lowerCAmelCase__   :				str 			=				ids.tolist()
        return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(snake_case			,					snake_case   )]






