

import unittest

from transformers import BertGenerationConfig, 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import BertGenerationDecoder, BertGenerationEncoder





class  __lowerCAmelCase     :




  def __init__(				self							,   lowerCAmelCase							,   lowerCAmelCase=13							,   lowerCAmelCase=7							,   lowerCAmelCase=True							,   lowerCAmelCase=True							,   lowerCAmelCase=99							,   lowerCAmelCase=32							,   lowerCAmelCase=5							,   lowerCAmelCase=4							,   lowerCAmelCase=37							,   lowerCAmelCase="gelu"							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.1							,   lowerCAmelCase=50							,   lowerCAmelCase=0.02							,   lowerCAmelCase=True							,   lowerCAmelCase=None							,   )  -> int:
        '''simple docstring'''






        _lowercase	       =parent
        _lowercase	       =batch_size
        _lowercase	       =seq_length
        _lowercase	       =is_training
        _lowercase	       =use_input_mask
        _lowercase	       =vocab_size
        _lowercase	       =hidden_size
        _lowercase	       =num_hidden_layers
        _lowercase	       =num_attention_heads
        _lowercase	       =intermediate_size
        _lowercase	       =hidden_act
        _lowercase	       =hidden_dropout_prob
        _lowercase	       =attention_probs_dropout_prob
        _lowercase	       =max_position_embeddings
        _lowercase	       =initializer_range
        _lowercase	       =use_labels
        _lowercase	       =scope




  def   A__     (				self					)  -> Optional[Any]:
        '''simple docstring'''






        _lowercase	       =ids_tensor([self.batch_size, self.seq_length]							,   self.vocab_size					)

        _lowercase	       =None
        if self.use_input_mask:
              _lowercase	       =random_attention_mask([self.batch_size, self.seq_length]					)

        if self.use_labels:
              _lowercase	       =ids_tensor([self.batch_size, self.seq_length]							,   self.vocab_size					)

        _lowercase	       =self.get_config()

        return config, input_ids, input_mask, token_labels




  def   A__     (				self					)  -> Tuple:
        '''simple docstring'''






        return BertGenerationConfig(
            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							,   is_decoder=lowerCAmelCase							,   initializer_range=self.initializer_range							,   )




  def   A__     (				self					)  -> Union[str, Any]:
        '''simple docstring'''






        (
            (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,           
        )	       =self.prepare_config_and_inputs()

        _lowercase	       =True
        _lowercase	       =floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
        _lowercase	       =ids_tensor([self.batch_size, self.seq_length]							,   vocab_size=2					)

        return (
            config,
            input_ids,
            input_mask,
            token_labels,
            encoder_hidden_states,
            encoder_attention_mask,
        )




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   **lowerCAmelCase							,   )  -> Union[str, Any]:
        '''simple docstring'''






        _lowercase	       =BertGenerationEncoder(config=lowerCAmelCase					)
        model.to(lowerCAmelCase					)
        model.eval()
        _lowercase	       =model(lowerCAmelCase							,   attention_mask=lowerCAmelCase					)
        _lowercase	       =model(lowerCAmelCase					)
        self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   **lowerCAmelCase							,   )  -> List[Any]:
        '''simple docstring'''






        _lowercase	       =True
        _lowercase	       =BertGenerationEncoder(config=lowerCAmelCase					)
        model.to(lowerCAmelCase					)
        model.eval()
        _lowercase	       =model(
            lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   encoder_hidden_states=lowerCAmelCase							,   encoder_attention_mask=lowerCAmelCase							,   )
        _lowercase	       =model(
            lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   encoder_hidden_states=lowerCAmelCase							,   )
        self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   **lowerCAmelCase							,   )  -> Tuple:
        '''simple docstring'''






        _lowercase	       =True
        _lowercase	       =True
        _lowercase	       =BertGenerationDecoder(config=lowerCAmelCase					).to(lowerCAmelCase					).eval()

        # first forward pass
        _lowercase	       =model(
            lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   encoder_hidden_states=lowerCAmelCase							,   encoder_attention_mask=lowerCAmelCase							,   use_cache=lowerCAmelCase							,   )
        _lowercase	       =outputs.past_key_values

        # create hypothetical multiple next token and extent to next_input_ids
        _lowercase	       =ids_tensor((self.batch_size, 3)							,   config.vocab_size					)
        _lowercase	       =ids_tensor((self.batch_size, 3)							,   vocab_size=2					)

        # append to next input_ids and
        _lowercase	       =torch.cat([input_ids, next_tokens]							,   dim=-1					)
        _lowercase	       =torch.cat([input_mask, next_mask]							,   dim=-1					)

        _lowercase	       =model(
            lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   encoder_hidden_states=lowerCAmelCase							,   encoder_attention_mask=lowerCAmelCase							,   output_hidden_states=lowerCAmelCase							,   )['hidden_states'][0]
        _lowercase	       =model(
            lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   encoder_hidden_states=lowerCAmelCase							,   encoder_attention_mask=lowerCAmelCase							,   past_key_values=lowerCAmelCase							,   output_hidden_states=lowerCAmelCase							,   )['hidden_states'][0]

        # select random slice
        _lowercase	       =ids_tensor((1,)							,   output_from_past.shape[-1]					).item()
        _lowercase	       =output_from_no_past[:, -3:, random_slice_idx].detach()
        _lowercase	       =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(lowerCAmelCase							,   lowerCAmelCase							,   atol=1e-3					)					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   *lowerCAmelCase							,   )  -> Dict:
        '''simple docstring'''






        _lowercase	       =BertGenerationDecoder(lowerCAmelCase					)
        model.to(lowerCAmelCase					)
        model.eval()
        _lowercase	       =model(lowerCAmelCase							,   attention_mask=lowerCAmelCase							,   labels=lowerCAmelCase					)
        self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.seq_length, self.vocab_size)					)




  def   A__     (				self					)  -> Optional[Any]:
        '''simple docstring'''






        _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase	       =self.prepare_config_and_inputs()
        _lowercase	       ={'input_ids': input_ids, 'attention_mask': input_mask}
        return config, inputs_dict





@require_torch
class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			unittest.TestCase							):
  _a									=  (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
  _a									=  (BertGenerationDecoder,) if is_torch_available() else ()
  _a									=  (
      {'feature-extraction': BertGenerationEncoder, 'text-generation': BertGenerationDecoder}
      if is_torch_available()
      else {}
  )




  def   A__     (				self					)  -> List[Any]:
        '''simple docstring'''






        _lowercase	       =BertGenerationEncoderTester(self					)
        _lowercase	       =ConfigTester(self							,   config_class=lowerCAmelCase							,   hidden_size=37					)




  def   A__     (				self					)  -> Tuple:
        '''simple docstring'''






        self.config_tester.run_common_tests()




  def   A__     (				self					)  -> Optional[int]:
        '''simple docstring'''






        _lowercase	       =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase					)




  def   A__     (				self					)  -> Optional[int]:
        '''simple docstring'''






        _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase	       =self.model_tester.prepare_config_and_inputs()
        _lowercase	       ='bert'
        self.model_tester.create_and_check_model(lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase					)




  def   A__     (				self					)  -> int:
        '''simple docstring'''






        _lowercase	       =self.model_tester.prepare_config_and_inputs_for_decoder()
        self.model_tester.create_and_check_model_as_decoder(*lowerCAmelCase					)




  def   A__     (				self					)  -> Optional[Any]:
        '''simple docstring'''






        _lowercase	       =self.model_tester.prepare_config_and_inputs_for_decoder()
        self.model_tester.create_and_check_decoder_model_past_large_inputs(*lowerCAmelCase					)




  def   A__     (				self					)  -> Union[str, Any]:
        '''simple docstring'''






        (
            (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,       (
            _lowercase    
        )       ,           
        )	       =self.model_tester.prepare_config_and_inputs_for_decoder()

        _lowercase	       =None

        self.model_tester.create_and_check_model_as_decoder(
            lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   )




  def   A__     (				self					)  -> Tuple:
        '''simple docstring'''






        _lowercase	       =self.model_tester.prepare_config_and_inputs_for_decoder()
        self.model_tester.create_and_check_for_causal_lm(*lowerCAmelCase					)




  @slow
  def   A__     (				self					)  -> int:
        '''simple docstring'''






        _lowercase	       =BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'					)
        self.assertIsNotNone(lowerCAmelCase					)





@require_torch
class  __lowerCAmelCase     (					unittest.TestCase							):




  @slow
  def   A__     (				self					)  -> Any:
        '''simple docstring'''






        _lowercase	       =BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'					)
        _lowercase	       =torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]]					)
        with torch.no_grad():
              _lowercase	       =model(lowerCAmelCase					)[0]
        _lowercase	       =torch.Size([1, 8, 1_024]					)
        self.assertEqual(output.shape							,   lowerCAmelCase					)
        _lowercase	       =torch.tensor(
            [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]]					)
        self.assertTrue(torch.allclose(output[:, :3, :3]							,   lowerCAmelCase							,   atol=1e-4					)					)





@require_torch
class  __lowerCAmelCase     (					unittest.TestCase							):




  @slow
  def   A__     (				self					)  -> Dict:
        '''simple docstring'''






        _lowercase	       =BertGenerationDecoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'					)
        _lowercase	       =torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]]					)
        with torch.no_grad():
              _lowercase	       =model(lowerCAmelCase					)[0]
        _lowercase	       =torch.Size([1, 8, 50_358]					)
        self.assertEqual(output.shape							,   lowerCAmelCase					)
        _lowercase	       =torch.tensor(
            [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]]					)
        self.assertTrue(torch.allclose(output[:, :3, :3]							,   lowerCAmelCase							,   atol=1e-4					)					)







'''simple docstring'''





from typing import List

import datasets
from datasets.tasks import AudioClassification

from ..folder_based_builder import folder_based_builder


lowercase_		       =  datasets.utils.logging.get_logger(__name__)






class __A			(  folder_based_builder.FolderBasedBuilderConfig						):



 '''simple docstring'''







 __lowerCamelCase    :       bool          =       None
 __lowerCamelCase    :       bool          =       None






class __A			(  folder_based_builder.FolderBasedBuilder						):



 '''simple docstring'''







 __lowerCamelCase    :       int          =       datasets.Audio()
 __lowerCamelCase    :       str          =       'audio'
 __lowerCamelCase    :       Optional[Any]          =       AudioFolderConfig
 __lowerCamelCase    :       List[str]  # definition at the bottom of the script
 __lowerCamelCase    :       Union[str, Any]          =       AudioClassification(audio_column='audio'   ,   label_column='label'						)





lowercase_		       =  [
    ".aiff",
    ".au",
    ".avr",
    ".caf",
    ".flac",
    ".htk",
    ".svx",
    ".mat4",
    ".mat5",
    ".mpc2k",
    ".ogg",
    ".paf",
    ".pvf",
    ".raw",
    ".rf64",
    ".sd2",
    ".sds",
    ".ircam",
    ".voc",
    ".w64",
    ".wav",
    ".nist",
    ".wavex",
    ".wve",
    ".xi",
    ".mp3",
    ".opus",
]
lowercase_		       =  AUDIO_EXTENSIONS



