

"""simple docstring"""



import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin



class     a  (				lowerCamelCase__,		unittest.TestCase ):



    """simple docstring"""



    UpperCAmelCase         =    DebertaTokenizer
    UpperCAmelCase         =    True
    UpperCAmelCase         =    DebertaTokenizerFast

    def  UpperCamelCase		(   self:       List[str]				):






         """simple docstring"""


         super().setUp()

         # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
         A__								=     [
             """l""",
             """o""",
             """w""",
             """e""",
             """r""",
             """s""",
             """t""",
             """i""",
             """d""",
             """n""",
             """\u0120""",
             """\u0120l""",
             """\u0120n""",
             """\u0120lo""",
             """\u0120low""",
             """er""",
             """\u0120lowest""",
             """\u0120newer""",
             """\u0120wider""",
             """[UNK]""",
         ]
         A__								=     dict(zip(lowercase__			,  range(len(lowercase__				)				)				)				)
         A__								=     ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
         A__								=     {"""unk_token""": """[UNK]"""}

         A__								=     os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["""vocab_file"""]				)
         A__								=     os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["""merges_file"""]				)
         with open(self.vocab_file			,  """w"""			,  encoding="""utf-8"""				) as fp:
              fp.write(json.dumps(lowercase__				) + """\n"""				)
         with open(self.merges_file			,  """w"""			,  encoding="""utf-8"""				) as fp:
              fp.write("""\n""".join(lowercase__				)				)

    def  UpperCamelCase		(   self:       int			,  **UpperCamelCase:       Any				):






         """simple docstring"""


         kwargs.update(self.special_tokens_map				)
         return self.tokenizer_class.from_pretrained(self.tmpdirname			,  **lowercase__				)

    def  UpperCamelCase		(   self:       Union[str, Any]			,  UpperCamelCase:       int				):






         """simple docstring"""


         A__								=     """lower newer"""
         A__								=     """lower newer"""
         return input_text, output_text

    def  UpperCamelCase		(   self:       List[str]				):






         """simple docstring"""


         A__								=     self.get_tokenizer()
         A__								=     """lower newer"""
         A__								=     ["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
         A__								=     tokenizer.tokenize(lowercase__				)
         self.assertListEqual(lowercase__			,  lowercase__				)

         A__								=     tokens + [tokenizer.unk_token]
         A__								=     [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase__				)			,  lowercase__				)

    def  UpperCamelCase		(   self:       str				):






         """simple docstring"""


         A__								=     self.get_tokenizer()
         A__								=     tokenizer("""Hello"""			,  """World"""				)
         A__								=     [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
         self.assertListEqual(tokd["""token_type_ids"""]			,  lowercase__				)

    @slow
    def  UpperCamelCase		(   self:       Any				):






         """simple docstring"""


         A__								=     self.tokenizer_class.from_pretrained("""microsoft/deberta-base"""				)

         A__								=     tokenizer.encode("""sequence builders"""			,  add_special_tokens=lowercase__				)
         A__								=     tokenizer.encode("""multi-sequence build"""			,  add_special_tokens=lowercase__				)

         A__								=     tokenizer.encode(
             """sequence builders"""			,  add_special_tokens=lowercase__			,  add_prefix_space=lowercase__				)
         A__								=     tokenizer.encode(
             """sequence builders"""			,  """multi-sequence build"""			,  add_special_tokens=lowercase__			,  add_prefix_space=lowercase__				)

         A__								=     tokenizer.build_inputs_with_special_tokens(lowercase__				)
         A__								=     tokenizer.build_inputs_with_special_tokens(lowercase__			,  lowercase__				)

         assert encoded_sentence == encoded_text_from_decode
         assert encoded_pair == encoded_pair_from_decode





    @slow
    def  UpperCamelCase		(   self:       Optional[Any]				):






         """simple docstring"""


         A__								=     [self.tokenizer_class]
         if self.test_rust_tokenizer:
              tokenizer_classes.append(self.rust_tokenizer_class				)

         for tokenizer_class in tokenizer_classes:
              A__								=     tokenizer_class.from_pretrained("""microsoft/deberta-base"""				)

              A__								=     [
                  """ALBERT: A Lite BERT for Self-supervised Learning of Language Representations""",
                  """ALBERT incorporates two parameter reduction techniques""",
                  """The first one is a factorized embedding parameterization. By decomposing the large vocabulary"""
                  """ embedding matrix into two small matrices, we separate the size of the hidden layers from the size of"""
                  """ vocabulary embedding.""",
              ]

              A__								=     tokenizer(lowercase__			,  padding=lowercase__				)
              A__								=     [tokenizer.decode(lowercase__			,  skip_special_tokens=lowercase__				) for seq in encoding["""input_ids"""]]

              # fmt: off
              A__								=     {
                  """input_ids""": [
                      [1, 21_18, 1_11_26, 5_65, 35, 83, 2_51_91, 1_63, 1_88_54, 13, 1_21_56, 12, 1_61_01, 2_53_76, 1_38_07, 9, 2_22_05, 2_78_93, 16_35, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [1, 21_18, 1_11_26, 5_65, 2_45_36, 80, 4_37_97, 48_78, 73_73, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [1, 1_33, 78, 65, 16, 10, 37_24, 15_38, 3_31_83, 1_13_03, 4_37_97, 19_38, 4, 8_70, 2_41_65, 2_91_05, 5, 7_39, 3_26_44, 3_31_83, 1_13_03, 3_61_73, 88, 80, 6_50, 78_21, 4_59_40, 6, 52, 25_59, 5, 18_36, 9, 5, 73_97, 1_31_71, 31, 5, 18_36, 9, 3_26_44, 3_31_83, 1_13_03, 4, 2]
                  ],
                  """token_type_ids""": [
                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                  ],
                  """attention_mask""": [
                      [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                      [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
                  ]
              }
              # fmt: on

              A__								=     [
                  """ALBERT: A Lite BERT for Self-supervised Learning of Language Representations""",
                  """ALBERT incorporates two parameter reduction techniques""",
                  """The first one is a factorized embedding parameterization. By decomposing the large vocabulary"""
                  """ embedding matrix into two small matrices, we separate the size of the hidden layers from the size of"""
                  """ vocabulary embedding.""",
              ]

              self.assertDictEqual(encoding.data			,  lowercase__				)

              for expected, decoded in zip(lowercase__			,  lowercase__				):
                   self.assertEqual(lowercase__			,  lowercase__				)









'''simple docstring'''






import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

lowerCAmelCase__											=	logging.getLogger()


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = argparse.ArgumentParser()
 parser.add_argument('''-f'''      )
 __lowercase							  = parser.parse_args()
 return args.f


def 		_A     (    A__      ):






 """simple docstring"""



 __lowercase							  = {}
 __lowercase							  = os.path.join(A__     ,				'''all_results.json'''      )
 if os.path.exists(A__      ):
  with open(A__     ,				'''r'''      ) as f:
   __lowercase							  = json.load(A__      )
 else:
  raise ValueError(F"can't find {path}"      )
 return results


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = torch.cuda.is_available() and torch_device == '''cuda'''
 return is_using_cuda and is_apex_available()


lowerCAmelCase__											=	logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)






class 			lowercase_	(lowerCamelCase__      ):




  """simple docstring"""




  @classmethod
  def 					SCREAMING_SNAKE_CASE      (      cls   :     List[str]			):
   # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
   __lowercase							  = tempfile.mkdtemp()
   __lowercase							  = os.path.join(cls.tmpdir					,'''default_config.yml'''			)
   write_basic_config(save_location=cls.configPath			)
   __lowercase							  = ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]






  @classmethod
  def 					SCREAMING_SNAKE_CASE      (      cls   :     str			):
   shutil.rmtree(cls.tmpdir			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Any			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   if is_cuda_and_apex_available():
    testargs.append('''--fp16'''			)

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_accuracy''']					,0.7_5			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''glue_no_trainer'''			)			)			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[int]			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   if torch.cuda.device_count() > 1:
    # Skipping because there are not enough batches to train the model + would need a drop_last to work.
    return

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertLess(result['''perplexity''']					,1_0_0			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''clm_no_trainer'''			)			)			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[int]			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertLess(result['''perplexity''']					,4_2			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''mlm_no_trainer'''			)			)			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
   __lowercase							  = 7 if get_gpu_count() > 1 else 2

   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_accuracy''']					,0.7_5			)
   self.assertLess(result['''train_loss''']					,0.5			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''ner_no_trainer'''			)			)			)






  @unittest.skip(reason='''Fix me @muellerzr'''			)
  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
   self.assertGreaterEqual(result['''eval_f1''']					,2_8			)
   self.assertGreaterEqual(result['''eval_exact''']					,2_8			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''qa_no_trainer'''			)			)			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_accuracy''']					,0.8			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''swag_no_trainer'''			)			)			)






  @slow
  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_rouge1''']					,1_0			)
   self.assertGreaterEqual(result['''eval_rouge2''']					,2			)
   self.assertGreaterEqual(result['''eval_rougeL''']					,7			)
   self.assertGreaterEqual(result['''eval_rougeLsum''']					,7			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''summarization_no_trainer'''			)			)			)






  @slow
  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_bleu''']					,3_0			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''epoch_0'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''translation_no_trainer'''			)			)			)






  @slow
  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   __lowercase							  = logging.StreamHandler(sys.stdout			)
   logger.addHandler(lowercase__			)

   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        ".split()

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   self.assertGreaterEqual(result['''eval_overall_accuracy''']					,0.1_0			)






  @mock.patch.dict(os.environ					,{'''WANDB_MODE''': '''offline'''}			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   __lowercase							  = self.get_auto_remove_tmp_dir()
   __lowercase							  = F"\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        ".split()

   if is_cuda_and_apex_available():
    testargs.append('''--fp16'''			)

   run_command(self._launch_args + testargs			)
   __lowercase							  = get_results(lowercase__			)
   # The base model scores a 25%
   self.assertGreaterEqual(result['''eval_accuracy''']					,0.6			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''step_1'''			)			)			)
   self.assertTrue(os.path.exists(os.path.join(lowercase__					,'''image_classification_no_trainer'''			)			)			)

