






from sklearn.metrics import matthews_corrcoef

import datasets


snake_case    				=		"""\nCompute the Matthews correlation coefficient (MCC)\n\nThe Matthews correlation coefficient is used in machine learning as a\nmeasure of the quality of binary and multiclass classifications. It takes\ninto account true and false positives and negatives and is generally\nregarded as a balanced measure which can be used even if the classes are of\nvery different sizes. The MCC is in essence a correlation coefficient value\nbetween -1 and +1. A coefficient of +1 represents a perfect prediction, 0\nan average random prediction and -1 an inverse prediction.  The statistic\nis also known as the phi coefficient. [source: Wikipedia]\n"""

snake_case    				=		"""\nArgs:\n    predictions (list of int): Predicted labels, as returned by a model.\n    references (list of int): Ground truth labels.\n    sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.\nReturns:\n    matthews_correlation (dict containing float): Matthews correlation.\nExamples:\n    Example 1, a basic example with only predictions and references as inputs:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3])\n        >>> print(round(results[\'matthews_correlation\'], 2))\n        0.54\n\n    Example 2, the same example as above, but also including sample weights:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 3, 1, 1, 1, 2])\n        >>> print(round(results[\'matthews_correlation\'], 2))\n        0.1\n\n    Example 3, the same example as above, but with sample weights that cause a negative correlation:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 1, 0, 0, 0, 1])\n        >>> print(round(results[\'matthews_correlation\'], 2))\n        -0.25\n"""

snake_case    				=		"""\\n@article{scikit-learn,\n  title={Scikit-learn: Machine Learning in {P}ython},\n  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n  journal={Journal of Machine Learning Research},\n  volume={12},\n  pages={2825--2830},\n  year={2011}\n}\n"""


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,		_KWARGS_DESCRIPTION					)
class  SCREAMING_SNAKE_CASE			(			datasets.Metric					):
     '''simple docstring'''


     def 				_A       (				self       :	List[str]      ):
       return datasets.MetricInfo(
           description=_DESCRIPTION					, citation=_CITATION					, inputs_description=_KWARGS_DESCRIPTION					, features=datasets.Features(
               {
                   "predictions": datasets.Value("int32"      ),
                   "references": datasets.Value("int32"      ),
               }      )					, reference_urls=[
               "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html"
           ]					, )






     def 				_A       (				self       :	List[Any]					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	List[str]=None      ):
       return {
           "matthews_correlation": float(matthews_corrcoef(UpperCamelCase_					, UpperCamelCase_					, sample_weight=UpperCamelCase_      )      ),
       }














import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


snake_case    				=		logging.get_logger(__name__)

snake_case    				=		{
    """nvidia/segformer-b0-finetuned-ade-512-512""": (
        """https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json"""
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


     UpperCamelCase_							:		str			=	'''segformer'''


     def __init__(				self       :	List[Any]					, UpperCAmelCase_       :	int=3					, UpperCAmelCase_       :	Optional[Any]=4					, UpperCAmelCase_       :	List[str]=[2, 2, 2, 2]					, UpperCAmelCase_       :	Optional[int]=[8, 4, 2, 1]					, UpperCAmelCase_       :	Union[str, Any]=[32, 64, 160, 256]					, UpperCAmelCase_       :	int=[7, 3, 3, 3]					, UpperCAmelCase_       :	str=[4, 2, 2, 2]					, UpperCAmelCase_       :	List[str]=[1, 2, 5, 8]					, UpperCAmelCase_       :	List[Any]=[4, 4, 4, 4]					, UpperCAmelCase_       :	Dict="gelu"					, UpperCAmelCase_       :	Optional[Any]=0.0					, UpperCAmelCase_       :	Optional[Any]=0.0					, UpperCAmelCase_       :	int=0.1					, UpperCAmelCase_       :	List[Any]=0.02					, UpperCAmelCase_       :	Optional[int]=0.1					, UpperCAmelCase_       :	Optional[Any]=1E-6					, UpperCAmelCase_       :	List[str]=256					, UpperCAmelCase_       :	Dict=255					, **UpperCAmelCase_       :	Dict					, ):
       super().__init__(**UpperCAmelCase_      )

       if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
         warnings.warn(
             "Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be"
             " removed, as the behaviour will default to that of reshape_last_stage = True."					, UpperCAmelCase_					, )

       SCREAMING_SNAKE_CASE       :      Dict							=    num_channels
       SCREAMING_SNAKE_CASE       :      Any							=    num_encoder_blocks
       SCREAMING_SNAKE_CASE       :      Tuple							=    depths
       SCREAMING_SNAKE_CASE       :      Any							=    sr_ratios
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    hidden_sizes
       SCREAMING_SNAKE_CASE       :      int							=    patch_sizes
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    strides
       SCREAMING_SNAKE_CASE       :      Tuple							=    mlp_ratios
       SCREAMING_SNAKE_CASE       :      Any							=    num_attention_heads
       SCREAMING_SNAKE_CASE       :      int							=    hidden_act
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    hidden_dropout_prob
       SCREAMING_SNAKE_CASE       :      str							=    attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE       :      Tuple							=    classifier_dropout_prob
       SCREAMING_SNAKE_CASE       :      List[Any]							=    initializer_range
       SCREAMING_SNAKE_CASE       :      Dict							=    drop_path_rate
       SCREAMING_SNAKE_CASE       :      Any							=    layer_norm_eps
       SCREAMING_SNAKE_CASE       :      Any							=    decoder_hidden_size
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    kwargs.get("reshape_last_stage"					, UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    semantic_loss_ignore_index





class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Dict			=	version.parse('''1.11'''					)


     @property
     def 				_A       (				self       :	Optional[Any]      ):
       return OrderedDict(
           [
               ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
           ]      )


     @property
     def 				_A       (				self       :	List[str]      ):
       return 1E-4






     @property
     def 				_A       (				self       :	Any      ):
       return 12






