"""simple docstring"""




import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
    import os

    # The slow tests are often failing with OOM error on GPU
    # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
    # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
    __lowerCamelCase											=  "platform"

    import jax
    import jax.numpy as jnp

    from transformers import BlenderbotTokenizer
    from transformers.models.blenderbot.modeling_flax_blenderbot import (
        FlaxBlenderbotForConditionalGeneration,
        FlaxBlenderbotModel,
        shift_tokens_right,
    )






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__=None       ,    UpperCamelCase__=None       ,    UpperCamelCase__=None       ,    UpperCamelCase__=None       ,    UpperCamelCase__=None       ,    UpperCamelCase__=None       ,    ):






       """simple docstring"""





       if attention_mask is None:
              A__	     =							np.where(input_ids != config.pad_token_id       ,    1       ,    0				)
       if decoder_attention_mask is None:
              A__	     =							np.where(decoder_input_ids != config.pad_token_id       ,    1       ,    0				)
       if head_mask is None:
              A__	     =							np.ones((config.encoder_layers, config.encoder_attention_heads)				)
       if decoder_head_mask is None:
              A__	     =							np.ones((config.decoder_layers, config.decoder_attention_heads)				)
       if cross_attn_head_mask is None:
              A__	     =							np.ones((config.decoder_layers, config.decoder_attention_heads)				)
       return {
           "input_ids": input_ids,
           "decoder_input_ids": decoder_input_ids,
           "attention_mask": attention_mask,
           "decoder_attention_mask": attention_mask,
       }
class     UpperCamelCase__:





      def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=7		,__UpperCAmelCase=True		,__UpperCAmelCase=False		,__UpperCAmelCase=99		,__UpperCAmelCase=16		,__UpperCAmelCase=2		,__UpperCAmelCase=4		,__UpperCAmelCase=4		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.1		,__UpperCAmelCase=32		,__UpperCAmelCase=2		,__UpperCAmelCase=1		,__UpperCAmelCase=0		,__UpperCAmelCase=0.0_2		,)					->				List[str]:
             A__	     =							parent
             A__	     =							batch_size
             A__	     =							seq_length
             A__	     =							is_training
             A__	     =							use_labels
             A__	     =							vocab_size
             A__	     =							hidden_size
             A__	     =							num_hidden_layers
             A__	     =							num_attention_heads
             A__	     =							intermediate_size
             A__	     =							hidden_act
             A__	     =							hidden_dropout_prob
             A__	     =							attention_probs_dropout_prob
             A__	     =							max_position_embeddings
             A__	     =							eos_token_id
             A__	     =							pad_token_id
             A__	     =							bos_token_id
             A__	     =							initializer_range





      def 				snake_case__	(       self     )					->				Optional[int]:
             A__	     =							np.clip(ids_tensor([self.batch_size, self.seq_length - 1]		,self.vocab_size     )		,3		,self.vocab_size     )
             A__	     =							np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)		,dtype=np.intaa     ))		,-1     )

             A__	     =							shift_tokens_right(lowerCamelCase_		,1		,2     )

             A__	     =							BlenderbotConfig(
                 vocab_size=self.vocab_size		,d_model=self.hidden_size		,encoder_layers=self.num_hidden_layers		,decoder_layers=self.num_hidden_layers		,encoder_attention_heads=self.num_attention_heads		,decoder_attention_heads=self.num_attention_heads		,encoder_ffn_dim=self.intermediate_size		,decoder_ffn_dim=self.intermediate_size		,dropout=self.hidden_dropout_prob		,attention_dropout=self.attention_probs_dropout_prob		,max_position_embeddings=self.max_position_embeddings		,eos_token_id=self.eos_token_id		,bos_token_id=self.bos_token_id		,pad_token_id=self.pad_token_id		,initializer_range=self.initializer_range		,use_cache=lowerCamelCase_		,)
             A__	     =							prepare_blenderbot_inputs_dict(lowerCamelCase_		,lowerCamelCase_		,lowerCamelCase_     )
             return config, inputs_dict





      def 				snake_case__	(       self     )					->				List[Any]:
             A__     ,  A__	     =							self.prepare_config_and_inputs()
             return config, inputs_dict





      def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				str:
             A__	     =							20
             A__	     =							model_class_name(lowerCamelCase_     )

             A__	     =							model.encode(inputs_dict['input_ids']     )

             A__     ,  A__	     =							(
                 inputs_dict['decoder_input_ids'],
                 inputs_dict['decoder_attention_mask'],
             )

             A__	     =							model.init_cache(decoder_input_ids.shape[0]		,lowerCamelCase_		,lowerCamelCase_     )
             A__	     =							jnp.ones((decoder_input_ids.shape[0], max_decoder_length)		,dtype='i4'     )

             A__	     =							jnp.broadcast_to(
                 jnp.arange(decoder_input_ids.shape[-1] - 1     )[None, :]		,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,)
             A__	     =							model.decode(
                 decoder_input_ids[:, :-1]		,lowerCamelCase_		,decoder_attention_mask=lowerCamelCase_		,past_key_values=lowerCamelCase_		,decoder_position_ids=lowerCamelCase_		,)

             A__	     =							jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,dtype='i4'     )
             A__	     =							model.decode(
                 decoder_input_ids[:, -1:]		,lowerCamelCase_		,decoder_attention_mask=lowerCamelCase_		,past_key_values=outputs_cache.past_key_values		,decoder_position_ids=lowerCamelCase_		,)

             A__	     =							model.decode(lowerCamelCase_		,lowerCamelCase_     )

             A__	     =							np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])     )     )
             self.parent.assertTrue(diff < 1e-3		,msg=f'''Max diff is {diff}'''     )





      def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Any:
             A__	     =							20
             A__	     =							model_class_name(lowerCamelCase_     )

             A__	     =							model.encode(inputs_dict['input_ids']     )

             A__     ,  A__	     =							(
                 inputs_dict['decoder_input_ids'],
                 inputs_dict['decoder_attention_mask'],
             )

             A__	     =							jnp.concatenate(
                 [
                     decoder_attention_mask,
                     jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])     ),
                 ]		,axis=-1		,)

             A__	     =							model.init_cache(decoder_input_ids.shape[0]		,lowerCamelCase_		,lowerCamelCase_     )
             A__	     =							jnp.broadcast_to(
                 jnp.arange(decoder_input_ids.shape[-1] - 1     )[None, :]		,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,)

             A__	     =							model.decode(
                 decoder_input_ids[:, :-1]		,lowerCamelCase_		,decoder_attention_mask=lowerCamelCase_		,past_key_values=lowerCamelCase_		,decoder_position_ids=lowerCamelCase_		,)
             A__	     =							jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,dtype='i4'     )
             A__	     =							model.decode(
                 decoder_input_ids[:, -1:]		,lowerCamelCase_		,past_key_values=outputs_cache.past_key_values		,decoder_attention_mask=lowerCamelCase_		,decoder_position_ids=lowerCamelCase_		,)

             A__	     =							model.decode(lowerCamelCase_		,lowerCamelCase_		,decoder_attention_mask=lowerCamelCase_     )

             A__	     =							np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])     )     )
             self.parent.assertTrue(diff < 1e-3		,msg=f'''Max diff is {diff}'''     )






@require_flax
class     UpperCamelCase__(			unittest.TestCase ):
      lowerCAmelCase__  :						str													=		99





      def 				snake_case__	(       self     )					->				List[str]:
             A__	     =							np.array(
                 [
                     [71, 82, 18, 33, 46, 91, 2],
                     [68, 34, 26, 58, 30, 82, 2],
                     [5, 97, 17, 39, 94, 40, 2],
                     [76, 83, 94, 25, 70, 78, 2],
                     [87, 59, 41, 35, 48, 66, 2],
                     [55, 13, 16, 58, 5, 2, 1],  # note padding
                     [64, 27, 31, 51, 12, 75, 2],
                     [52, 64, 86, 17, 83, 39, 2],
                     [48, 61, 9, 24, 71, 82, 2],
                     [26, 1, 60, 48, 22, 13, 2],
                     [21, 5, 62, 28, 14, 76, 2],
                     [45, 98, 37, 86, 59, 48, 2],
                     [70, 70, 50, 9, 28, 0, 2],
                 ]		,dtype=np.intaa		,)

             A__	     =							input_ids.shape[0]
             A__	     =							BlenderbotConfig(
                 vocab_size=self.vocab_size		,d_model=24		,encoder_layers=2		,decoder_layers=2		,encoder_attention_heads=2		,decoder_attention_heads=2		,encoder_ffn_dim=32		,decoder_ffn_dim=32		,max_position_embeddings=48		,eos_token_id=2		,pad_token_id=1		,bos_token_id=0		,)
             return config, input_ids, batch_size





      def 				snake_case__	(       self     )					->				Union[str, Any]:
             A__     ,  A__     ,  A__	     =							self._get_config_and_data()
             A__	     =							FlaxBlenderbotForConditionalGeneration(lowerCamelCase_     )
             A__	     =							lm_model(input_ids=lowerCamelCase_     )
             A__	     =							(batch_size, input_ids.shape[1], config.vocab_size)
             self.assertEqual(outputs['logits'].shape		,lowerCamelCase_     )





      def 				snake_case__	(       self     )					->				Tuple:
             A__	     =							BlenderbotConfig(
                 vocab_size=self.vocab_size		,d_model=14		,encoder_layers=2		,decoder_layers=2		,encoder_attention_heads=2		,decoder_attention_heads=2		,encoder_ffn_dim=8		,decoder_ffn_dim=8		,max_position_embeddings=48		,)
             A__	     =							FlaxBlenderbotForConditionalGeneration(lowerCamelCase_     )
             A__	     =							np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]		,dtype=np.intaa     )
             A__	     =							np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]		,dtype=np.intaa     )
             A__	     =							lm_model(input_ids=lowerCamelCase_		,decoder_input_ids=lowerCamelCase_     )
             A__	     =							(*summary.shape, config.vocab_size)
             self.assertEqual(outputs['logits'].shape		,lowerCamelCase_     )





      def 				snake_case__	(       self     )					->				List[Any]:
             A__	     =							np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]		,dtype=np.intaa     )
             A__	     =							shift_tokens_right(lowerCamelCase_		,1		,2     )
             A__	     =							np.equal(lowerCamelCase_		,1     ).astype(np.floataa     ).sum()
             A__	     =							np.equal(lowerCamelCase_		,1     ).astype(np.floataa     ).sum()
             self.assertEqual(shifted.shape		,input_ids.shape     )
             self.assertEqual(lowerCamelCase_		,n_pad_before - 1     )
             self.assertTrue(np.equal(shifted[:, 0]		,2     ).all()     )






@require_flax
class     UpperCamelCase__(			a__		,						unittest.TestCase		,						a__ ):
      lowerCAmelCase__  :						Union[str, Any]													=		True
      lowerCAmelCase__  :						Tuple													=		(
          (
              FlaxBlenderbotModel,
              FlaxBlenderbotForConditionalGeneration,
          )
          if is_flax_available()
          else ()
      )
      lowerCAmelCase__  :						str													=		(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()





      def 				snake_case__	(       self     )					->				Optional[Any]:
             A__	     =							FlaxBlenderbotModelTester(self     )





      def 				snake_case__	(       self     )					->				int:
             A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs()
             for model_class in self.all_model_classes:
                    self.model_tester.check_use_cache_forward(lowerCamelCase_		,lowerCamelCase_		,lowerCamelCase_     )





      def 				snake_case__	(       self     )					->				Union[str, Any]:
             A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs()
             for model_class in self.all_model_classes:
                    self.model_tester.check_use_cache_forward_with_attn_mask(lowerCamelCase_		,lowerCamelCase_		,lowerCamelCase_     )





      def 				snake_case__	(       self     )					->				Dict:
             A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    with self.subTest(model_class.__name__     ):
                           A__	     =							self._prepare_for_class(lowerCamelCase_		,lowerCamelCase_     )
                           A__	     =							model_class(lowerCamelCase_     )

                           @jax.jit
                           def encode_jitted(__UpperCAmelCase		,__UpperCAmelCase=None		,**__UpperCAmelCase     ):
                                  return model.encode(input_ids=lowerCamelCase_		,attention_mask=lowerCamelCase_     )

                           with self.subTest('JIT Enabled'     ):
                                  A__	     =							encode_jitted(**lowerCamelCase_     ).to_tuple()

                           with self.subTest('JIT Disabled'     ):
                                  with jax.disable_jit():
                                         A__	     =							encode_jitted(**lowerCamelCase_     ).to_tuple()

                           self.assertEqual(len(lowerCamelCase_     )		,len(lowerCamelCase_     )     )
                           for jitted_output, output in zip(lowerCamelCase_		,lowerCamelCase_     ):
                                  self.assertEqual(jitted_output.shape		,output.shape     )





      def 				snake_case__	(       self     )					->				Union[str, Any]:
             A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    with self.subTest(model_class.__name__     ):
                           A__	     =							model_class(lowerCamelCase_     )
                           A__	     =							model.encode(inputs_dict['input_ids']		,inputs_dict['attention_mask']     )

                           A__	     =							{
                               'decoder_input_ids': inputs_dict['decoder_input_ids'],
                               'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
                               'encoder_outputs': encoder_outputs,
                           }

                           @jax.jit
                           def decode_jitted(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     ):
                                  return model.decode(
                                      decoder_input_ids=lowerCamelCase_		,decoder_attention_mask=lowerCamelCase_		,encoder_outputs=lowerCamelCase_		,)

                           with self.subTest('JIT Enabled'     ):
                                  A__	     =							decode_jitted(**lowerCamelCase_     ).to_tuple()

                           with self.subTest('JIT Disabled'     ):
                                  with jax.disable_jit():
                                         A__	     =							decode_jitted(**lowerCamelCase_     ).to_tuple()

                           self.assertEqual(len(lowerCamelCase_     )		,len(lowerCamelCase_     )     )
                           for jitted_output, output in zip(lowerCamelCase_		,lowerCamelCase_     ):
                                  self.assertEqual(jitted_output.shape		,output.shape     )





      @slow
      def 				snake_case__	(       self     )					->				Union[str, Any]:
             for model_class_name in self.all_model_classes:
                    A__	     =							model_class_name.from_pretrained('facebook/blenderbot-400M-distill'     )
                    # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
                    A__	     =							np.ones((1, 1)     ) * model.config.eos_token_id
                    A__	     =							model(lowerCamelCase_     )
                    self.assertIsNotNone(lowerCamelCase_     )





      @unittest.skipUnless(jax_device != 'cpu'		,'3B test too slow on CPU.'     )
      @slow
      def 				snake_case__	(       self     )					->				Any:
             A__	     =							{'num_beams': 1, 'early_stopping': True, 'min_length': 15, 'max_length': 25}
             A__	     =							{'skip_special_tokens': True, 'clean_up_tokenization_spaces': True}

             A__	     =							FlaxBlenderbotForConditionalGeneration.from_pretrained('facebook/blenderbot-3B'		,from_pt=lowerCamelCase_     )
             A__	     =							BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B'     )

             A__	     =							['Sam']
             A__	     =							tokenizer(lowerCamelCase_		,return_tensors='jax'     )

             A__	     =							model.generate(**lowerCamelCase_		,**lowerCamelCase_     )
             A__	     =							'Sam is a great name. It means "sun" in Gaelic.'

             A__	     =							tokenizer.batch_decode(lowerCamelCase_		,**lowerCamelCase_     )
             assert generated_txt[0].strip() == tgt_text






"""simple docstring"""




from typing import Dict, Optional

import numpy as np

import datasets


__lowerCamelCase											=  "\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"

__lowerCamelCase											=  "\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"

__lowerCamelCase											=  "\\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   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = None       ,    UpperCamelCase__ = False       ,    ):






							"""simple docstring"""





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

    # turn into Numpy arrays
							A__	     =							np.array(UpperCamelCase__				)
							A__	     =							np.array(UpperCamelCase__				)

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

							A__	     =							label != ignore_index
							A__	     =							np.not_equal(UpperCamelCase__       ,    UpperCamelCase__				)
							A__	     =							pred_label[mask]
							A__	     =							np.array(UpperCamelCase__				)[mask]

							A__	     =							pred_label[pred_label == label]

							A__	     =							np.histogram(UpperCamelCase__       ,    bins=UpperCamelCase__       ,    range=(0, num_labels - 1)				)[0]
							A__	     =							np.histogram(UpperCamelCase__       ,    bins=UpperCamelCase__       ,    range=(0, num_labels - 1)				)[0]
							A__	     =							np.histogram(UpperCamelCase__       ,    bins=UpperCamelCase__       ,    range=(0, num_labels - 1)				)[0]

							A__	     =							area_pred_label + area_label - area_intersect

							return area_intersect, area_union, area_pred_label, area_label






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = None       ,    UpperCamelCase__ = False       ,    ):






							"""simple docstring"""





							A__	     =							np.zeros((num_labels,)       ,    dtype=np.floataa				)
							A__	     =							np.zeros((num_labels,)       ,    dtype=np.floataa				)
							A__	     =							np.zeros((num_labels,)       ,    dtype=np.floataa				)
							A__	     =							np.zeros((num_labels,)       ,    dtype=np.floataa				)
							for result, gt_seg_map in zip(UpperCamelCase__       ,    UpperCamelCase__				):
														A__     ,  A__     ,  A__     ,  A__	     =							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   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = None       ,    UpperCamelCase__ = None       ,    UpperCamelCase__ = False       ,    ):






							"""simple docstring"""





							A__     ,  A__     ,  A__     ,  A__	     =							total_intersect_and_union(
							    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				)

							# compute metrics
							A__	     =							{}

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

							A__	     =							np.nanmean(UpperCamelCase__				)
							A__	     =							np.nanmean(UpperCamelCase__				)
							A__	     =							all_acc
							A__	     =							iou
							A__	     =							acc

							if nan_to_num is not None:
														A__	     =							{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     UpperCamelCase__(			datasets.Metric ):





						def 				snake_case__	(       self     )					->				str:
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase = None		,__UpperCAmelCase = None		,__UpperCAmelCase = False		,)					->				Tuple:
													A__	     =							mean_iou(
													    results=__UpperCAmelCase		,gt_seg_maps=__UpperCAmelCase		,num_labels=__UpperCAmelCase		,ignore_index=__UpperCAmelCase		,nan_to_num=__UpperCAmelCase		,label_map=__UpperCAmelCase		,reduce_labels=__UpperCAmelCase		,)
													return iou_result





