




import copy
from typing import Dict, Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING
from ..detr import DetrConfig
from ..swin import SwinConfig


lowerCAmelCase_						=			{
    'facebook/maskformer-swin-base-ade': (
        'https://huggingface.co/facebook/maskformer-swin-base-ade/blob/main/config.json'
    )
    # See all MaskFormer models at https://huggingface.co/models?filter=maskformer
}

lowerCAmelCase_						=			logging.get_logger(__name__)
class 						_A (  _lowerCamelCase				):
  _UpperCamelCase       :      int			=      '''maskformer'''
  _UpperCamelCase       :      Union[str, Any]			=      {'''hidden_size''': '''mask_feature_size'''}
  _UpperCamelCase       :      Dict			=      ['''resnet''', '''swin''']
  _UpperCamelCase       :      Optional[int]			=      ['''detr''']






  def __init__(  self		:     Any				,						_A		:     int = 256				,						_A		:     int = 256				,						_A		:     float = 0.1				,						_A		:     bool = False				,						_A		:     Optional[Dict] = None				,						_A		:     Optional[Dict] = None				,						_A		:     float = 0.02				,						_A		:     float = 1.0				,						_A		:     float = 1.0				,						_A		:     float = 1.0				,						_A		:     float = 20.0				,						_A		:     Optional[bool] = None				,						**_A		:     str				,						)		->   str:






       """simple docstring"""







       if backbone_config is None:
            # fall back to https://huggingface.co/microsoft/swin-base-patch4-window12-384-in22k
            lowercase :       List[str]       =			SwinConfig(
                image_size=384				,						in_channels=3				,						patch_size=4				,						embed_dim=128				,						depths=[2, 2, 18, 2]				,						num_heads=[4, 8, 16, 32]				,						window_size=12				,						drop_path_rate=0.3				,						out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']				,						)

       if isinstance(_A				,						_A				):
            lowercase :       Optional[int]       =			backbone_config.pop('''model_type'''				)
            lowercase :       List[str]       =			CONFIG_MAPPING[backbone_model_type]
            lowercase :       Union[str, Any]       =			config_class.from_dict(_A				)

       # verify that the backbone is supported
       if backbone_config.model_type not in self.backbones_supported:
            logger.warning_once(
                f"""Backbone {backbone_config.model_type} is not a supported model and may not be compatible with MaskFormer. """
                f"""Supported model types: {','.join(self.backbones_supported				)}"""				)

       if decoder_config is None:
            # fall back to https://huggingface.co/facebook/detr-resnet-50
            lowercase :       Any       =			DetrConfig()
       else:
            # verify that the decoder is supported
            lowercase :       Union[str, Any]       =			(
                decoder_config.pop('''model_type'''				) if isinstance(_A				,						_A				) else decoder_config.model_type
            )
            if decoder_type not in self.decoders_supported:
                 raise ValueError(
                     f"""Transformer Decoder {decoder_type} not supported, please use one of"""
                     f""" {','.join(self.decoders_supported				)}"""				)
            if isinstance(_A				,						_A				):
                 lowercase :       str       =			CONFIG_MAPPING[decoder_type]
                 lowercase :       Dict       =			config_class.from_dict(_A				)

       lowercase :       Tuple       =			backbone_config
       lowercase :       List[Any]       =			decoder_config
       # main feature dimension for the model
       lowercase :       Optional[int]       =			fpn_feature_size
       lowercase :       List[Any]       =			mask_feature_size
       # initializer
       lowercase :       Union[str, Any]       =			init_std
       lowercase :       Tuple       =			init_xavier_std
       # Hungarian matcher && loss
       lowercase :       List[str]       =			cross_entropy_weight
       lowercase :       int       =			dice_weight
       lowercase :       List[Any]       =			mask_weight
       lowercase :       Tuple       =			use_auxiliary_loss
       lowercase :       Tuple       =			no_object_weight
       lowercase :       int       =			output_auxiliary_logits

       lowercase :       List[Any]       =			self.decoder_config.encoder_attention_heads
       lowercase :       List[Any]       =			self.decoder_config.num_hidden_layers
       super().__init__(**_A				)






  @classmethod
  def  __a      (  cls		:     Optional[int]				,						_A		:     PretrainedConfig				,						_A		:     PretrainedConfig				,						**_A		:     str				)		->   Any:






       """simple docstring"""







       return cls(
           backbone_config=_A				,						decoder_config=_A				,						**_A				,						)






  def  __a      (  self		:     Optional[int]				)		->   Dict[str, any]:






       """simple docstring"""







       lowercase :       str       =			copy.deepcopy(self.__dict__				)
       lowercase :       Optional[Any]       =			self.backbone_config.to_dict()
       lowercase :       List[Any]       =			self.decoder_config.to_dict()
       lowercase :       Optional[int]       =			self.__class__.model_type
       return output





import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCAmelCase_						=			logging.get_logger(__name__)
class 						_A (  _lowerCamelCase				):
  _UpperCamelCase       :      str			=      ['''input_values''', '''attention_mask''']






  def __init__(  self		:     Optional[Any]				,						_A		:     int = 1				,						_A		:     int = 16_000				,						_A		:     float = 0.0				,						_A		:     bool = False				,						_A		:     int = 80				,						_A		:     int = 16				,						_A		:     int = 64				,						_A		:     str = "hann_window"				,						_A		:     float = 1.0				,						_A		:     float = 80				,						_A		:     float = 7_600				,						_A		:     float = 1E-10				,						_A		:     int = 2				,						_A		:     bool = True				,						**_A		:     int				,						)		->   Union[str, Any]:






       """simple docstring"""







       super().__init__(feature_size=_A				,						sampling_rate=_A				,						padding_value=_A				,						**_A				)
       lowercase :       str       =			do_normalize
       lowercase :       int       =			return_attention_mask

       lowercase :       Union[str, Any]       =			num_mel_bins
       lowercase :       Union[str, Any]       =			hop_length
       lowercase :       Dict       =			win_length
       lowercase :       Union[str, Any]       =			win_function
       lowercase :       int       =			frame_signal_scale
       lowercase :       Dict       =			fmin
       lowercase :       Optional[Any]       =			fmax
       lowercase :       str       =			mel_floor
       lowercase :       Dict       =			reduction_factor

       lowercase :       List[Any]       =			win_length * sampling_rate // 1_000
       lowercase :       Union[str, Any]       =			hop_length * sampling_rate // 1_000
       lowercase :       Optional[Any]       =			optimal_fft_length(self.sample_size				)
       lowercase :       Dict       =			(self.n_fft // 2) + 1

       lowercase :       Any       =			window_function(window_length=self.sample_size				,						name=self.win_function				,						periodic=_A				)

       lowercase :       Dict       =			mel_filter_bank(
           num_frequency_bins=self.n_freqs				,						num_mel_filters=self.num_mel_bins				,						min_frequency=self.fmin				,						max_frequency=self.fmax				,						sampling_rate=self.sampling_rate				,						norm='''slaney'''				,						mel_scale='''slaney'''				,						)

       if frame_signal_scale != 1.0:
            warnings.warn(
                '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)
       if reduction_factor != 2.0:
            warnings.warn(
                '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)






  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def  __a      (  _A		:     List[np.ndarray]				,						_A		:     List[np.ndarray]				,						_A		:     float = 0.0				)		->   List[np.ndarray]:






       """simple docstring"""







       if attention_mask is not None:
            lowercase :       Optional[int]       =			np.array(_A				,						np.intaa				)
            lowercase :       Dict       =			[]

            for vector, length in zip(_A				,						attention_mask.sum(-1				)				):
                 lowercase :       Dict       =			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7				)
                 if length < normed_slice.shape[0]:
                      lowercase :       List[str]       =			padding_value

                 normed_input_values.append(_A				)
       else:
            lowercase :       Dict       =			[(x - x.mean()) / np.sqrt(x.var() + 1E-7				) for x in input_values]

       return normed_input_values






  def  __a      (  self		:     Any				,						_A		:     np.ndarray				,						)		->   np.ndarray:






       """simple docstring"""







       lowercase :       Tuple       =			spectrogram(
           _A				,						window=self.window				,						frame_length=self.sample_size				,						hop_length=self.sample_stride				,						fft_length=self.n_fft				,						mel_filters=self.mel_filters				,						mel_floor=self.mel_floor				,						log_mel='''log10'''				,						)
       return log_mel_spec.T






  def __call__(  self		:     List[Any]				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						_A		:     Optional[int] = None				,						**_A		:     Tuple				,						)		->   BatchFeature:






       """simple docstring"""







       if audio is None and audio_target is None:
            raise ValueError('''You must provide either `audio` or `audio_target` values.'''				)

       if sampling_rate is not None:
            if sampling_rate != self.sampling_rate:
                 raise ValueError(
                     f"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
                     f""" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"""
                     f""" {self.sampling_rate} and not {sampling_rate}."""				)
       else:
            logger.warning(
                '''It is strongly recommended to pass the ``sampling_rate`` argument to this function. '''
                '''Failing to do so can result in silent errors that might be hard to debug.'''				)

       if audio is not None:
            lowercase :       Any       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)
       else:
            lowercase :       Any       =			None

       if audio_target is not None:
            lowercase :       Tuple       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)

            if inputs is None:
                 return inputs_target
            else:
                 lowercase :       Any       =			inputs_target['''input_values''']
                 lowercase :       Dict       =			inputs_target.get('''attention_mask'''				)
                 if decoder_attention_mask is not None:
                      lowercase :       Union[str, Any]       =			decoder_attention_mask

       return inputs






  def  __a      (  self		:     List[Any]				,						_A		:     Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,						_A		:     bool = False				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						**_A		:     Any				,						)		->   BatchFeature:






       """simple docstring"""







       lowercase :       Optional[int]       =			isinstance(_A				,						np.ndarray				) and len(speech.shape				) > 1
       if is_batched_numpy and len(speech.shape				) > 2:
            raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""				)
       lowercase :       int       =			is_batched_numpy or (
           isinstance(_A				,						(list, tuple)				) and (isinstance(speech[0]				,						(np.ndarray, tuple, list)				))
       )

       if is_batched:
            lowercase :       Optional[int]       =			[np.asarray(_A				,						dtype=np.floataa				) for speech in speech]
       elif not is_batched and not isinstance(_A				,						np.ndarray				):
            lowercase :       List[str]       =			np.asarray(_A				,						dtype=np.floataa				)
       elif isinstance(_A				,						np.ndarray				) and speech.dtype is np.dtype(np.floataa				):
            lowercase :       List[str]       =			speech.astype(np.floataa				)

       # always return batch
       if not is_batched:
            lowercase :       Union[str, Any]       =			[speech]

       # needed to make pad() work on spectrogram inputs
       lowercase :       Any       =			self.feature_size

       # convert into correct format for padding
       if is_target:
            lowercase :       int       =			[self._extract_mel_features(_A				) for waveform in speech]
            lowercase :       Any       =			BatchFeature({'''input_values''': features}				)
            lowercase :       Optional[Any]       =			self.num_mel_bins
       else:
            lowercase :       Optional[Any]       =			BatchFeature({'''input_values''': speech}				)

       lowercase :       Optional[int]       =			self.pad(
           _A				,						padding=_A				,						max_length=_A				,						truncation=_A				,						pad_to_multiple_of=_A				,						return_attention_mask=_A				,						**_A				,						)

       lowercase :       str       =			feature_size_hack

       # convert input values to correct format
       lowercase :       List[Any]       =			padded_inputs['''input_values''']
       if not isinstance(input_values[0]				,						np.ndarray				):
            lowercase :       List[str]       =			[np.asarray(_A				,						dtype=np.floataa				) for array in input_values]
       elif (
           not isinstance(_A				,						np.ndarray				)
           and isinstance(input_values[0]				,						np.ndarray				)
           and input_values[0].dtype is np.dtype(np.floataa				)
       ):
            lowercase :       List[str]       =			[array.astype(np.floataa				) for array in input_values]
       elif isinstance(_A				,						np.ndarray				) and input_values.dtype is np.dtype(np.floataa				):
            lowercase :       Optional[Any]       =			input_values.astype(np.floataa				)

       # convert attention_mask to correct format
       lowercase :       int       =			padded_inputs.get('''attention_mask'''				)
       if attention_mask is not None:
            lowercase :       Union[str, Any]       =			[np.asarray(_A				,						dtype=np.intaa				) for array in attention_mask]

       # zero-mean and unit-variance normalization
       if not is_target and self.do_normalize:
            lowercase :       Any       =			(
                attention_mask
                if self._get_padding_strategies(_A				,						max_length=_A				) is not PaddingStrategy.DO_NOT_PAD
                else None
            )
            lowercase :       Optional[int]       =			self.zero_mean_unit_var_norm(
                padded_inputs['''input_values''']				,						attention_mask=_A				,						padding_value=self.padding_value				)

       if return_tensors is not None:
            lowercase :       Tuple       =			padded_inputs.convert_to_tensors(_A				)

       return padded_inputs






  def  __a      (  self		:     Optional[Any]				)		->   Dict[str, Any]:






       """simple docstring"""







       lowercase :       Optional[Any]       =			super().to_dict()

       # Don't serialize these as they are derived from the other properties.
       lowercase :       Optional[int]       =			['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
       for name in names:
            if name in output:
                 del output[name]

       return output