





import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        BioGptForCausalLM,
        BioGptForSequenceClassification,
        BioGptForTokenClassification,
        BioGptModel,
        BioGptTokenizer,
    )
    from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST





class  A__    :




   """simple docstring"""



   def __init__(					self					,  lowercase					,  lowercase=13					,  lowercase=7					,  lowercase=True					,  lowercase=True					,  lowercase=False					,  lowercase=True					,  lowercase=99					,  lowercase=32					,  lowercase=5					,  lowercase=4					,  lowercase=37					,  lowercase="gelu"					,  lowercase=0.1					,  lowercase=0.1					,  lowercase=512					,  lowercase=16					,  lowercase=2					,  lowercase=0.02					,  lowercase=3					,  lowercase=4					,  lowercase=None					,  )			->						Optional[int]:







          '''simple docstring'''

          a__						:	Union[str, Any] =				parent
          a__						:	List[Any] =				batch_size
          a__						:	Tuple =				seq_length
          a__						:	Any =				is_training
          a__						:	str =				use_input_mask
          a__						:	Dict =				use_token_type_ids
          a__						:	List[Any] =				use_labels
          a__						:	int =				vocab_size
          a__						:	Union[str, Any] =				hidden_size
          a__						:	Dict =				num_hidden_layers
          a__						:	Optional[int] =				num_attention_heads
          a__						:	str =				intermediate_size
          a__						:	str =				hidden_act
          a__						:	int =				hidden_dropout_prob
          a__						:	Union[str, Any] =				attention_probs_dropout_prob
          a__						:	Optional[int] =				max_position_embeddings
          a__						:	Tuple =				type_vocab_size
          a__						:	Dict =				type_sequence_label_size
          a__						:	List[str] =				initializer_range
          a__						:	Dict =				num_labels
          a__						:	int =				num_choices
          a__						:	str =				scope

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	Union[str, Any] =				ids_tensor([self.batch_size, self.seq_length]					,  self.vocab_size)

          a__						:	List[Any] =				None
          if self.use_input_mask:
                 a__						:	Union[str, Any] =				random_attention_mask([self.batch_size, self.seq_length])

          a__						:	Any =				None
          if self.use_token_type_ids:
                 a__						:	Dict =				ids_tensor([self.batch_size, self.seq_length]					,  self.type_vocab_size)

          a__						:	str =				None
          a__						:	int =				None
          a__						:	Union[str, Any] =				None
          if self.use_labels:
                 a__						:	Dict =				ids_tensor([self.batch_size]					,  self.type_sequence_label_size)
                 a__						:	str =				ids_tensor([self.batch_size, self.seq_length]					,  self.num_labels)
                 a__						:	List[str] =				ids_tensor([self.batch_size]					,  self.num_choices)

          a__						:	Dict =				self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

   def 							__lowercase		(					self)			->						Tuple:







          '''simple docstring'''

          return BioGptConfig(
              vocab_size=self.vocab_size					,  hidden_size=self.hidden_size					,  num_hidden_layers=self.num_hidden_layers					,  num_attention_heads=self.num_attention_heads					,  intermediate_size=self.intermediate_size					,  hidden_act=self.hidden_act					,  hidden_dropout_prob=self.hidden_dropout_prob					,  attention_probs_dropout_prob=self.attention_probs_dropout_prob					,  max_position_embeddings=self.max_position_embeddings					,  type_vocab_size=self.type_vocab_size					,  is_decoder=lowercase					,  initializer_range=self.initializer_range					,  )

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase)			->						Optional[Any]:







          '''simple docstring'''

          a__						:	Dict =				BioGptModel(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	Dict =				model(lowercase					,  attention_mask=lowercase)
          a__						:	Optional[int] =				model(lowercase)
          self.parent.assertEqual(result.last_hidden_state.shape					,  (self.batch_size, self.seq_length, self.hidden_size))

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  )			->						Union[str, Any]:







          '''simple docstring'''

          a__						:	List[str] =				BioGptForCausalLM(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	int =				model(lowercase					,  attention_mask=lowercase					,  token_type_ids=lowercase					,  labels=lowercase)
          self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.vocab_size))

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  *lowercase)			->						Optional[Any]:







          '''simple docstring'''

          a__						:	List[Any] =				BioGptModel(config=lowercase)
          model.to(lowercase)
          model.eval()

          # create attention mask
          a__						:	int =				torch.ones(input_ids.shape					,  dtype=torch.long					,  device=lowercase)
          a__						:	List[str] =				self.seq_length // 2
          a__						:	Tuple =				0

          # first forward pass
          a__ ,							a__						:	str =				model(lowercase					,  attention_mask=lowercase).to_tuple()

          # create hypothetical next token and extent to next_input_ids
          a__						:	int =				ids_tensor((self.batch_size, 1)					,  config.vocab_size)

          # change a random masked slice from input_ids
          a__						:	Union[str, Any] =				ids_tensor((1,)					,  lowercase).item() + 1
          a__						:	List[Any] =				ids_tensor((self.batch_size, 1)					,  config.vocab_size).squeeze(-1)
          a__						:	str =				random_other_next_tokens

          # append to next input_ids and attn_mask
          a__						:	Tuple =				torch.cat([input_ids, next_tokens]					,  dim=-1)
          a__						:	int =				torch.cat(
              [attn_mask, torch.ones((attn_mask.shape[0], 1)					,  dtype=torch.long					,  device=lowercase)]					,  dim=1					,  )

          # get two different outputs
          a__						:	Any =				model(lowercase					,  attention_mask=lowercase)['last_hidden_state']
          a__						:	Optional[Any] =				model(lowercase					,  past_key_values=lowercase					,  attention_mask=lowercase)['last_hidden_state']

          # select random slice
          a__						:	Optional[int] =				ids_tensor((1,)					,  output_from_past.shape[-1]).item()
          a__						:	str =				output_from_no_past[:, -1, random_slice_idx].detach()
          a__						:	List[Any] =				output_from_past[:, 0, random_slice_idx].detach()

          # test that outputs are equal for slice
          self.parent.assertTrue(torch.allclose(lowercase					,  lowercase					,  atol=1e-3))

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  *lowercase)			->						Any:







          '''simple docstring'''

          a__						:	Union[str, Any] =				BioGptModel(config=lowercase).to(lowercase).eval()

          a__						:	List[Any] =				torch.ones(input_ids.shape					,  dtype=torch.long					,  device=lowercase)

          # first forward pass
          a__						:	List[str] =				model(lowercase					,  attention_mask=lowercase					,  use_cache=lowercase)

          a__ ,							a__						:	Any =				outputs.to_tuple()

          # create hypothetical multiple next token and extent to next_input_ids
          a__						:	Optional[Any] =				ids_tensor((self.batch_size, 3)					,  config.vocab_size)
          a__						:	Tuple =				ids_tensor((self.batch_size, 3)					,  2)

          # append to next input_ids and
          a__						:	str =				torch.cat([input_ids, next_tokens]					,  dim=-1)
          a__						:	str =				torch.cat([attention_mask, next_attn_mask]					,  dim=-1)

          a__						:	str =				model(lowercase					,  attention_mask=lowercase)['last_hidden_state']
          a__						:	List[Any] =				model(lowercase					,  attention_mask=lowercase					,  past_key_values=lowercase)[
              'last_hidden_state'
          ]

          # select random slice
          a__						:	Union[str, Any] =				ids_tensor((1,)					,  output_from_past.shape[-1]).item()
          a__						:	Any =				output_from_no_past[:, -3:, random_slice_idx].detach()
          a__						:	Dict =				output_from_past[:, :, random_slice_idx].detach()

          self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

          # test that outputs are equal for slice
          self.parent.assertTrue(torch.allclose(lowercase					,  lowercase					,  atol=1e-3))

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  *lowercase					,  lowercase=False)			->						Optional[Any]:







          '''simple docstring'''

          a__						:	List[Any] =				BioGptForCausalLM(lowercase)
          model.to(lowercase)
          if gradient_checkpointing:
                 model.gradient_checkpointing_enable()

          a__						:	List[str] =				model(lowercase					,  labels=lowercase)
          self.parent.assertEqual(result.loss.shape					,  ())
          self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.vocab_size))
          result.loss.backward()

   def 							__lowercase		(					self					,  lowercase					,  *lowercase)			->						Dict:







          '''simple docstring'''

          a__						:	Tuple =				BioGptModel(lowercase)
          a__						:	int =				model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers)
          for key in model.state_dict().keys():
                 if "c_proj" in key and "weight" in key:
                        self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]) - model_std)					,  0.0_01)
                        self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]) - 0.0)					,  0.01)

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  lowercase					,  *lowercase)			->						Union[str, Any]:







          '''simple docstring'''

          a__						:	Dict =				self.num_labels
          a__						:	int =				BioGptForTokenClassification(lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	int =				model(lowercase					,  attention_mask=lowercase					,  token_type_ids=lowercase)
          self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.num_labels))

   def 							__lowercase		(					self)			->						Union[str, Any]:







          '''simple docstring'''

          a__						:	Any =				self.prepare_config_and_inputs()
          (
              (
              a__
          ) ,							(
              a__
          ) ,							(
              a__
          ) ,							(
              a__
          ) ,							(
              a__
          ) ,							(
              a__
          ) ,							(
              a__
          ) ,							
          )						:	str =				config_and_inputs
          a__						:	Dict =				{'input_ids': input_ids, 'attention_mask': input_mask}
          return config, inputs_dict





@require_torch
class  A__    (							__UpperCAmelCase ,  __UpperCAmelCase ,  __UpperCAmelCase ,  unittest.TestCase	):




   """simple docstring"""



   __A   :				Any         =  (
       (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
       if is_torch_available()
       else ()
   )
   __A   :				str         =  (BioGptForCausalLM,) if is_torch_available() else ()
   __A   :				Optional[int]         =  (
       {
           '''feature-extraction''': BioGptModel,
           '''text-classification''': BioGptForSequenceClassification,
           '''text-generation''': BioGptForCausalLM,
           '''token-classification''': BioGptForTokenClassification,
           '''zero-shot''': BioGptForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   __A   :				Optional[Any]         =  False

   def 							__lowercase		(					self)			->						Optional[int]:







          '''simple docstring'''

          a__						:	Tuple =				BioGptModelTester(self)
          a__						:	Optional[int] =				ConfigTester(self					,  config_class=lowercase					,  hidden_size=37)

   def 							__lowercase		(					self)			->						Union[str, Any]:







          '''simple docstring'''

          self.config_tester.run_common_tests()

   def 							__lowercase		(					self)			->						str:







          '''simple docstring'''

          a__						:	Any =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase)

   def 							__lowercase		(					self)			->						Optional[Any]:







          '''simple docstring'''

          a__						:	Any =				self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                 a__						:	Dict =				type
                 self.model_tester.create_and_check_model(*lowercase)

   def 							__lowercase		(					self)			->						List[Any]:







          '''simple docstring'''

          a__						:	Optional[int] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_biogpt_model_attention_mask_past(*lowercase)

   def 							__lowercase		(					self)			->						List[Any]:







          '''simple docstring'''

          a__						:	Optional[int] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_forward_and_backwards(*lowercase					,  gradient_checkpointing=lowercase)

   def 							__lowercase		(					self)			->						Optional[int]:







          '''simple docstring'''

          a__						:	List[Any] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_biogpt_model_past_large_inputs(*lowercase)

   def 							__lowercase		(					self)			->						Tuple:







          '''simple docstring'''

          a__						:	Optional[Any] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_biogpt_weight_initialization(*lowercase)

   def 							__lowercase		(					self)			->						List[Any]:







          '''simple docstring'''

          a__						:	Optional[int] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_biogpt_for_token_classification(*lowercase)

   @slow
   def 							__lowercase		(					self)			->						Optional[Any]:







          '''simple docstring'''

          a__						:	Any =				BioGptForCausalLM.from_pretrained('microsoft/biogpt')
          model.to(lowercase)
          a__						:	Dict =				BioGptTokenizer.from_pretrained('microsoft/biogpt')

          a__						:	str =				'left'

          # Define PAD Token = EOS Token = 50256
          a__						:	Optional[Any] =				tokenizer.eos_token
          a__						:	Optional[int] =				model.config.eos_token_id

          # use different length sentences to test batching
          a__						:	Optional[Any] =				[
              'Hello, my dog is a little',
              'Today, I',
          ]

          a__						:	List[str] =				tokenizer(lowercase					,  return_tensors='pt'					,  padding=lowercase)
          a__						:	Optional[Any] =				inputs['input_ids'].to(lowercase)

          a__						:	Dict =				model.generate(
              input_ids=lowercase					,  attention_mask=inputs['attention_mask'].to(lowercase)					,  )

          a__						:	Any =				tokenizer(sentences[0]					,  return_tensors='pt').input_ids.to(lowercase)
          a__						:	Union[str, Any] =				model.generate(input_ids=lowercase)

          a__						:	Dict =				inputs_non_padded.shape[-1] - inputs['attention_mask'][-1].long().sum().cpu().item()
          a__						:	Union[str, Any] =				tokenizer(sentences[1]					,  return_tensors='pt').input_ids.to(lowercase)
          a__						:	Tuple =				model.generate(input_ids=lowercase					,  max_length=model.config.max_length - num_paddings)

          a__						:	List[Any] =				tokenizer.batch_decode(lowercase					,  skip_special_tokens=lowercase)
          a__						:	Union[str, Any] =				tokenizer.decode(output_non_padded[0]					,  skip_special_tokens=lowercase)
          a__						:	Tuple =				tokenizer.decode(output_padded[0]					,  skip_special_tokens=lowercase)

          a__						:	Dict =				[
              'Hello, my dog is a little bit bigger than a little bit.',
              'Today, I have a good idea of how to use the information',
          ]
          self.assertListEqual(lowercase					,  lowercase)
          self.assertListEqual(lowercase					,  [non_padded_sentence, padded_sentence])

   @slow
   def 							__lowercase		(					self)			->						Optional[int]:







          '''simple docstring'''

          for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 a__						:	Any =				BioGptModel.from_pretrained(lowercase)
                 self.assertIsNotNone(lowercase)

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__ ,							a__						:	Union[str, Any] =				self.model_tester.prepare_config_and_inputs_for_common()
          a__						:	int =				3
          a__						:	List[str] =				input_dict['input_ids']
          a__						:	Any =				input_ids.ne(1).to(lowercase)
          a__						:	Tuple =				ids_tensor([self.model_tester.batch_size]					,  self.model_tester.type_sequence_label_size)
          a__						:	List[str] =				BioGptForSequenceClassification(lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	int =				model(lowercase					,  attention_mask=lowercase					,  labels=lowercase)
          self.assertEqual(result.logits.shape					,  (self.model_tester.batch_size, self.model_tester.num_labels))

   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          a__ ,							a__						:	str =				self.model_tester.prepare_config_and_inputs_for_common()
          a__						:	List[Any] =				3
          a__						:	Union[str, Any] =				'multi_label_classification'
          a__						:	Dict =				input_dict['input_ids']
          a__						:	Union[str, Any] =				input_ids.ne(1).to(lowercase)
          a__						:	Any =				ids_tensor(
              [self.model_tester.batch_size, config.num_labels]					,  self.model_tester.type_sequence_label_size).to(torch.float)
          a__						:	Union[str, Any] =				BioGptForSequenceClassification(lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	List[Any] =				model(lowercase					,  attention_mask=lowercase					,  labels=lowercase)
          self.assertEqual(result.logits.shape					,  (self.model_tester.batch_size, self.model_tester.num_labels))





@require_torch
class  A__    (							unittest.TestCase	):




   """simple docstring"""



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







          '''simple docstring'''

          a__						:	str =				BioGptForCausalLM.from_pretrained('microsoft/biogpt')
          a__						:	Union[str, Any] =				torch.tensor([[2, 4805, 9, 656, 21]])
          a__						:	Union[str, Any] =				model(lowercase)[0]

          a__						:	Optional[Any] =				4_2384

          a__						:	int =				torch.Size((1, 5, vocab_size))
          self.assertEqual(output.shape					,  lowercase)

          a__						:	str =				torch.tensor(
              [[[-9.52_36, -9.89_18, 10.45_57], [-11.04_69, -9.64_23, 8.10_22], [-8.86_64, -7.88_26, 5.53_25]]])

          self.assertTrue(torch.allclose(output[:, :3, :3]					,  lowercase					,  atol=1e-4))

   @slow
   def 							__lowercase		(					self)			->						int:







          '''simple docstring'''

          a__						:	Optional[Any] =				BioGptTokenizer.from_pretrained('microsoft/biogpt')
          a__						:	List[str] =				BioGptForCausalLM.from_pretrained('microsoft/biogpt')
          model.to(lowercase)

          torch.manual_seed(0)
          a__						:	Optional[Any] =				tokenizer('COVID-19 is'					,  return_tensors='pt').to(lowercase)
          a__						:	List[str] =				model.generate(
              **lowercase					,  min_length=100					,  max_length=1024					,  num_beams=5					,  early_stopping=lowercase					,  )
          a__						:	Tuple =				tokenizer.decode(output_ids[0]					,  skip_special_tokens=lowercase)

          a__						:	int =				(
              'COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the'
              ' causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and'
              ' territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),'
              ' and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and'
              ' more than 800,000 deaths.'
          )
          self.assertEqual(lowercase					,  lowercase)









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

lowercase      :       List[str]									=  logging.get_logger(__name__)

lowercase      :       Any									=  {
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
lowercase      :       List[str]									=  [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_7, 3_6_6, 4_3_8, 5_3_2, 6_8_5,
    7_0_5, 7_9_6, 9_3_0, 1_0_5_8, 1_2_2_0, 1_2_6_7, 1_2_7_9, 1_3_0_3, 1_3_4_3, 1_3_7_7,
    1_3_9_1, 1_6_3_5, 1_7_8_2, 1_8_7_5, 2_1_6_2, 2_3_6_1, 2_4_8_8, 3_4_6_7, 4_0_0_8, 4_2_1_1,
    4_6_0_0, 4_8_0_8, 5_2_9_9, 5_8_5_5, 6_3_2_9, 7_2_0_3, 9_6_0_9, 9_9_5_9, 1_0_5_6_3, 1_0_7_8_6,
    1_1_4_2_0, 1_1_7_0_9, 1_1_9_0_7, 1_3_1_6_3, 1_3_6_9_7, 1_3_7_0_0, 1_4_8_0_8, 1_5_3_0_6, 1_6_4_1_0, 1_6_7_9_1,
    1_7_9_9_2, 1_9_2_0_3, 1_9_5_1_0, 2_0_7_2_4, 2_2_3_0_5, 2_2_9_3_5, 2_7_0_0_7, 3_0_1_0_9, 3_0_4_2_0, 3_3_4_0_9,
    3_4_9_4_9, 4_0_2_8_3, 4_0_4_9_3, 4_0_5_4_9, 4_7_2_8_2, 4_9_1_4_6, 5_0_2_5_7, 5_0_3_5_9, 5_0_3_6_0, 5_0_3_6_1
]
lowercase      :       List[Any]									=  [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_9, 5_0_3, 5_2_2, 5_4_2, 8_7_3,
    8_9_3, 9_0_2, 9_1_8, 9_2_2, 9_3_1, 1_3_5_0, 1_8_5_3, 1_9_8_2, 2_4_6_0, 2_6_2_7,
    3_2_4_6, 3_2_5_3, 3_2_6_8, 3_5_3_6, 3_8_4_6, 3_9_6_1, 4_1_8_3, 4_6_6_7, 6_5_8_5, 6_6_4_7,
    7_2_7_3, 9_0_6_1, 9_3_8_3, 1_0_4_2_8, 1_0_9_2_9, 1_1_9_3_8, 1_2_0_3_3, 1_2_3_3_1, 1_2_5_6_2, 1_3_7_9_3,
    1_4_1_5_7, 1_4_6_3_5, 1_5_2_6_5, 1_5_6_1_8, 1_6_5_5_3, 1_6_6_0_4, 1_8_3_6_2, 1_8_9_5_6, 2_0_0_7_5, 2_1_6_7_5,
    2_2_5_2_0, 2_6_1_3_0, 2_6_1_6_1, 2_6_4_3_5, 2_8_2_7_9, 2_9_4_6_4, 3_1_6_5_0, 3_2_3_0_2, 3_2_4_7_0, 3_6_8_6_5,
    4_2_8_6_3, 4_7_4_2_5, 4_9_8_7_0, 5_0_2_5_4, 5_0_2_5_8, 5_0_3_6_0, 5_0_3_6_1, 5_0_3_6_2
]





class  A__    (							__UpperCAmelCase	):




   """simple docstring"""



   __A   :				int         =  '''whisper'''
   __A   :				List[Any]         =  ['''past_key_values''']
   __A   :				Optional[int]         =  {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}

   def __init__(					self					,  lowercase=5_1865					,  lowercase=80					,  lowercase=6					,  lowercase=4					,  lowercase=6					,  lowercase=4					,  lowercase=1536					,  lowercase=1536					,  lowercase=0.0					,  lowercase=0.0					,  lowercase=5_0257					,  lowercase=True					,  lowercase=True					,  lowercase="gelu"					,  lowercase=256					,  lowercase=0.0					,  lowercase=0.0					,  lowercase=0.0					,  lowercase=0.02					,  lowercase=False					,  lowercase=1500					,  lowercase=448					,  lowercase=5_0256					,  lowercase=5_0256					,  lowercase=5_0256					,  lowercase=None					,  lowercase=[220, 5_0256]					,  lowercase=False					,  lowercase=256					,  lowercase=False					,  lowercase=0.05					,  lowercase=10					,  lowercase=2					,  lowercase=0.0					,  lowercase=10					,  lowercase=0					,  lowercase=7					,  **lowercase					,  )			->						str:







          '''simple docstring'''

          a__						:	int =				vocab_size
          a__						:	int =				num_mel_bins
          a__						:	Optional[int] =				d_model
          a__						:	List[str] =				encoder_layers
          a__						:	Dict =				encoder_attention_heads
          a__						:	List[str] =				decoder_layers
          a__						:	Tuple =				decoder_attention_heads
          a__						:	List[str] =				decoder_ffn_dim
          a__						:	Optional[Any] =				encoder_ffn_dim
          a__						:	Tuple =				dropout
          a__						:	Optional[int] =				attention_dropout
          a__						:	Any =				activation_dropout
          a__						:	Any =				activation_function
          a__						:	List[Any] =				init_std
          a__						:	Optional[int] =				encoder_layerdrop
          a__						:	Union[str, Any] =				decoder_layerdrop
          a__						:	Tuple =				use_cache
          a__						:	List[str] =				encoder_layers
          a__						:	Dict =				scale_embedding  # scale factor will be sqrt(d_model) if True
          a__						:	Dict =				max_source_positions
          a__						:	Dict =				max_target_positions

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

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

          a__						:	Tuple =				median_filter_width

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





class  A__    (							__UpperCAmelCase	):




   """simple docstring"""



   @property
   def 							__lowercase		(					self)			->						Mapping[str, Mapping[int, str]]:







          '''simple docstring'''

          a__						:	List[str] =				OrderedDict(
              [
                  ('input_features', {0: 'batch', 1: 'feature_size', 2: 'encoder_sequence'}),
              ])
          if self.use_past:
                 a__						:	Optional[Any] =				{0: 'batch'}
          else:
                 a__						:	Optional[Any] =				{0: 'batch', 1: 'decoder_sequence'}

          if self.use_past:
                 self.fill_with_past_key_values_(lowercase					,  direction='inputs')

          return common_inputs

   def 							__lowercase		(					self					,  lowercase					,  lowercase = -1					,  lowercase = -1					,  lowercase = False					,  lowercase = None					,  lowercase = 2_2050					,  lowercase = 5.0					,  lowercase = 220					,  )			->						Mapping[str, Any]:







          '''simple docstring'''

          a__						:	Union[str, Any] =				OrderedDict()
          a__						:	int =				OnnxConfig.generate_dummy_inputs(
              self					,  preprocessor=preprocessor.feature_extractor					,  batch_size=lowercase					,  framework=lowercase					,  sampling_rate=lowercase					,  time_duration=lowercase					,  frequency=lowercase					,  )
          a__						:	List[Any] =				encoder_inputs['input_features'].shape[2]
          a__						:	Optional[int] =				encoder_sequence_length // 2 if self.use_past else seq_length

          a__						:	Any =				super().generate_dummy_inputs(
              preprocessor.tokenizer					,  lowercase					,  lowercase					,  lowercase					,  lowercase)

          a__						:	List[str] =				encoder_inputs.pop('input_features')
          a__						:	Optional[int] =				decoder_inputs.pop('decoder_input_ids')

          if "past_key_values" in decoder_inputs:
                 a__						:	List[str] =				decoder_inputs.pop('past_key_values')

          return dummy_inputs

   @property
   def 							__lowercase		(					self)			->						float:







          '''simple docstring'''

          return 1e-3


