


'''simple docstring'''






import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment






class        __snake_case	(       unittest.TestCase):







    """simple docstring"""



    def __lowercase       (       self   :  Tuple		)       ->  List[str]:
      lowerCAmelCase_      :				Optional[Any]      =       inspect.getfile(accelerate.test_utils		)
      lowerCAmelCase_      :				Tuple      =       os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_script.py"""]		)
      lowerCAmelCase_      :				List[Any]      =       os.path.sep.join(
          mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_distributed_data_loop.py"""]		)
      lowerCAmelCase_      :				Union[str, Any]      =       os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_ops.py"""]		)

    @require_multi_gpu
    def __lowercase       (       self   :  Optional[Any]		)       ->  str:
      print(F'Found {torch.cuda.device_count()} devices.'		)
      lowerCAmelCase_      :				Union[str, Any]      =       ["""torchrun""", F'--nproc_per_node={torch.cuda.device_count()}', self.test_file_path]
      with patch_environment(omp_num_threads=1		):
        execute_subprocess_async(lowerCamelCase   ,						env=os.environ.copy()		)

    @require_multi_gpu
    def __lowercase       (       self   :  str		)       ->  int:
      print(F'Found {torch.cuda.device_count()} devices.'		)
      lowerCAmelCase_      :				Any      =       ["""torchrun""", F'--nproc_per_node={torch.cuda.device_count()}', self.operation_file_path]
      print(F'Command: {cmd}'		)
      with patch_environment(omp_num_threads=1		):
        execute_subprocess_async(lowerCamelCase   ,						env=os.environ.copy()		)

    @require_multi_gpu
    def __lowercase       (       self   :  Dict		)       ->  List[str]:
      lowerCAmelCase_      :				Any      =       ["""torchrun""", F'--nproc_per_node={torch.cuda.device_count()}', inspect.getfile(self.__class__		)]
      with patch_environment(omp_num_threads=1		):
        execute_subprocess_async(lowerCamelCase   ,						env=os.environ.copy()		)





    @require_multi_gpu
    def __lowercase       (       self   :  Tuple		)       ->  Any:
      print(F'Found {torch.cuda.device_count()} devices, using 2 devices only'		)
      lowerCAmelCase_      :				List[Any]      =       ["""torchrun""", F'--nproc_per_node={torch.cuda.device_count()}', self.data_loop_file_path]
      with patch_environment(omp_num_threads=1   ,						cuda_visible_devices="""0,1"""		):
        execute_subprocess_async(lowerCamelCase   ,						env=os.environ.copy()		)


if __name__ == "__main__":
  __A :  str    							=				Accelerator()
  __A :  Optional[Any]    							=				(accelerator.state.process_index + 2, 10)
  __A :  List[str]    							=				torch.randint(0, 10, shape).to(accelerator.device)

  __A :  Union[str, Any]    							=				""

  __A :  Dict    							=				accelerator.pad_across_processes(tensor)
  if tensora.shape[0] != accelerator.state.num_processes + 1:
    error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
  if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
    error_msg += "Tensors have different values."
  if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
    error_msg += "Padding was not done with the right value (0)."

  __A :  Tuple    							=				accelerator.pad_across_processes(tensor, pad_first=True)
  if tensora.shape[0] != accelerator.state.num_processes + 1:
    error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
  __A :  Dict    							=				accelerator.state.num_processes - accelerator.state.process_index - 1
  if not torch.equal(tensora[index:], tensor):
    error_msg += "Tensors have different values."
  if not torch.all(tensora[:index] == 0):
    error_msg += "Padding was not done with the right value (0)."

  # Raise error at the end to make sure we don't stop at the first failure.
  if len(error_msg) > 0:
    raise ValueError(error_msg)








'''simple docstring'''






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


__A :  Any    							=				{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

__A :  int    							=				{
    "vocab_file": {
        "unc-nlp/lxmert-base-uncased": "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt",
    },
    "tokenizer_file": {
        "unc-nlp/lxmert-base-uncased": (
            "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json"
        ),
    },
}

__A :  List[Any]    							=				{
    "unc-nlp/lxmert-base-uncased": 512,
}

__A :  Optional[Any]    							=				{
    "unc-nlp/lxmert-base-uncased": {"do_lower_case": True},
}






class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase       			= VOCAB_FILES_NAMES
    lowercase       			= PRETRAINED_VOCAB_FILES_MAP
    lowercase       			= PRETRAINED_INIT_CONFIGURATION
    lowercase       			= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowercase       			= LxmertTokenizer

    def __init__(       self   :  Dict   ,						lowerCamelCase   :  Tuple=None   ,						lowerCamelCase   :  List[str]=None   ,						lowerCamelCase   :  Dict=True   ,						lowerCamelCase   :  List[Any]="[UNK]"   ,						lowerCamelCase   :  Tuple="[SEP]"   ,						lowerCamelCase   :  str="[PAD]"   ,						lowerCamelCase   :  Any="[CLS]"   ,						lowerCamelCase   :  str="[MASK]"   ,						lowerCamelCase   :  Dict=True   ,						lowerCamelCase   :  Union[str, Any]=None   ,						**lowerCamelCase   :  Optional[int]   ,						)       ->  Optional[Any]:
      super().__init__(
          lowerCamelCase   ,						tokenizer_file=lowerCamelCase   ,						do_lower_case=lowerCamelCase   ,						unk_token=lowerCamelCase   ,						sep_token=lowerCamelCase   ,						pad_token=lowerCamelCase   ,						cls_token=lowerCamelCase   ,						mask_token=lowerCamelCase   ,						tokenize_chinese_chars=lowerCamelCase   ,						strip_accents=lowerCamelCase   ,						**lowerCamelCase   ,						)

      lowerCAmelCase_      :				Optional[Any]      =       json.loads(self.backend_tokenizer.normalizer.__getstate__()		)
      if (
          normalizer_state.get("""lowercase"""   ,						lowerCamelCase		) != do_lower_case
          or normalizer_state.get("""strip_accents"""   ,						lowerCamelCase		) != strip_accents
          or normalizer_state.get("""handle_chinese_chars"""   ,						lowerCamelCase		) != tokenize_chinese_chars
      ):
        lowerCAmelCase_      :				Tuple      =       getattr(lowerCamelCase   ,						normalizer_state.pop("""type"""		)		)
        lowerCAmelCase_      :				Optional[Any]      =       do_lower_case
        lowerCAmelCase_      :				Dict      =       strip_accents
        lowerCAmelCase_      :				List[Any]      =       tokenize_chinese_chars
        lowerCAmelCase_      :				List[Any]      =       normalizer_class(**lowerCamelCase		)

      lowerCAmelCase_      :				Tuple      =       do_lower_case

    def __lowercase       (       self   :  Tuple   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  Optional[Any]=None		)       ->  int:
      lowerCAmelCase_      :				Any      =       [self.cls_token_id] + token_ids_a + [self.sep_token_id]

      if token_ids_a:
        output += token_ids_a + [self.sep_token_id]

      return output

    def __lowercase       (       self   :  str   ,						lowerCamelCase   :  List[int]   ,						lowerCamelCase   :  Optional[List[int]] = None		)       ->  List[int]:
      lowerCAmelCase_      :				str      =       [self.sep_token_id]
      lowerCAmelCase_      :				Optional[int]      =       [self.cls_token_id]
      if token_ids_a is None:
        return len(cls + token_ids_a + sep		) * [0]
      return len(cls + token_ids_a + sep		) * [0] + len(token_ids_a + sep		) * [1]





    def __lowercase       (       self   :  Tuple   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  Optional[str] = None		)       ->  Tuple[str]:
      lowerCAmelCase_      :				int      =       self._tokenizer.model.save(lowerCamelCase   ,						name=lowerCamelCase		)
      return tuple(lowerCamelCase		)



