



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


A_		:  Optional[int]										=  logging.get_logger(__name__)



class 		_lowercase		(							UpperCAmelCase__						):
   _UpperCAmelCase  						=      ['''pixel_values''']

   def __init__(   self      :							Optional[int]				, __lowerCAmelCase      :							bool = True				, __lowerCAmelCase      :							Optional[Dict[str, int]] = None				, __lowerCAmelCase      :							PILImageResampling = PILImageResampling.BILINEAR				, __lowerCAmelCase      :							bool = True				, __lowerCAmelCase      :							Union[int, float] = 1 / 255				, __lowerCAmelCase      :							bool = True				, __lowerCAmelCase      :							Optional[Union[float, List[float]]] = None				, __lowerCAmelCase      :							Optional[Union[float, List[float]]] = None				, **__lowerCAmelCase      :							Any				, )							->					None:


    """simple docstring"""






    super().__init__(**__lowerCAmelCase				)
    a							=		size if size is not None else {"height": 224, "width": 224}
    a							=		get_size_dict(__lowerCAmelCase				)
    a							=		do_resize
    a							=		do_rescale
    a							=		do_normalize
    a							=		size
    a							=		resample
    a							=		rescale_factor
    a							=		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
    a							=		image_std if image_std is not None else IMAGENET_STANDARD_STD

   def 		A				(   self      :							Tuple				, __lowerCAmelCase      :							np.ndarray				, __lowerCAmelCase      :							Dict[str, int]				, __lowerCAmelCase      :							PILImageResampling = PILImageResampling.BILINEAR				, __lowerCAmelCase      :							Optional[Union[str, ChannelDimension]] = None				, **__lowerCAmelCase      :							int				, )							->					np.ndarray:


    """simple docstring"""






    a							=		get_size_dict(__lowerCAmelCase				)
    if "height" not in size or "width" not in size:
     raise ValueError(f"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}"""				)
    return resize(
        __lowerCAmelCase				, size=(size["height"], size["width"])				, resample=__lowerCAmelCase				, data_format=__lowerCAmelCase				, **__lowerCAmelCase				)

   def 		A				(   self      :							Any				, __lowerCAmelCase      :							np.ndarray				, __lowerCAmelCase      :							float				, __lowerCAmelCase      :							Optional[Union[str, ChannelDimension]] = None				, **__lowerCAmelCase      :							Tuple				)							->					np.ndarray:


    """simple docstring"""






    return rescale(__lowerCAmelCase				, scale=__lowerCAmelCase				, data_format=__lowerCAmelCase				, **__lowerCAmelCase				)

   def 		A				(   self      :							Any				, __lowerCAmelCase      :							np.ndarray				, __lowerCAmelCase      :							Union[float, List[float]]				, __lowerCAmelCase      :							Union[float, List[float]]				, __lowerCAmelCase      :							Optional[Union[str, ChannelDimension]] = None				, **__lowerCAmelCase      :							str				, )							->					np.ndarray:


    """simple docstring"""






    return normalize(__lowerCAmelCase				, mean=__lowerCAmelCase				, std=__lowerCAmelCase				, data_format=__lowerCAmelCase				, **__lowerCAmelCase				)




   def 		A				(   self      :							str				, __lowerCAmelCase      :							ImageInput				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							Dict[str, int] = None				, __lowerCAmelCase      :							PILImageResampling = None				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							Optional[float] = None				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							Optional[Union[float, List[float]]] = None				, __lowerCAmelCase      :							Optional[Union[float, List[float]]] = None				, __lowerCAmelCase      :							Optional[Union[str, TensorType]] = None				, __lowerCAmelCase      :							Union[str, ChannelDimension] = ChannelDimension.FIRST				, **__lowerCAmelCase      :							Optional[int]				, )							->					List[Any]:


    """simple docstring"""






    a							=		do_resize if do_resize is not None else self.do_resize
    a							=		do_rescale if do_rescale is not None else self.do_rescale
    a							=		do_normalize if do_normalize is not None else self.do_normalize
    a							=		resample if resample is not None else self.resample
    a							=		rescale_factor if rescale_factor is not None else self.rescale_factor
    a							=		image_mean if image_mean is not None else self.image_mean
    a							=		image_std if image_std is not None else self.image_std

    a							=		size if size is not None else self.size
    a							=		get_size_dict(__lowerCAmelCase				)

    a							=		make_list_of_images(__lowerCAmelCase				)

    if not valid_images(__lowerCAmelCase				):
     raise ValueError(
         "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
         "torch.Tensor, tf.Tensor or jax.ndarray."				)

    if do_resize and size is None:
     raise ValueError("Size must be specified if do_resize is True."				)

    if do_rescale and rescale_factor is None:
     raise ValueError("Rescale factor must be specified if do_rescale is True."				)

    # All transformations expect numpy arrays.
    a							=		[to_numpy_array(__lowerCAmelCase				) for image in images]

    if do_resize:
     a							=		[self.resize(image=__lowerCAmelCase				, size=__lowerCAmelCase				, resample=__lowerCAmelCase				) for image in images]

    if do_rescale:
     a							=		[self.rescale(image=__lowerCAmelCase				, scale=__lowerCAmelCase				) for image in images]

    if do_normalize:
     a							=		[self.normalize(image=__lowerCAmelCase				, mean=__lowerCAmelCase				, std=__lowerCAmelCase				) for image in images]

    a							=		[to_channel_dimension_format(__lowerCAmelCase				, __lowerCAmelCase				) for image in images]

    a							=		{"pixel_values": images}
    return BatchFeature(data=__lowerCAmelCase				, tensor_type=__lowerCAmelCase				)







'''simple docstring'''





import functools
import operator

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


a		:	Dict       =      logging.get_logger(__name__)

a		:	Optional[int]       =      {
    '''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      UpperCamelCase       (	snake_case__       ):
  a     :int          =					'hubert'



  def __init__(			self		,     __lowerCAmelCase=32		,     __lowerCAmelCase=768		,     __lowerCAmelCase=12		,     __lowerCAmelCase=12		,     __lowerCAmelCase=3072		,     __lowerCAmelCase="gelu"		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=True		,     __lowerCAmelCase=0.0		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.02		,     __lowerCAmelCase=1e-5		,     __lowerCAmelCase="group"		,     __lowerCAmelCase="gelu"		,     __lowerCAmelCase=(512, 512, 512, 512, 512, 512, 512)		,     __lowerCAmelCase=(5, 2, 2, 2, 2, 2, 2)		,     __lowerCAmelCase=(10, 3, 3, 3, 3, 2, 2)		,     __lowerCAmelCase=False		,     __lowerCAmelCase=128		,     __lowerCAmelCase=16		,     __lowerCAmelCase=False		,     __lowerCAmelCase=True		,     __lowerCAmelCase=0.05		,     __lowerCAmelCase=10		,     __lowerCAmelCase=2		,     __lowerCAmelCase=0.0		,     __lowerCAmelCase=10		,     __lowerCAmelCase=0		,     __lowerCAmelCase="sum"		,     __lowerCAmelCase=False		,     __lowerCAmelCase=False		,     __lowerCAmelCase=256		,     __lowerCAmelCase=0		,     __lowerCAmelCase=1		,     __lowerCAmelCase=2		,     **__lowerCAmelCase		,     ):







      '''simple docstring'''


      super().__init__(**__lowerCAmelCase		,     pad_token_id=__lowerCAmelCase		,     bos_token_id=__lowerCAmelCase		,     eos_token_id=__lowerCAmelCase )
      _a				:							List[Any]							       =      hidden_size
      _a				:							Union[str, Any]							       =      feat_extract_norm
      _a				:							Any							       =      feat_extract_activation
      _a				:							Tuple							       =      list(__lowerCAmelCase )
      _a				:							List[Any]							       =      list(__lowerCAmelCase )
      _a				:							Any							       =      list(__lowerCAmelCase )
      _a				:							Optional[int]							       =      conv_bias
      _a				:							Tuple							       =      num_conv_pos_embeddings
      _a				:							Optional[int]							       =      num_conv_pos_embedding_groups
      _a				:							Tuple							       =      len(self.conv_dim )
      _a				:							int							       =      num_hidden_layers
      _a				:							Optional[Any]							       =      intermediate_size
      _a				:							Dict							       =      hidden_act
      _a				:							Tuple							       =      num_attention_heads
      _a				:							Tuple							       =      hidden_dropout
      _a				:							str							       =      attention_dropout
      _a				:							Union[str, Any]							       =      activation_dropout
      _a				:							int							       =      feat_proj_layer_norm
      _a				:							List[Any]							       =      feat_proj_dropout
      _a				:							Any							       =      final_dropout
      _a				:							Dict							       =      layerdrop
      _a				:							List[str]							       =      layer_norm_eps
      _a				:							Any							       =      initializer_range
      _a				:							List[str]							       =      vocab_size
      _a				:							int							       =      do_stable_layer_norm
      _a				:							str							       =      use_weighted_layer_sum
      _a				:							Optional[Any]							       =      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				:							str							       =      apply_spec_augment
      _a				:							List[Any]							       =      mask_time_prob
      _a				:							List[Any]							       =      mask_time_length
      _a				:							List[Any]							       =      mask_time_min_masks
      _a				:							Union[str, Any]							       =      mask_feature_prob
      _a				:							str							       =      mask_feature_length
      _a				:							Any							       =      mask_feature_min_masks

      # ctc loss
      _a				:							Tuple							       =      ctc_loss_reduction
      _a				:							Optional[int]							       =      ctc_zero_infinity



  @property
  def     a_							(			self ):







      '''simple docstring'''


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


