"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import BlipImageProcessor




class   __snake_case			(	unittest.TestCase							):



      def __init__(		self       ,     lowercase       ,     lowercase=7       ,     lowercase=3       ,     lowercase=18       ,     lowercase=30       ,     lowercase=4_00       ,     lowercase=True       ,     lowercase=None       ,     lowercase=True       ,     lowercase=False       ,     lowercase=[0.48145466, 0.4578275, 0.40821073]       ,     lowercase=[0.26862954, 0.26130258, 0.27577711]       ,     lowercase=True       ,     )      ->     Optional[int]:





        '''simple docstring'''





        a__:	Dict     				=      size if size is not None else {'height': 20, 'width': 20}
        a__:	Dict     				=      parent
        a__:	Union[str, Any]     				=      batch_size
        a__:	Dict     				=      num_channels
        a__:	List[Any]     				=      image_size
        a__:	Optional[int]     				=      min_resolution
        a__:	List[str]     				=      max_resolution
        a__:	Optional[Any]     				=      do_resize
        a__:	Optional[Any]     				=      size
        a__:	Any     				=      do_normalize
        a__:	Union[str, Any]     				=      image_mean
        a__:	Dict     				=      image_std
        a__:	int     				=      do_pad
        a__:	int     				=      do_convert_rgb



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





        '''simple docstring'''





        return {
            "do_resize": self.do_resize,
            "size": self.size,
            "do_normalize": self.do_normalize,
            "image_mean": self.image_mean,
            "image_std": self.image_std,
            "do_convert_rgb": self.do_convert_rgb,
            "do_pad": self.do_pad,
        }



      def     lowerCamelCase_  (		self       ,     lowercase=False       ,     lowercase=False       ,     lowercase=False)      ->     str:





        '''simple docstring'''





        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

        if equal_resolution:
          a__:	List[str]     				=      []
          for i in range(self.batch_size):
            image_inputs.append(
                np.random.randint(
                    2_55       ,     size=(self.num_channels, self.max_resolution, self.max_resolution)       ,     dtype=np.uinta))
        else:
          a__:	List[str]     				=      []
          for i in range(self.batch_size):
            a__				,       a__:	Tuple     				=      np.random.choice(np.arange(self.min_resolution       ,     self.max_resolution)       ,     2)
            image_inputs.append(np.random.randint(2_55       ,     size=(self.num_channels, width, height)       ,     dtype=np.uinta))

        if not numpify and not torchify:
          # PIL expects the channel dimension as last dimension
          a__:	Union[str, Any]     				=      [Image.fromarray(np.moveaxis(lowercase       ,     0       ,     -1)) for x in image_inputs]

        if torchify:
          a__:	int     				=      [torch.from_numpy(lowercase) for x in image_inputs]

        return image_inputs







@require_torch
@require_vision
class   __snake_case			(	__lowerCAmelCase			, unittest.TestCase							):
      a__								=						BlipImageProcessor if is_vision_available() else None



      def     lowerCamelCase_  (		self)      ->     List[str]:





        '''simple docstring'''





        a__:	int     				=      BlipImageProcessingTester(self)



      @property
      def     lowerCamelCase_  (		self)      ->     Optional[Any]:





        '''simple docstring'''





        return self.image_processor_tester.prepare_image_processor_dict()



      def     lowerCamelCase_  (		self)      ->     Any:





        '''simple docstring'''





        a__:	Optional[int]     				=      self.image_processing_class(**self.image_processor_dict)
        self.assertTrue(hasattr(lowercase       ,     'do_resize'))
        self.assertTrue(hasattr(lowercase       ,     'size'))
        self.assertTrue(hasattr(lowercase       ,     'do_normalize'))
        self.assertTrue(hasattr(lowercase       ,     'image_mean'))
        self.assertTrue(hasattr(lowercase       ,     'image_std'))
        self.assertTrue(hasattr(lowercase       ,     'do_convert_rgb'))



      def     lowerCamelCase_  (		self)      ->     List[str]:





        '''simple docstring'''





        pass



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





        '''simple docstring'''





        a__:	Dict     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PIL images
        a__:	Any     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     Image.Image)

        # Test not batched input
        a__:	Tuple     				=      image_processor(image_inputs[0]       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Tuple     				=      image_processor(lowercase       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )



      def     lowerCamelCase_  (		self)      ->     str:





        '''simple docstring'''





        a__:	int     				=      self.image_processing_class(**self.image_processor_dict)
        # create random numpy tensors
        a__:	Optional[Any]     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase       ,     numpify=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     np.ndarray)

        # Test not batched input
        a__:	Dict     				=      image_processor(image_inputs[0]       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	int     				=      image_processor(lowercase       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )



      def     lowerCamelCase_  (		self)      ->     str:





        '''simple docstring'''





        a__:	int     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PyTorch tensors
        a__:	List[str]     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase       ,     torchify=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     torch.Tensor)

        # Test not batched input
        a__:	Optional[Any]     				=      image_processor(image_inputs[0]       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Tuple     				=      image_processor(lowercase       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )







@require_torch
@require_vision
class   __snake_case			(	__lowerCAmelCase			, unittest.TestCase							):
      a__								=						BlipImageProcessor if is_vision_available() else None



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





        '''simple docstring'''





        a__:	Optional[Any]     				=      BlipImageProcessingTester(self       ,     num_channels=4)
        a__:	Union[str, Any]     				=      3



      @property
      def     lowerCamelCase_  (		self)      ->     Dict:





        '''simple docstring'''





        return self.image_processor_tester.prepare_image_processor_dict()



      def     lowerCamelCase_  (		self)      ->     Dict:





        '''simple docstring'''





        a__:	Dict     				=      self.image_processing_class(**self.image_processor_dict)
        self.assertTrue(hasattr(lowercase       ,     'do_resize'))
        self.assertTrue(hasattr(lowercase       ,     'size'))
        self.assertTrue(hasattr(lowercase       ,     'do_normalize'))
        self.assertTrue(hasattr(lowercase       ,     'image_mean'))
        self.assertTrue(hasattr(lowercase       ,     'image_std'))
        self.assertTrue(hasattr(lowercase       ,     'do_convert_rgb'))



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





        '''simple docstring'''





        pass



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





        '''simple docstring'''





        a__:	Optional[int]     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PIL images
        a__:	Dict     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     Image.Image)

        # Test not batched input
        a__:	Union[str, Any]     				=      image_processor(image_inputs[0]       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                1,
                self.expected_encoded_image_num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Dict     				=      image_processor(lowercase       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                self.image_processor_tester.batch_size,
                self.expected_encoded_image_num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )







import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A_		:  str										=  logging.get_logger(__name__)

A_		:  Dict										=  {
    '''facebook/hubert-base-ls960''': '''https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json''',
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}



class 		_lowercase		(							UpperCAmelCase__						):
   _UpperCAmelCase  						=      '''hubert'''

   def __init__(   self      :							Optional[Any]				, __lowerCAmelCase      :							str=32				, __lowerCAmelCase      :							int=768				, __lowerCAmelCase      :							Optional[int]=12				, __lowerCAmelCase      :							List[Any]=12				, __lowerCAmelCase      :							Optional[Any]=3072				, __lowerCAmelCase      :							Tuple="gelu"				, __lowerCAmelCase      :							Dict=0.1				, __lowerCAmelCase      :							List[Any]=0.1				, __lowerCAmelCase      :							str=0.1				, __lowerCAmelCase      :							Union[str, Any]=True				, __lowerCAmelCase      :							Tuple=0.0				, __lowerCAmelCase      :							Optional[int]=0.1				, __lowerCAmelCase      :							List[str]=0.1				, __lowerCAmelCase      :							Dict=0.0_2				, __lowerCAmelCase      :							Any=1E-5				, __lowerCAmelCase      :							Optional[Any]="group"				, __lowerCAmelCase      :							int="gelu"				, __lowerCAmelCase      :							Dict=(512, 512, 512, 512, 512, 512, 512)				, __lowerCAmelCase      :							Tuple=(5, 2, 2, 2, 2, 2, 2)				, __lowerCAmelCase      :							Tuple=(10, 3, 3, 3, 3, 2, 2)				, __lowerCAmelCase      :							Tuple=False				, __lowerCAmelCase      :							Any=128				, __lowerCAmelCase      :							Tuple=16				, __lowerCAmelCase      :							Tuple=False				, __lowerCAmelCase      :							int=True				, __lowerCAmelCase      :							List[str]=0.0_5				, __lowerCAmelCase      :							List[str]=10				, __lowerCAmelCase      :							int=2				, __lowerCAmelCase      :							List[Any]=0.0				, __lowerCAmelCase      :							Dict=10				, __lowerCAmelCase      :							List[str]=0				, __lowerCAmelCase      :							Union[str, Any]="sum"				, __lowerCAmelCase      :							Dict=False				, __lowerCAmelCase      :							List[str]=False				, __lowerCAmelCase      :							int=256				, __lowerCAmelCase      :							List[str]=0				, __lowerCAmelCase      :							str=1				, __lowerCAmelCase      :							Any=2				, **__lowerCAmelCase      :							Tuple				, )							->					Tuple:


    """simple docstring"""






    super().__init__(**__lowerCAmelCase				, pad_token_id=__lowerCAmelCase				, bos_token_id=__lowerCAmelCase				, eos_token_id=__lowerCAmelCase				)
    a							=		hidden_size
    a							=		feat_extract_norm
    a							=		feat_extract_activation
    a							=		list(__lowerCAmelCase				)
    a							=		list(__lowerCAmelCase				)
    a							=		list(__lowerCAmelCase				)
    a							=		conv_bias
    a							=		num_conv_pos_embeddings
    a							=		num_conv_pos_embedding_groups
    a							=		len(self.conv_dim				)
    a							=		num_hidden_layers
    a							=		intermediate_size
    a							=		hidden_act
    a							=		num_attention_heads
    a							=		hidden_dropout
    a							=		attention_dropout
    a							=		activation_dropout
    a							=		feat_proj_layer_norm
    a							=		feat_proj_dropout
    a							=		final_dropout
    a							=		layerdrop
    a							=		layer_norm_eps
    a							=		initializer_range
    a							=		vocab_size
    a							=		do_stable_layer_norm
    a							=		use_weighted_layer_sum
    a							=		classifier_proj_size

    if (
        (len(self.conv_stride				) != self.num_feat_extract_layers)
        or (len(self.conv_kernel				) != self.num_feat_extract_layers)
        or (len(self.conv_dim				) != self.num_feat_extract_layers)
    ):
     raise ValueError(
         "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
         " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
         f""" {len(self.conv_dim				)}`, `len(config.conv_stride) = {len(self.conv_stride				)}`,"""
         f""" `len(config.conv_kernel) = {len(self.conv_kernel				)}`."""				)

    # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
    a							=		apply_spec_augment
    a							=		mask_time_prob
    a							=		mask_time_length
    a							=		mask_time_min_masks
    a							=		mask_feature_prob
    a							=		mask_feature_length
    a							=		mask_feature_min_masks

    # ctc loss
    a							=		ctc_loss_reduction
    a							=		ctc_zero_infinity




   @property
   def 		A				(   self      :							Tuple				)							->					Optional[Any]:


    """simple docstring"""






    return functools.reduce(operator.mul				, self.conv_stride				, 1				)

