





'''simple docstring'''




import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import (
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_MAPPING,
      DeiTForImageClassification,
      DeiTForImageClassificationWithTeacher,
      DeiTForMaskedImageModeling,
      DeiTModel,
  )
  from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import DeiTImageProcessor


class  SCREAMING_SNAKE_CASE    :


     def __init__(						self						,	_UpperCAmelCase						,	_UpperCAmelCase=13						,	_UpperCAmelCase=30						,	_UpperCAmelCase=2						,	_UpperCAmelCase=3						,	_UpperCAmelCase=True						,	_UpperCAmelCase=True						,	_UpperCAmelCase=32						,	_UpperCAmelCase=5						,	_UpperCAmelCase=4						,	_UpperCAmelCase=37						,	_UpperCAmelCase="gelu"						,	_UpperCAmelCase=0.1						,	_UpperCAmelCase=0.1						,	_UpperCAmelCase=10						,	_UpperCAmelCase=0.02						,	_UpperCAmelCase=3						,	_UpperCAmelCase=None						,	_UpperCAmelCase=2						,	):

          '''simple docstring'''






          __A						: Optional[Any]      =       parent
          __A						: int      =       batch_size
          __A						: List[Any]      =       image_size
          __A						: Union[str, Any]      =       patch_size
          __A						: Union[str, Any]      =       num_channels
          __A						: str      =       is_training
          __A						: str      =       use_labels
          __A						: str      =       hidden_size
          __A						: Union[str, Any]      =       num_hidden_layers
          __A						: int      =       num_attention_heads
          __A						: Optional[int]      =       intermediate_size
          __A						: str      =       hidden_act
          __A						: Tuple      =       hidden_dropout_prob
          __A						: List[str]      =       attention_probs_dropout_prob
          __A						: int      =       type_sequence_label_size
          __A						: str      =       initializer_range
          __A						: Union[str, Any]      =       scope
          __A						: List[str]      =       encoder_stride

          # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
          __A						: str      =       (image_size // patch_size) ** 2
          __A						: Optional[int]      =       num_patches + 2


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Tuple      =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

          __A						: List[str]      =       None
          if self.use_labels:
               __A						: str      =       ids_tensor([self.batch_size]						,	self.type_sequence_label_size)

          __A						: Any      =       self.get_config()

          return config, pixel_values, labels


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return DeiTConfig(
              image_size=self.image_size						,	patch_size=self.patch_size						,	num_channels=self.num_channels						,	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						,	is_decoder=__SCREAMING_SNAKE_CASE						,	initializer_range=self.initializer_range						,	encoder_stride=self.encoder_stride						,	)


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase):

          '''simple docstring'''






          __A						: Optional[Any]      =       DeiTModel(config=__SCREAMING_SNAKE_CASE)
          model.to(__SCREAMING_SNAKE_CASE)
          model.eval()
          __A						: Optional[Any]      =       model(__SCREAMING_SNAKE_CASE)
          self.parent.assertEqual(result.last_hidden_state.shape						,	(self.batch_size, self.seq_length, self.hidden_size))


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase):

          '''simple docstring'''






          __A						: Any      =       DeiTForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE)
          model.to(__SCREAMING_SNAKE_CASE)
          model.eval()
          __A						: Union[str, Any]      =       model(__SCREAMING_SNAKE_CASE)
          self.parent.assertEqual(
              result.reconstruction.shape						,	(self.batch_size, self.num_channels, self.image_size, self.image_size))

          # test greyscale images
          __A						: Dict      =       1
          __A						: Optional[int]      =       DeiTForMaskedImageModeling(__SCREAMING_SNAKE_CASE)
          model.to(__SCREAMING_SNAKE_CASE)
          model.eval()

          __A						: List[Any]      =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
          __A						: List[Any]      =       model(__SCREAMING_SNAKE_CASE)
          self.parent.assertEqual(result.reconstruction.shape						,	(self.batch_size, 1, self.image_size, self.image_size))


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase):

          '''simple docstring'''






          __A						: Any      =       self.type_sequence_label_size
          __A						: Union[str, Any]      =       DeiTForImageClassification(__SCREAMING_SNAKE_CASE)
          model.to(__SCREAMING_SNAKE_CASE)
          model.eval()
          __A						: Any      =       model(__SCREAMING_SNAKE_CASE						,	labels=__SCREAMING_SNAKE_CASE)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.type_sequence_label_size))

          # test greyscale images
          __A						: List[str]      =       1
          __A						: List[Any]      =       DeiTForImageClassification(__SCREAMING_SNAKE_CASE)
          model.to(__SCREAMING_SNAKE_CASE)
          model.eval()

          __A						: Tuple      =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
          __A						: int      =       model(__SCREAMING_SNAKE_CASE						,	labels=__SCREAMING_SNAKE_CASE)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.type_sequence_label_size))


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Any      =       self.prepare_config_and_inputs()
          (
              (
              __A	
          ) ,(
              __A	
          ) ,(
              __A	
          ) ,	
          )						: List[str]      =       config_and_inputs
          __A						: List[str]      =       {'pixel_values': pixel_values}
          return config, inputs_dict




@require_torch
class  SCREAMING_SNAKE_CASE    (__snake_case					,		__snake_case					,		unittest.TestCase							):
     lowerCAmelCase					=       (
         (
             DeiTModel,
             DeiTForImageClassification,
             DeiTForImageClassificationWithTeacher,
             DeiTForMaskedImageModeling,
         )
         if is_torch_available()
         else ()
     )
     lowerCAmelCase					=       (
         {
             """feature-extraction""": DeiTModel,
             """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     lowerCAmelCase					=       False
     lowerCAmelCase					=       False
     lowerCAmelCase					=       False


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: str      =       DeiTModelTester(self)
          __A						: List[str]      =       ConfigTester(self						,	config_class=__SCREAMING_SNAKE_CASE						,	has_text_modality=__SCREAMING_SNAKE_CASE						,	hidden_size=37)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          self.config_tester.run_common_tests()


     @unittest.skip(reason='DeiT does not use inputs_embeds')
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          pass


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A ,__A						: Optional[Any]      =       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __A						: Any      =       model_class(__SCREAMING_SNAKE_CASE)
               self.assertIsInstance(model.get_input_embeddings()						,	(nn.Module))
               __A						: Tuple      =       model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE						,	nn.Linear))


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A ,__A						: Union[str, Any]      =       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __A						: Any      =       model_class(__SCREAMING_SNAKE_CASE)
               __A						: Optional[int]      =       inspect.signature(model.forward)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               __A						: int      =       [*signature.parameters.keys()]

               __A						: List[Any]      =       ['pixel_values']
               self.assertListEqual(arg_names[:1]						,	__SCREAMING_SNAKE_CASE)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Optional[int]      =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Any      =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Tuple      =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE)


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase=False):

          '''simple docstring'''






          __A						: Optional[int]      =       super()._prepare_for_class(__SCREAMING_SNAKE_CASE						,	__SCREAMING_SNAKE_CASE						,	return_labels=__SCREAMING_SNAKE_CASE)

          if return_labels:
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                    del inputs_dict["labels"]

          return inputs_dict


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          if not self.model_tester.is_training:
               return

          __A ,__A						: Optional[int]      =       self.model_tester.prepare_config_and_inputs_for_common()
          __A						: str      =       True

          for model_class in self.all_model_classes:
               # DeiTForImageClassificationWithTeacher supports inference-only
               if (
                   model_class in get_values(__SCREAMING_SNAKE_CASE)
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                    continue
               __A						: int      =       model_class(__SCREAMING_SNAKE_CASE)
               model.to(__SCREAMING_SNAKE_CASE)
               model.train()
               __A						: int      =       self._prepare_for_class(__SCREAMING_SNAKE_CASE						,	__SCREAMING_SNAKE_CASE						,	return_labels=__SCREAMING_SNAKE_CASE)
               __A						: Optional[int]      =       model(**__SCREAMING_SNAKE_CASE).loss
               loss.backward()


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A ,__A						: Union[str, Any]      =       self.model_tester.prepare_config_and_inputs_for_common()
          if not self.model_tester.is_training:
               return

          __A						: Dict      =       False
          __A						: str      =       True

          for model_class in self.all_model_classes:
               if model_class in get_values(__SCREAMING_SNAKE_CASE) or not model_class.supports_gradient_checkpointing:
                    continue
               # DeiTForImageClassificationWithTeacher supports inference-only
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                    continue
               __A						: Union[str, Any]      =       model_class(__SCREAMING_SNAKE_CASE)
               model.gradient_checkpointing_enable()
               model.to(__SCREAMING_SNAKE_CASE)
               model.train()
               __A						: int      =       self._prepare_for_class(__SCREAMING_SNAKE_CASE						,	__SCREAMING_SNAKE_CASE						,	return_labels=__SCREAMING_SNAKE_CASE)
               __A						: Any      =       model(**__SCREAMING_SNAKE_CASE).loss
               loss.backward()


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A ,__A						: Dict      =       self.model_tester.prepare_config_and_inputs_for_common()

          __A						: Optional[Any]      =       [
              {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
              {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
              {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
          ]

          for model_class in self.all_model_classes:
               if (
                   model_class
                   not in [
                       *get_values(__SCREAMING_SNAKE_CASE),
                       *get_values(__SCREAMING_SNAKE_CASE),
                   ]
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                    continue

               for problem_type in problem_types:
                    with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'):
                         __A						: Union[str, Any]      =       problem_type['title']
                         __A						: Union[str, Any]      =       problem_type['num_labels']

                         __A						: List[Any]      =       model_class(__SCREAMING_SNAKE_CASE)
                         model.to(__SCREAMING_SNAKE_CASE)
                         model.train()

                         __A						: str      =       self._prepare_for_class(__SCREAMING_SNAKE_CASE						,	__SCREAMING_SNAKE_CASE						,	return_labels=__SCREAMING_SNAKE_CASE)

                         if problem_type["num_labels"] > 1:
                              __A						: int      =       inputs['labels'].unsqueeze(1).repeat(1						,	problem_type['num_labels'])

                         __A						: Dict      =       inputs['labels'].to(problem_type['dtype'])

                         # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                         # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                         # they have the same size." which is a symptom something in wrong for the regression problem.
                         # See https://github.com/huggingface/transformers/issues/11780
                         with warnings.catch_warnings(record=__SCREAMING_SNAKE_CASE) as warning_list:
                              __A						: Union[str, Any]      =       model(**__SCREAMING_SNAKE_CASE).loss
                         for w in warning_list:
                              if "Using a target size that is different to the input size" in str(w.message):
                                   raise ValueError(
                                       F'Something is going wrong in the regression problem: intercepted {w.message}')

                         loss.backward()


     @slow
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __A						: str      =       DeiTModel.from_pretrained(__SCREAMING_SNAKE_CASE)
               self.assertIsNotNone(__SCREAMING_SNAKE_CASE)






def        _lowerCAmelCase			(  )     ->     Any:
     __A						: Tuple      =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
     return image







@require_torch
@require_vision
class  SCREAMING_SNAKE_CASE    (unittest.TestCase							):


     @cached_property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return (
              DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224')
              if is_vision_available()
              else None
          )


     @slow
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Union[str, Any]      =       DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224').to(
              __SCREAMING_SNAKE_CASE)

          __A						: Optional[int]      =       self.default_image_processor
          __A						: str      =       prepare_img()
          __A						: Union[str, Any]      =       image_processor(images=__SCREAMING_SNAKE_CASE						,	return_tensors='pt').to(__SCREAMING_SNAKE_CASE)

          # forward pass
          with torch.no_grad():
               __A						: Union[str, Any]      =       model(**__SCREAMING_SNAKE_CASE)

          # verify the logits
          __A						: Optional[Any]      =       torch.Size((1, 1000))
          self.assertEqual(outputs.logits.shape						,	__SCREAMING_SNAKE_CASE)

          __A						: Optional[Any]      =       torch.tensor([-1.0266, 0.1912, -1.2861]).to(__SCREAMING_SNAKE_CASE)

          self.assertTrue(torch.allclose(outputs.logits[0, :3]						,	__SCREAMING_SNAKE_CASE						,	atol=1e-4))


     @slow
     @require_accelerate
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: List[Any]      =       DeiTModel.from_pretrained(
              'facebook/deit-base-distilled-patch16-224'						,	torch_dtype=torch.floataa						,	device_map='auto')
          __A						: Optional[int]      =       self.default_image_processor

          __A						: Optional[int]      =       prepare_img()
          __A						: Dict      =       image_processor(images=__SCREAMING_SNAKE_CASE						,	return_tensors='pt')
          __A						: Dict      =       inputs.pixel_values.to(__SCREAMING_SNAKE_CASE)

          # forward pass to make sure inference works in fp16
          with torch.no_grad():
               __A						: Optional[int]      =       model(__SCREAMING_SNAKE_CASE)







"""simple docstring"""





import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


_SCREAMING_SNAKE_CASE					:				Tuple					    =						random.Random()







def      lowerCamelCase__       (							_lowerCamelCase       :		List[Any]		,				_lowerCamelCase       :		List[Any]=1.0		,				_lowerCamelCase       :		Optional[int]=None		,				_lowerCamelCase       :		str=None )      ->				List[str]:
  if rng is None:
    lowerCamelCase_         =						global_rng

  lowerCamelCase_         =						[]
  for batch_idx in range(shape[0] ):
    values.append([] )
    for _ in range(shape[1] ):
      values[-1].append(rng.random() * scale )

  return values






@require_torch
class      a						(					unittest.TestCase		):






    def __init__(       self     :							Any       ,						__SCREAMING_SNAKE_CASE     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							Tuple=7       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=400       ,						__SCREAMING_SNAKE_CASE     :							int=2000       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=1       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=0.0       ,						__SCREAMING_SNAKE_CASE     :							Dict=16000       ,						__SCREAMING_SNAKE_CASE     :							Dict=True       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=80       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=16       ,						__SCREAMING_SNAKE_CASE     :							int=64       ,						__SCREAMING_SNAKE_CASE     :							Tuple="hann_window"       ,						__SCREAMING_SNAKE_CASE     :							Dict=80       ,						__SCREAMING_SNAKE_CASE     :							List[str]=7600       ,						__SCREAMING_SNAKE_CASE     :							List[str]=1e-1_0       ,						__SCREAMING_SNAKE_CASE     :							Any=True       ,						)     ->		List[str]:
      lowerCamelCase_         =						parent
      lowerCamelCase_         =						batch_size
      lowerCamelCase_         =						min_seq_length
      lowerCamelCase_         =						max_seq_length
      lowerCamelCase_         =						(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      lowerCamelCase_         =						feature_size
      lowerCamelCase_         =						padding_value
      lowerCamelCase_         =						sampling_rate
      lowerCamelCase_         =						do_normalize
      lowerCamelCase_         =						num_mel_bins
      lowerCamelCase_         =						hop_length
      lowerCamelCase_         =						win_length
      lowerCamelCase_         =						win_function
      lowerCamelCase_         =						fmin
      lowerCamelCase_         =						fmax
      lowerCamelCase_         =						mel_floor
      lowerCamelCase_         =						return_attention_mask






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "do_normalize": self.do_normalize,
          "num_mel_bins": self.num_mel_bins,
          "hop_length": self.hop_length,
          "win_length": self.win_length,
          "win_function": self.win_function,
          "fmin": self.fmin,
          "fmax": self.fmax,
          "mel_floor": self.mel_floor,
          "return_attention_mask": self.return_attention_mask,
      }






    def    UpperCamelCase       (       self     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							Tuple=False       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=False					)     ->		str:
      def _flatten(__SCREAMING_SNAKE_CASE     :							Any					):
        return list(itertools.chain(*__SCREAMING_SNAKE_CASE					)					)

      if equal_length:
        lowerCamelCase_         =						floats_list((self.batch_size, self.max_seq_length)					)
      else:
        # make sure that inputs increase in size
        lowerCamelCase_         =						[
            _flatten(floats_list((x, self.feature_size)					)					)
            for x in range(self.min_seq_length       ,						self.max_seq_length       ,						self.seq_length_diff					)
        ]

      if numpify:
        lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]

      return speech_inputs






    def    UpperCamelCase       (       self     :							Optional[int]       ,						__SCREAMING_SNAKE_CASE     :							str=False       ,						__SCREAMING_SNAKE_CASE     :							Any=False					)     ->		int:
      if equal_length:
        lowerCamelCase_         =						[floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
      else:
        # make sure that inputs increase in size
        lowerCamelCase_         =						[
            floats_list((x, self.num_mel_bins)					)
            for x in range(self.min_seq_length       ,						self.max_seq_length       ,						self.seq_length_diff					)
        ]

      if numpify:
        lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]

      return speech_inputs






@require_torch
class      a						(					__snake_case  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     Any						= SpeechTaFeatureExtractor






    def    UpperCamelCase       (       self     :							Any					)     ->		Any:
      lowerCamelCase_         =						SpeechTaFeatureExtractionTester(self					)






    def    UpperCamelCase       (       self     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							int					)     ->		List[Any]:
      self.assertTrue(np.all(np.mean(__SCREAMING_SNAKE_CASE       ,						axis=0					) < 1e-3					)					)
      self.assertTrue(np.all(np.abs(np.var(__SCREAMING_SNAKE_CASE       ,						axis=0					) - 1					) < 1e-3					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		int:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      # create three inputs of length 800, 1000, and 1200
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test not batched input
      lowerCamelCase_         =						feat_extract(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		Optional[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]
      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
        lowerCamelCase_         =						processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:800]					)
        self.assertTrue(input_values[0][800:].sum() < 1e-6					)
        self._check_zero_mean_unit_variance(input_values[1][:1000]					)
        self.assertTrue(input_values[0][1000:].sum() < 1e-6					)
        self._check_zero_mean_unit_variance(input_values[2][:1200]					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Dict:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						range(800       ,						1400       ,						200					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in lengths]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]

      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE					)
        lowerCamelCase_         =						processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:800]					)
        self._check_zero_mean_unit_variance(input_values[1][:1000]					)
        self._check_zero_mean_unit_variance(input_values[2][:1200]					)






    def    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='max_length'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1]					)
      self._check_zero_mean_unit_variance(input_values[2]					)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1, :1000]					)
      self._check_zero_mean_unit_variance(input_values[2]					)

      # make sure that if max_length < longest -> then pad to max_length
      self.assertTrue(input_values.shape == (3, 1000)					)

      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=2000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1, :1000]					)
      self._check_zero_mean_unit_variance(input_values[2]					)

      # make sure that if max_length > longest -> then pad to longest
      self.assertTrue(input_values.shape == (3, 1200)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						np.random.rand(100					).astype(np.floataa					)
      lowerCamelCase_         =						np_speech_inputs.tolist()

      for inputs in [py_speech_inputs, np_speech_inputs]:
        lowerCamelCase_         =						feature_extractor.pad([{'input_values': inputs}]       ,						return_tensors='np'					)
        self.assertTrue(np_processed.input_values.dtype == np.floataa					)
        lowerCamelCase_         =						feature_extractor.pad([{'input_values': inputs}]       ,						return_tensors='pt'					)
        self.assertTrue(pt_processed.input_values.dtype == torch.floataa					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Tuple:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      # create three inputs of length 800, 1000, and 1200
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test feature size
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      self.assertTrue(input_values.ndim == 3					)
      self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

      # Test not batched input
      lowerCamelCase_         =						feature_extractor(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test 2-D numpy arrays are batched.
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in (800, 800, 800)]
      lowerCamelCase_         =						np.asarray(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							int					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      self.assertTrue(all(len(__SCREAMING_SNAKE_CASE					) == len(__SCREAMING_SNAKE_CASE					) for x, y in zip(__SCREAMING_SNAKE_CASE       ,						processed_features[input_name]					)					)					)

      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='np'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							Tuple					)     ->		Any:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='pt'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)[input_name]
      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='pt'					)[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(list(processed.attention_mask.shape					)       ,						list(processed[input_name].shape[:2]					)					)
      self.assertListEqual(processed.attention_mask.sum(-1					).tolist()       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)
      lowerCamelCase_         =						min(__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(
          __SCREAMING_SNAKE_CASE       ,						padding='max_length'       ,						max_length=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(
          list(processed_pad.attention_mask.shape					)       ,						[processed_pad[input_name].shape[0], max_length]					)
      self.assertListEqual(
          processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()       ,						[max_length for x in speech_inputs]					)






    def    UpperCamelCase       (       self     :							Optional[Any]       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]					)     ->		List[str]:
      from datasets import load_dataset

      lowerCamelCase_         =						load_dataset('hf-internal-testing/librispeech_asr_dummy'       ,						'clean'       ,						split='validation'					)
      # automatic decoding with librispeech
      lowerCamelCase_         =						ds.sort('id'					).select(range(__SCREAMING_SNAKE_CASE					)					)[:num_samples]['audio']

      return [x["array"] for x in speech_samples]






    def    UpperCamelCase       (       self     :							str					)     ->		Dict:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
           3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
           2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
           4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
           7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
           4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 93680)					)
      self.assertTrue(torch.allclose(input_values[0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-6					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Optional[int]:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
           -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
           -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
           -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 366, 80)					)
      self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-4					)					)




