






'''simple docstring'''






import argparse
import json
import logging
import os
import sys
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


__A    	=   [
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        '''text-classification''',
        '''language-modeling''',
        '''summarization''',
        '''token-classification''',
        '''question-answering''',
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
      import run_clm_flax
      import run_flax_glue
      import run_flax_ner
      import run_mlm_flax
      import run_qa
      import run_summarization_flax
      import run_ta_mlm_flax


logging.basicConfig(level=logging.DEBUG)

__A    	=   logging.getLogger()




def        _SCREAMING_SNAKE_CASE  (				)    -> Dict:







   """simple docstring"""
   __snake_case				:      Optional[int]     							= argparse.ArgumentParser()
   parser.add_argument('-f'  )
   __snake_case				:      List[Any]     							= parser.parse_args()
   return args.f




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       Union[str, Any]="eval"  )    -> List[str]:







   """simple docstring"""
   __snake_case				:      int     							= os.path.join(A  ,		F"""{split}_results.json"""  )
   if os.path.exists(A  ):
      with open(A  ,		'r'  ) as f:
         return json.load(A  )
   raise ValueError(F"""can't find {path}"""  )


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





class a_    (    UpperCamelCase_							):







   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      Union[str, Any]     							= F"""
            run_glue.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --eval_steps=2
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_flax_glue.main()
         __snake_case				:      List[Any]     							= get_results(__a)
         self.assertGreaterEqual(result['eval_accuracy']					,   0.75)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      Any     							= F"""
            run_clm_flax.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --block_size 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_clm_flax.main()
         __snake_case				:      Any     							= get_results(__a)
         self.assertLess(result['eval_perplexity']					,   1_0_0)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case				:      int     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      Any     							= F"""
            run_summarization.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --test_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=8
            --do_train
            --do_eval
            --do_predict
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --predict_with_generate
        """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_summarization_flax.main()
         __snake_case				:      Dict     							= get_results(__a					,   split='test')
         self.assertGreaterEqual(result['test_rouge1']					,   1_0)
         self.assertGreaterEqual(result['test_rouge2']					,   2)
         self.assertGreaterEqual(result['test_rougeL']					,   7)
         self.assertGreaterEqual(result['test_rougeLsum']					,   7)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      str:
      """simple docstring"""






      __snake_case				:      str     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      int     							= F"""
            run_mlm.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --logging_steps 2 --eval_steps 2
            --do_train
            --do_eval
            --num_train_epochs=1
        """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_mlm_flax.main()
         __snake_case				:      Optional[Any]     							= get_results(__a)
         self.assertLess(result['eval_perplexity']					,   4_2)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      __snake_case				:      Dict     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      List[Any]     							= F"""
            run_t5_mlm_flax.py
            --model_name_or_path t5-small
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_ta_mlm_flax.main()
         __snake_case				:      List[Any]     							= get_results(__a)
         self.assertGreaterEqual(result['eval_accuracy']					,   0.42)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      __snake_case				:      Tuple     							= 7 if get_gpu_count() > 1 else 2

      __snake_case				:      Any     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      int     							= F"""
            run_flax_ner.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --warmup_steps=2
            --learning_rate=2e-4
            --logging_steps 2 --eval_steps 2
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
        """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_flax_ner.main()
         __snake_case				:      List[Any]     							= get_results(__a)
         self.assertGreaterEqual(result['eval_accuracy']					,   0.75)
         self.assertGreaterEqual(result['eval_f1']					,   0.3)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= self.get_auto_remove_tmp_dir()
      __snake_case				:      Optional[Any]     							= F"""
            run_qa.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=2
            --do_train
            --do_eval
            --logging_steps 2 --eval_steps 2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

      with patch.object(__a					,   'argv'					,   __a):
         run_qa.main()
         __snake_case				:      Tuple     							= get_results(__a)
         self.assertGreaterEqual(result['eval_f1']					,   3_0)
         self.assertGreaterEqual(result['eval_exact']					,   3_0)







'''simple docstring'''






from typing import TYPE_CHECKING

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


__A    	=   {
    '''configuration_distilbert''': [
        '''DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''DistilBertConfig''',
        '''DistilBertOnnxConfig''',
    ],
    '''tokenization_distilbert''': ['''DistilBertTokenizer'''],
}

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

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''DistilBertForMaskedLM''',
          '''DistilBertForMultipleChoice''',
          '''DistilBertForQuestionAnswering''',
          '''DistilBertForSequenceClassification''',
          '''DistilBertForTokenClassification''',
          '''DistilBertModel''',
          '''DistilBertPreTrainedModel''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFDistilBertForMaskedLM''',
          '''TFDistilBertForMultipleChoice''',
          '''TFDistilBertForQuestionAnswering''',
          '''TFDistilBertForSequenceClassification''',
          '''TFDistilBertForTokenClassification''',
          '''TFDistilBertMainLayer''',
          '''TFDistilBertModel''',
          '''TFDistilBertPreTrainedModel''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''FlaxDistilBertForMaskedLM''',
          '''FlaxDistilBertForMultipleChoice''',
          '''FlaxDistilBertForQuestionAnswering''',
          '''FlaxDistilBertForSequenceClassification''',
          '''FlaxDistilBertForTokenClassification''',
          '''FlaxDistilBertModel''',
          '''FlaxDistilBertPreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_distilbert import (
          DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
          DistilBertConfig,
          DistilBertOnnxConfig,
      )
      from .tokenization_distilbert import DistilBertTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_distilbert_fast import DistilBertTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_distilbert import (
                DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                DistilBertForMaskedLM,
                DistilBertForMultipleChoice,
                DistilBertForQuestionAnswering,
                DistilBertForSequenceClassification,
                DistilBertForTokenClassification,
                DistilBertModel,
                DistilBertPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_distilbert import (
                TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFDistilBertForMaskedLM,
                TFDistilBertForMultipleChoice,
                TFDistilBertForQuestionAnswering,
                TFDistilBertForSequenceClassification,
                TFDistilBertForTokenClassification,
                TFDistilBertMainLayer,
                TFDistilBertModel,
                TFDistilBertPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_distilbert import (
                FlaxDistilBertForMaskedLM,
                FlaxDistilBertForMultipleChoice,
                FlaxDistilBertForQuestionAnswering,
                FlaxDistilBertForSequenceClassification,
                FlaxDistilBertForTokenClassification,
                FlaxDistilBertModel,
                FlaxDistilBertPreTrainedModel,
            )

else:
      import sys

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