





"""simple docstring"""
from typing import Dict, Optional

import numpy as np

import datasets


__UpperCamelCase     :						Tuple						       =  '''\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'''

__UpperCamelCase     :						Any						       =  '''\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'''

__UpperCamelCase     :						Optional[int]						       =  '''\\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 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    str  ,     _UpperCAmelCase					:    str  ,     _UpperCAmelCase					:    Tuple  ,     _UpperCAmelCase					:    bool  ,     _UpperCAmelCase					:    Optional[Dict[int, int]] = None  ,     _UpperCAmelCase					:    bool = False  ,     ):





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

    # turn into Numpy arrays
 lowerCAmelCase    				= np.array(a__			)
 lowerCAmelCase    				= np.array(a__			)

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

 lowerCAmelCase    				= label != ignore_index
 lowerCAmelCase    				= np.not_equal(a__  ,     a__			)
 lowerCAmelCase    				= pred_label[mask]
 lowerCAmelCase    				= np.array(a__			)[mask]

 lowerCAmelCase    				= pred_label[pred_label == label]

 lowerCAmelCase    				= np.histogram(a__  ,     bins=a__  ,     range=(0, num_labels - 1)			)[0]
 lowerCAmelCase    				= np.histogram(a__  ,     bins=a__  ,     range=(0, num_labels - 1)			)[0]
 lowerCAmelCase    				= np.histogram(a__  ,     bins=a__  ,     range=(0, num_labels - 1)			)[0]

 lowerCAmelCase    				= area_pred_label + area_label - area_intersect

 return area_intersect, area_union, area_pred_label, area_label

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Optional[int]  ,     _UpperCAmelCase					:    Any  ,     _UpperCAmelCase					:    Optional[int]  ,     _UpperCAmelCase					:    bool  ,     _UpperCAmelCase					:    Optional[Dict[int, int]] = None  ,     _UpperCAmelCase					:    bool = False  ,     ):
 lowerCAmelCase    				= np.zeros((num_labels,)  ,     dtype=np.floataa			)
 lowerCAmelCase    				= np.zeros((num_labels,)  ,     dtype=np.floataa			)
 lowerCAmelCase    				= np.zeros((num_labels,)  ,     dtype=np.floataa			)
 lowerCAmelCase    				= np.zeros((num_labels,)  ,     dtype=np.floataa			)
 for result, gt_seg_map in zip(a__  ,     a__			):
  lowerCAmelCase				,lowerCAmelCase				,lowerCAmelCase				,lowerCAmelCase    				= intersect_and_union(
      a__  ,     a__  ,     a__  ,     a__  ,     a__  ,     a__			)
  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 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    List[str]  ,     _UpperCAmelCase					:    str  ,     _UpperCAmelCase					:    int  ,     _UpperCAmelCase					:    bool  ,     _UpperCAmelCase					:    Optional[int] = None  ,     _UpperCAmelCase					:    Optional[Dict[int, int]] = None  ,     _UpperCAmelCase					:    bool = False  ,     ):
 lowerCAmelCase				,lowerCAmelCase				,lowerCAmelCase				,lowerCAmelCase    				= total_intersect_and_union(
     a__  ,     a__  ,     a__  ,     a__  ,     a__  ,     a__			)

 # compute metrics
 lowerCAmelCase    				= {}

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

 lowerCAmelCase    				= np.nanmean(a__			)
 lowerCAmelCase    				= np.nanmean(a__			)
 lowerCAmelCase    				= all_acc
 lowerCAmelCase    				= iou
 lowerCAmelCase    				= acc

 if nan_to_num is not None:
  lowerCAmelCase    				= {metric: np.nan_to_num(a__  ,     nan=a__			) 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     ):







  """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				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case = None				,       _snake_case = None				,       _snake_case = False				,       ):







  """simple docstring"""






  lowerCAmelCase    				= 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












from typing import Tuple, Union

from ...modeling_outputs import BackboneOutput
from ...modeling_utils import PreTrainedModel
from ...utils import is_timm_available, is_torch_available, requires_backends
from ...utils.backbone_utils import BackboneMixin
from .configuration_timm_backbone import TimmBackboneConfig


if is_timm_available():
					import timm


if is_torch_available():
					from torch import Tensor

class 							__SCREAMING_SNAKE_CASE       (  _a ,		_a							):
							snake_case  :   int      =							"""pixel_values"""
							snake_case  :   List[Any]      =							False
							snake_case  :   str      =							TimmBackboneConfig






							def __init__(    self	,			__lowerCAmelCase	,			**__lowerCAmelCase	):
														requires_backends(self	,			"""timm"""	)
														super().__init__(__lowerCAmelCase	)
														UpperCamelCase__					  =      config

														if config.backbone is None:
																					raise ValueError("""backbone is not set in the config. Please set it to a timm model name."""	)

														if config.backbone not in timm.list_models():
																					raise ValueError(f"""backbone {config.backbone} is not supported by timm."""	)

														if hasattr(__lowerCAmelCase	,			"""out_features"""	) and config.out_features is not None:
																					raise ValueError("""out_features is not supported by TimmBackbone. Please use out_indices instead."""	)

														UpperCamelCase__					  =      getattr(__lowerCAmelCase	,			"""use_pretrained_backbone"""	,			__lowerCAmelCase	)
														if pretrained is None:
																					raise ValueError("""use_pretrained_backbone is not set in the config. Please set it to True or False."""	)

														# We just take the final layer by default. This matches the default for the transformers models.
														UpperCamelCase__					  =      config.out_indices if getattr(__lowerCAmelCase	,			"""out_indices"""	,			__lowerCAmelCase	) is not None else (-1,)

														UpperCamelCase__					  =      timm.create_model(
														    config.backbone	,			pretrained=__lowerCAmelCase	,			features_only=config.features_only	,			in_chans=config.num_channels	,			out_indices=__lowerCAmelCase	,			**__lowerCAmelCase	,			)
														# These are used to control the output of the model when called. If output_hidden_states is True, then
														# return_layers is modified to include all layers.
														UpperCamelCase__					  =      self._backbone.return_layers
														UpperCamelCase__					  =      {layer["""module"""]: str(__lowerCAmelCase	) for i, layer in enumerate(self._backbone.feature_info.info	)}
														super()._init_backbone(__lowerCAmelCase	)






							@classmethod
							def 					_lowerCamelCase		(    cls	,			__lowerCAmelCase	,			*__lowerCAmelCase	,			**__lowerCAmelCase	):
														requires_backends(cls	,			["""vision""", """timm"""]	)
														from ...models.timm_backbone import TimmBackboneConfig

														UpperCamelCase__					  =      kwargs.pop("""config"""	,			TimmBackboneConfig()	)

														UpperCamelCase__					  =      kwargs.pop("""use_timm_backbone"""	,			__lowerCAmelCase	)
														if not use_timm:
																					raise ValueError("""use_timm_backbone must be True for timm backbones"""	)

														UpperCamelCase__					  =      kwargs.pop("""num_channels"""	,			config.num_channels	)
														UpperCamelCase__					  =      kwargs.pop("""features_only"""	,			config.features_only	)
														UpperCamelCase__					  =      kwargs.pop("""use_pretrained_backbone"""	,			config.use_pretrained_backbone	)
														UpperCamelCase__					  =      kwargs.pop("""out_indices"""	,			config.out_indices	)
														UpperCamelCase__					  =      TimmBackboneConfig(
														    backbone=__lowerCAmelCase	,			num_channels=__lowerCAmelCase	,			features_only=__lowerCAmelCase	,			use_pretrained_backbone=__lowerCAmelCase	,			out_indices=__lowerCAmelCase	,			)
														return super()._from_config(__lowerCAmelCase	,			**__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	):
														pass







							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase=None	,			__lowerCAmelCase=None	,			__lowerCAmelCase=None	,			**__lowerCAmelCase	):
														UpperCamelCase__					  =      return_dict if return_dict is not None else self.config.use_return_dict
														UpperCamelCase__					  =      (
														    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
														)
														UpperCamelCase__					  =      output_attentions if output_attentions is not None else self.config.output_attentions

														if output_attentions:
																					raise ValueError("""Cannot output attentions for timm backbones at the moment"""	)

														if output_hidden_states:
																					# We modify the return layers to include all the stages of the backbone
																					UpperCamelCase__					  =      self._all_layers
																					UpperCamelCase__					  =      self._backbone(__lowerCAmelCase	,			**__lowerCAmelCase	)
																					UpperCamelCase__					  =      self._return_layers
																					UpperCamelCase__					  =      tuple(hidden_states[i] for i in self.out_indices	)
														else:
																					UpperCamelCase__					  =      self._backbone(__lowerCAmelCase	,			**__lowerCAmelCase	)
																					UpperCamelCase__					  =      None

														UpperCamelCase__					  =      tuple(__lowerCAmelCase	)
														UpperCamelCase__					  =      tuple(__lowerCAmelCase	) if hidden_states is not None else None

														if not return_dict:
																					UpperCamelCase__					  =      (feature_maps,)
																					if output_hidden_states:
																												UpperCamelCase__					  =      output + (hidden_states,)
																					return output

														return BackboneOutput(feature_maps=__lowerCAmelCase	,			hidden_states=__lowerCAmelCase	,			attentions=__lowerCAmelCase	)




