
"""simple docstring"""






from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
				from ...feature_extraction_utils import FeatureExtractionMixin
				from ...tokenization_utils_base import PreTrainedTokenizerBase
				from ...utils import TensorType

__UpperCAmelCase       =  logging.get_logger(__name__)

__UpperCAmelCase       =  {
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
__UpperCAmelCase       =  [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_57, 3_66, 4_38, 5_32, 6_85,
    7_05, 7_96, 9_30, 10_58, 12_20, 12_67, 12_79, 13_03, 13_43, 13_77,
    13_91, 16_35, 17_82, 18_75, 21_62, 23_61, 24_88, 34_67, 40_08, 42_11,
    46_00, 48_08, 52_99, 58_55, 63_29, 72_03, 96_09, 99_59, 1_05_63, 1_07_86,
    1_14_20, 1_17_09, 1_19_07, 1_31_63, 1_36_97, 1_37_00, 1_48_08, 1_53_06, 1_64_10, 1_67_91,
    1_79_92, 1_92_03, 1_95_10, 2_07_24, 2_23_05, 2_29_35, 2_70_07, 3_01_09, 3_04_20, 3_34_09,
    3_49_49, 4_02_83, 4_04_93, 4_05_49, 4_72_82, 4_91_46, 5_02_57, 5_03_59, 5_03_60, 5_03_61
]
__UpperCAmelCase       =  [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_59, 5_03, 5_22, 5_42, 8_73,
    8_93, 9_02, 9_18, 9_22, 9_31, 13_50, 18_53, 19_82, 24_60, 26_27,
    32_46, 32_53, 32_68, 35_36, 38_46, 39_61, 41_83, 46_67, 65_85, 66_47,
    72_73, 90_61, 93_83, 1_04_28, 1_09_29, 1_19_38, 1_20_33, 1_23_31, 1_25_62, 1_37_93,
    1_41_57, 1_46_35, 1_52_65, 1_56_18, 1_65_53, 1_66_04, 1_83_62, 1_89_56, 2_00_75, 2_16_75,
    2_25_20, 2_61_30, 2_61_61, 2_64_35, 2_82_79, 2_94_64, 3_16_50, 3_23_02, 3_24_70, 3_68_65,
    4_28_63, 4_74_25, 4_98_70, 5_02_54, 5_02_58, 5_03_60, 5_03_61, 5_03_62
]




class 			_SCREAMING_SNAKE_CASE					(			A__							):
			UpperCAmelCase_  :Dict				 =						"whisper"
			UpperCAmelCase_  :Dict				 =						["past_key_values"]
			UpperCAmelCase_  :List[Any]				 =						{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






			def __init__(					self       ,   __A=5_1865       ,   __A=80       ,   __A=6       ,   __A=4       ,   __A=6       ,   __A=4       ,   __A=1536       ,   __A=1536       ,   __A=0.0       ,   __A=0.0       ,   __A=5_0257       ,   __A=True       ,   __A=True       ,   __A="gelu"       ,   __A=256       ,   __A=0.0       ,   __A=0.0       ,   __A=0.0       ,   __A=0.0_2       ,   __A=False       ,   __A=1500       ,   __A=448       ,   __A=5_0256       ,   __A=5_0256       ,   __A=5_0256       ,   __A=None       ,   __A=[220, 5_0256]       ,   __A=False       ,   __A=256       ,   __A=False       ,   __A=0.0_5       ,   __A=10       ,   __A=2       ,   __A=0.0       ,   __A=10       ,   __A=0       ,   __A=7       ,   **__A       ,   )			->     Optional[int]:
						lowerCAmelCase_    :Union[str, Any]			     =  vocab_size
						lowerCAmelCase_    :Dict			     =  num_mel_bins
						lowerCAmelCase_    :Optional[int]			     =  d_model
						lowerCAmelCase_    :int			     =  encoder_layers
						lowerCAmelCase_    :List[Any]			     =  encoder_attention_heads
						lowerCAmelCase_    :str			     =  decoder_layers
						lowerCAmelCase_    :Optional[Any]			     =  decoder_attention_heads
						lowerCAmelCase_    :Any			     =  decoder_ffn_dim
						lowerCAmelCase_    :Union[str, Any]			     =  encoder_ffn_dim
						lowerCAmelCase_    :str			     =  dropout
						lowerCAmelCase_    :Any			     =  attention_dropout
						lowerCAmelCase_    :int			     =  activation_dropout
						lowerCAmelCase_    :Dict			     =  activation_function
						lowerCAmelCase_    :Union[str, Any]			     =  init_std
						lowerCAmelCase_    :Optional[Any]			     =  encoder_layerdrop
						lowerCAmelCase_    :int			     =  decoder_layerdrop
						lowerCAmelCase_    :Dict			     =  use_cache
						lowerCAmelCase_    :Any			     =  encoder_layers
						lowerCAmelCase_    :Dict			     =  scale_embedding  # scale factor will be sqrt(d_model) if True
						lowerCAmelCase_    :Union[str, Any]			     =  max_source_positions
						lowerCAmelCase_    :Tuple			     =  max_target_positions

						# Audio Classification-specific parameters. Feel free to ignore for other classes.
						lowerCAmelCase_    :Optional[Any]			     =  classifier_proj_size
						lowerCAmelCase_    :int			     =  use_weighted_layer_sum

						# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
						lowerCAmelCase_    :Union[str, Any]			     =  apply_spec_augment
						lowerCAmelCase_    :str			     =  mask_time_prob
						lowerCAmelCase_    :Optional[int]			     =  mask_time_length
						lowerCAmelCase_    :int			     =  mask_time_min_masks
						lowerCAmelCase_    :Dict			     =  mask_feature_prob
						lowerCAmelCase_    :int			     =  mask_feature_length
						lowerCAmelCase_    :Any			     =  mask_feature_min_masks

						lowerCAmelCase_    :Dict			     =  median_filter_width

						super().__init__(
						    pad_token_id=__UpperCAmelCase       ,   bos_token_id=__UpperCAmelCase       ,   eos_token_id=__UpperCAmelCase       ,   is_encoder_decoder=__UpperCAmelCase       ,   decoder_start_token_id=__UpperCAmelCase       ,   suppress_tokens=__UpperCAmelCase       ,   begin_suppress_tokens=__UpperCAmelCase       ,   **__UpperCAmelCase       ,   )




class 			_SCREAMING_SNAKE_CASE					(			A__							):






			@property
			def  __lowerCAmelCase (					self       )			->     Mapping[str, Mapping[int, str]]:
						lowerCAmelCase_    :str			     =  OrderedDict(
						    [
						        ("""input_features""", {0: """batch""", 1: """feature_size""", 2: """encoder_sequence"""}),
						    ]       )
						if self.use_past:
									lowerCAmelCase_    :Optional[int]			     =  {0: """batch"""}
						else:
									lowerCAmelCase_    :Union[str, Any]			     =  {0: """batch""", 1: """decoder_sequence"""}

						if self.use_past:
									self.fill_with_past_key_values_(__UpperCAmelCase       ,   direction="""inputs"""       )

						return common_inputs






			def  __lowerCAmelCase (					self       ,   __A       ,   __A = -1       ,   __A = -1       ,   __A = False       ,   __A = None       ,   __A = 2_2050       ,   __A = 5.0       ,   __A = 220       ,   )			->     Mapping[str, Any]:
						lowerCAmelCase_    :Union[str, Any]			     =  OrderedDict()
						lowerCAmelCase_    :Tuple			     =  OnnxConfig.generate_dummy_inputs(
						    self       ,   preprocessor=preprocessor.feature_extractor       ,   batch_size=__UpperCAmelCase       ,   framework=__UpperCAmelCase       ,   sampling_rate=__UpperCAmelCase       ,   time_duration=__UpperCAmelCase       ,   frequency=__UpperCAmelCase       ,   )
						lowerCAmelCase_    :Optional[int]			     =  encoder_inputs["""input_features"""].shape[2]
						lowerCAmelCase_    :Optional[int]			     =  encoder_sequence_length // 2 if self.use_past else seq_length

						lowerCAmelCase_    :Tuple			     =  super().generate_dummy_inputs(
						    preprocessor.tokenizer       ,   __UpperCAmelCase       ,   __UpperCAmelCase       ,   __UpperCAmelCase       ,   __UpperCAmelCase       )

						lowerCAmelCase_    :Dict			     =  encoder_inputs.pop("""input_features"""       )
						lowerCAmelCase_    :int			     =  decoder_inputs.pop("""decoder_input_ids"""       )

						if "past_key_values" in decoder_inputs:
									lowerCAmelCase_    :Optional[int]			     =  decoder_inputs.pop("""past_key_values"""       )

						return dummy_inputs






			@property
			def  __lowerCAmelCase (					self       )			->     float:
						return 1E-3














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)

UpperCAmelCase__				   =		logging.getLogger()
def 						_a    (      )							->			Optional[int]:
 a		  =      argparse.ArgumentParser()
 parser.add_argument('''-f''' )
 a		  =      parser.parse_args()
 return args.f
def 						_a    (      a :Any )							->			Tuple:
 a		  =      {}
 a		  =      os.path.join(a	,							'''all_results.json''' )
 if os.path.exists(a ):
  with open(a	,							'''r''' ) as f:
   a		  =      json.load(a )
 else:
  raise ValueError(F"""can't find {path}""" )
 return results
def 						_a    (      )							->			int:
 a		  =      torch.cuda.is_available() and torch_device == '''cuda'''
 return is_using_cuda and is_apex_available()


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






class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      @classmethod
      def       __lowerCAmelCase					(      cls      :						str  )    ->Tuple:




       """simple docstring"""


       a		  =      tempfile.mkdtemp()
       a		  =      os.path.join(cls.tmpdir ,					'''default_config.yml'''  )
       write_basic_config(save_location=cls.configPath  )
       a		  =      ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[int]  )    ->Union[str, Any]:




       """simple docstring"""


       shutil.rmtree(cls.tmpdir  )







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->List[str]:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.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
            --seed=42
            --checkpointing_steps epoch
            --with_tracking
        """.split()

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

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertGreaterEqual(result['''eval_accuracy'''] ,					0.75  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''glue_no_trainer'''  )  )  )







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Any:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --block_size 128
            --per_device_train_batch_size 5
            --per_device_eval_batch_size 5
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --checkpointing_steps epoch
            --with_tracking
        """.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  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertLess(result['''perplexity'''] ,					100  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''clm_no_trainer'''  )  )  )







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->int:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.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}
            --num_train_epochs=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertLess(result['''perplexity'''] ,					42  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''mlm_no_trainer'''  )  )  )







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->str:




       """simple docstring"""


       a		  =      7 if get_gpu_count() > 1 else 2

       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.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}
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
            --checkpointing_steps epoch
            --with_tracking
        """.split()

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertGreaterEqual(result['''eval_accuracy'''] ,					0.75  )
       self.assertLess(result['''train_loss'''] ,					0.5  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''ner_no_trainer'''  )  )  )







      @unittest.skip(reason='''Fix me @muellerzr'''  )
      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Any  )    ->int:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.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}
            --seed=42
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

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







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Any:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=20
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --with_tracking
        """.split()

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







      @slow
      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->Union[str, Any]:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.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
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertGreaterEqual(result['''eval_rouge1'''] ,					10  )
       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(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''summarization_no_trainer'''  )  )  )







      @slow
      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->List[str]:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py
            --model_name_or_path sshleifer/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --num_beams=6
            --learning_rate=3e-3
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
            --checkpointing_steps epoch
            --with_tracking
        """.split()

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertGreaterEqual(result['''eval_bleu'''] ,					30  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''epoch_0'''  )  )  )
       self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase ,					'''translation_no_trainer'''  )  )  )







      @slow
      def       __lowerCAmelCase					(      self      :						List[str]  )    ->int:




       """simple docstring"""


       a		  =      logging.StreamHandler(sys.stdout  )
       logger.addHandler(__UpperCAmelCase  )

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

       run_command(self._launch_args + testargs  )
       a		  =      get_results(__UpperCAmelCase  )
       self.assertGreaterEqual(result['''eval_overall_accuracy'''] ,					0.10  )







      @mock.patch.dict(os.environ ,					{'''WANDB_MODE''': '''offline'''}  )
      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Tuple:




       """simple docstring"""


       a		  =      self.get_auto_remove_tmp_dir()
       a		  =      F"""
            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py
            --model_name_or_path google/vit-base-patch16-224-in21k
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --max_train_steps 2
            --train_val_split 0.1
            --seed 42
            --output_dir {tmp_dir}
            --with_tracking
            --checkpointing_steps 1
        """.split()

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

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


