





'''simple docstring'''

from typing import Dict, Optional

import numpy as np

import datasets


a   	=    "\nIoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union\nbetween the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,\nthe mean IoU of the image is calculated by taking the IoU of each class and averaging them.\n"

a   	=    "\nArgs:\n    predictions (`List[ndarray]`):\n        List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n    references (`List[ndarray]`):\n        List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n    num_labels (`int`):\n        Number of classes (categories).\n    ignore_index (`int`):\n        Index that will be ignored during evaluation.\n    nan_to_num (`int`, *optional*):\n        If specified, NaN values will be replaced by the number defined by the user.\n    label_map (`dict`, *optional*):\n        If specified, dictionary mapping old label indices to new label indices.\n    reduce_labels (`bool`, *optional*, defaults to `False`):\n        Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,\n        and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.\n\nReturns:\n    `Dict[str, float | ndarray]` comprising various elements:\n    - *mean_iou* (`float`):\n        Mean Intersection-over-Union (IoU averaged over all categories).\n    - *mean_accuracy* (`float`):\n        Mean accuracy (averaged over all categories).\n    - *overall_accuracy* (`float`):\n        Overall accuracy on all images.\n    - *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):\n        Per category accuracy.\n    - *per_category_iou* (`ndarray` of shape `(num_labels,)`):\n        Per category IoU.\n\nExamples:\n\n    >>> import numpy as np\n\n    >>> mean_iou = datasets.load_metric(\"mean_iou\")\n\n    >>> # suppose one has 3 different segmentation maps predicted\n    >>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])\n    >>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])\n\n    >>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])\n    >>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])\n\n    >>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])\n    >>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])\n\n    >>> predicted = [predicted_1, predicted_2, predicted_3]\n    >>> ground_truth = [actual_1, actual_2, actual_3]\n\n    >>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {'mean_iou': 0.47750000000000004, 'mean_accuracy': 0.5916666666666666, 'overall_accuracy': 0.5263157894736842, 'per_category_iou': array([0.   , 0.   , 0.375, 0.4  , 0.5  , 0.   , 0.5  , 1.   , 1.   , 1.   ]), 'per_category_accuracy': array([0.        , 0.        , 0.75      , 0.66666667, 1.        , 0.        , 0.5       , 1.        , 1.        , 1.        ])}\n"

a   	=    "\\n@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,\nauthor = {{MMSegmentation Contributors}},\nlicense = {Apache-2.0},\nmonth = {7},\ntitle = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},\nurl = {https://github.com/open-mmlab/mmsegmentation},\nyear = {2020}\n}"

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase = None				,						__UpperCAmelCase = False				,						)    ->       List[Any]:

   '''simple docstring'''







   if label_map is not None:
      for old_id, new_id in label_map.items():
         __SCREAMING_SNAKE_CASE   				=							new_id

    # turn into Numpy arrays
   __SCREAMING_SNAKE_CASE   				=							np.array(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							np.array(__UpperCAmelCase   )

   if reduce_labels:
      __SCREAMING_SNAKE_CASE   				=							255
      __SCREAMING_SNAKE_CASE   				=							label - 1
      __SCREAMING_SNAKE_CASE   				=							255

   __SCREAMING_SNAKE_CASE   				=							label != ignore_index
   __SCREAMING_SNAKE_CASE   				=							np.not_equal(__UpperCAmelCase				,						__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							pred_label[mask]
   __SCREAMING_SNAKE_CASE   				=							np.array(__UpperCAmelCase   )[mask]

   __SCREAMING_SNAKE_CASE   				=							pred_label[pred_label == label]

   __SCREAMING_SNAKE_CASE   				=							np.histogram(__UpperCAmelCase				,						bins=__UpperCAmelCase				,						range=(0, num_labels - 1)   )[0]
   __SCREAMING_SNAKE_CASE   				=							np.histogram(__UpperCAmelCase				,						bins=__UpperCAmelCase				,						range=(0, num_labels - 1)   )[0]
   __SCREAMING_SNAKE_CASE   				=							np.histogram(__UpperCAmelCase				,						bins=__UpperCAmelCase				,						range=(0, num_labels - 1)   )[0]

   __SCREAMING_SNAKE_CASE   				=							area_pred_label + area_label - area_intersect

   return area_intersect, area_union, area_pred_label, area_label

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase = None				,						__UpperCAmelCase = False				,						)    ->       Optional[int]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							np.zeros((num_labels,)				,						dtype=np.floataa   )
   __SCREAMING_SNAKE_CASE   				=							np.zeros((num_labels,)				,						dtype=np.floataa   )
   __SCREAMING_SNAKE_CASE   				=							np.zeros((num_labels,)				,						dtype=np.floataa   )
   __SCREAMING_SNAKE_CASE   				=							np.zeros((num_labels,)				,						dtype=np.floataa   )
   for result, gt_seg_map in zip(__UpperCAmelCase				,						__UpperCAmelCase   ):
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							intersect_and_union(
          __UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )
      total_area_intersect += area_intersect
      total_area_union += area_union
      total_area_pred_label += area_pred_label
      total_area_label += area_label
   return total_area_intersect, total_area_union, total_area_pred_label, total_area_label

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase = None				,						__UpperCAmelCase = None				,						__UpperCAmelCase = False				,						)    ->       Dict:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							total_intersect_and_union(
       __UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )

   # compute metrics
   __SCREAMING_SNAKE_CASE   				=							{}

   __SCREAMING_SNAKE_CASE   				=							total_area_intersect.sum() / total_area_label.sum()
   __SCREAMING_SNAKE_CASE   				=							total_area_intersect / total_area_union
   __SCREAMING_SNAKE_CASE   				=							total_area_intersect / total_area_label

   __SCREAMING_SNAKE_CASE   				=							np.nanmean(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							np.nanmean(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							all_acc
   __SCREAMING_SNAKE_CASE   				=							iou
   __SCREAMING_SNAKE_CASE   				=							acc

   if nan_to_num is not None:
      __SCREAMING_SNAKE_CASE   				=							{metric: np.nan_to_num(__UpperCAmelCase				,						nan=__UpperCAmelCase   ) for metric, metric_value in metrics.items()}

   return metrics







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION      )
class __a			( datasets.Metric      ):





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      return datasets.MetricInfo(
          description=_DESCRIPTION					,citation=_CITATION					,inputs_description=_KWARGS_DESCRIPTION					,features=datasets.Features(
              # 1st Seq - height dim, 2nd - width dim
              {
                  """predictions""": datasets.Sequence(datasets.Sequence(datasets.Value("""uint16"""     )     )     ),
                  """references""": datasets.Sequence(datasets.Sequence(datasets.Value("""uint16"""     )     )     ),
              }     )					,reference_urls=[
              """https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py"""
          ]					,)





   def   UpperCAmelCase__  (       self					:      int					,lowerCamelCase					:      Optional[int]					,lowerCamelCase					:      Any					,lowerCamelCase					:      int					,lowerCamelCase					:      bool					,lowerCamelCase					:      Optional[int] = None					,lowerCamelCase					:      Optional[Dict[int, int]] = None					,lowerCamelCase					:      bool = False					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							mean_iou(
          results=lowerCamelCase					,gt_seg_maps=lowerCamelCase					,num_labels=lowerCamelCase					,ignore_index=lowerCamelCase					,nan_to_num=lowerCamelCase					,label_map=lowerCamelCase					,reduce_labels=lowerCamelCase					,)
      return iou_result







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


UpperCamelCase_						:     Union[str, Any]	       =							logging.get_logger(__name__)




class   __lowercase						(						__snake_case       ):
	_A       =   ["input_values", "attention_mask"]






	def __init__(self				: int      ,	snake_case				: int = 1      ,	snake_case				: int = 1_6000      ,	snake_case				: float = 0.0      ,	snake_case				: bool = False      ,	snake_case				: int = 80      ,	snake_case				: int = 16      ,	snake_case				: int = 64      ,	snake_case				: str = "hann_window"      ,	snake_case				: float = 1.0      ,	snake_case				: float = 80      ,	snake_case				: float = 7600      ,	snake_case				: float = 1e-10      ,	snake_case				: int = 2      ,	snake_case				: bool = True      ,	**snake_case				: Any      ,	) ->			str:
							super().__init__(feature_size=snake_case      ,	sampling_rate=snake_case      ,	padding_value=snake_case      ,	**snake_case    )
							_lowercase       :	int           =   do_normalize
							_lowercase       :	Any           =   return_attention_mask

							_lowercase       :	str           =   num_mel_bins
							_lowercase       :	str           =   hop_length
							_lowercase       :	List[Any]           =   win_length
							_lowercase       :	Tuple           =   win_function
							_lowercase       :	Any           =   frame_signal_scale
							_lowercase       :	Any           =   fmin
							_lowercase       :	Any           =   fmax
							_lowercase       :	List[str]           =   mel_floor
							_lowercase       :	str           =   reduction_factor

							_lowercase       :	str           =   win_length * sampling_rate // 1000
							_lowercase       :	Optional[int]           =   hop_length * sampling_rate // 1000
							_lowercase       :	Tuple           =   optimal_fft_length(self.sample_size    )
							_lowercase       :	int           =   (self.n_fft // 2) + 1

							_lowercase       :	Tuple           =   window_function(window_length=self.sample_size      ,	name=self.win_function      ,	periodic=snake_case    )

							_lowercase       :	Optional[int]           =   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"      ,	snake_case      ,	)
							if reduction_factor != 2.0:
													warnings.warn(
													    "The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"      ,	snake_case      ,	)






	@staticmethod
	# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
	def       _a(snake_case				: List[np.ndarray]      ,	snake_case				: List[np.ndarray]      ,	snake_case				: float = 0.0    ) ->			List[np.ndarray]:
							if attention_mask is not None:
													_lowercase       :	List[str]           =   np.array(snake_case      ,	np.intaa    )
													_lowercase       :	Dict           =   []

													for vector, length in zip(snake_case      ,	attention_mask.sum(-1    )    ):
																			_lowercase       :	Tuple           =   (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(snake_case    )
							else:
													_lowercase       :	Dict           =   [(x - x.mean()) / np.sqrt(x.var() + 1e-7    ) for x in input_values]

							return normed_input_values






	def       _a(self				: Optional[Any]      ,	snake_case				: np.ndarray      ,	) ->			np.ndarray:
							_lowercase       :	Tuple           =   spectrogram(
							    snake_case      ,	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				: Tuple      ,	snake_case				: Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None      ,	snake_case				: Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None      ,	snake_case				: Union[bool, str, PaddingStrategy] = False      ,	snake_case				: Optional[int] = None      ,	snake_case				: bool = False      ,	snake_case				: Optional[int] = None      ,	snake_case				: Optional[bool] = None      ,	snake_case				: Optional[Union[str, TensorType]] = None      ,	snake_case				: Optional[int] = None      ,	**snake_case				: Union[str, Any]      ,	) ->			BatchFeature:
							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       :	Union[str, Any]           =   self._process_audio(
													    snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	**snake_case      ,	)
							else:
													_lowercase       :	str           =   None

							if audio_target is not None:
													_lowercase       :	Union[str, Any]           =   self._process_audio(
													    snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	snake_case      ,	**snake_case      ,	)

													if inputs is None:
																			return inputs_target
													else:
																			_lowercase       :	int           =   inputs_target["input_values"]
																			_lowercase       :	Optional[int]           =   inputs_target.get("attention_mask"    )
																			if decoder_attention_mask is not None:
																									_lowercase       :	List[str]           =   decoder_attention_mask

							return inputs






	def       _a(self				: Optional[Any]      ,	snake_case				: Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]      ,	snake_case				: bool = False      ,	snake_case				: Union[bool, str, PaddingStrategy] = False      ,	snake_case				: Optional[int] = None      ,	snake_case				: bool = False      ,	snake_case				: Optional[int] = None      ,	snake_case				: Optional[bool] = None      ,	snake_case				: Optional[Union[str, TensorType]] = None      ,	**snake_case				: int      ,	) ->			BatchFeature:
							_lowercase       :	int           =   isinstance(snake_case      ,	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       :	List[str]           =   is_batched_numpy or (
							    isinstance(snake_case      ,	(list, tuple)    ) and (isinstance(speech[0]      ,	(np.ndarray, tuple, list)    ))
							)

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

							# always return batch
							if not is_batched:
													_lowercase       :	int           =   [speech]

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

							# convert into correct format for padding
							if is_target:
													_lowercase       :	List[str]           =   [self._extract_mel_features(snake_case    ) for waveform in speech]
													_lowercase       :	int           =   BatchFeature({"input_values": features}    )
													_lowercase       :	str           =   self.num_mel_bins
							else:
													_lowercase       :	Optional[int]           =   BatchFeature({"input_values": speech}    )

							_lowercase       :	List[Any]           =   self.pad(
							    snake_case      ,	padding=snake_case      ,	max_length=snake_case      ,	truncation=snake_case      ,	pad_to_multiple_of=snake_case      ,	return_attention_mask=snake_case      ,	**snake_case      ,	)

							_lowercase       :	Optional[Any]           =   feature_size_hack

							# convert input values to correct format
							_lowercase       :	int           =   padded_inputs["input_values"]
							if not isinstance(input_values[0]      ,	np.ndarray    ):
													_lowercase       :	Any           =   [np.asarray(snake_case      ,	dtype=np.floataa    ) for array in input_values]
							elif (
							    not isinstance(snake_case      ,	np.ndarray    )
							    and isinstance(input_values[0]      ,	np.ndarray    )
							    and input_values[0].dtype is np.dtype(np.floataa    )
							):
													_lowercase       :	Union[str, Any]           =   [array.astype(np.floataa    ) for array in input_values]
							elif isinstance(snake_case      ,	np.ndarray    ) and input_values.dtype is np.dtype(np.floataa    ):
													_lowercase       :	Tuple           =   input_values.astype(np.floataa    )

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

							# zero-mean and unit-variance normalization
							if not is_target and self.do_normalize:
													_lowercase       :	Dict           =   (
													    attention_mask
													    if self._get_padding_strategies(snake_case      ,	max_length=snake_case    ) is not PaddingStrategy.DO_NOT_PAD
													    else None
													)
													_lowercase       :	List[Any]           =   self.zero_mean_unit_var_norm(
													    padded_inputs["input_values"]      ,	attention_mask=snake_case      ,	padding_value=self.padding_value    )

							if return_tensors is not None:
													_lowercase       :	Any           =   padded_inputs.convert_to_tensors(snake_case    )

							return padded_inputs






	def       _a(self				: Dict    ) ->			Dict[str, Any]:
							_lowercase       :	str           =   super().to_dict()

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

							return output




