from sklearn.metrics import precision_score

import datasets


_lowerCAmelCase        =       '\nPrecision is the fraction of correctly labeled positive examples out of all of the examples that were labeled as positive. It is computed via the equation:\nPrecision = TP / (TP + FP)\nwhere TP is the True positives (i.e. the examples correctly labeled as positive) and FP is the False positive examples (i.e. the examples incorrectly labeled as positive).\n'


_lowerCAmelCase        =       '\nArgs:\n    predictions (`list` of `int`): Predicted class labels.\n    references (`list` of `int`): Actual class labels.\n    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`. If `average` is `None`, it should be the label order. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n    zero_division (`int` or `string`): Sets the value to return when there is a zero division. Defaults to \'warn\'.\n\n        - 0: Returns 0 when there is a zero division.\n        - 1: Returns 1 when there is a zero division.\n        - \'warn\': Raises warnings and then returns 0 when there is a zero division.\n\nReturns:\n    precision (`float` or `array` of `float`): Precision score or list of precision scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate that fewer negative examples were incorrectly labeled as positive, which means that, generally, higher scores are better.\n\nExamples:\n\n    Example 1-A simple binary example\n        >>> precision_metric = datasets.load_metric("precision")\n        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n        >>> print(results)\n        {\'precision\': 0.5}\n\n    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n        >>> precision_metric = datasets.load_metric("precision")\n        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n        >>> print(round(results[\'precision\'], 2))\n        0.67\n\n    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n        >>> precision_metric = datasets.load_metric("precision")\n        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n        >>> print(results)\n        {\'precision\': 0.23529411764705882}\n\n    Example 4-A multiclass example, with different values for the `average` input.\n        >>> predictions = [0, 2, 1, 0, 0, 1]\n        >>> references = [0, 1, 2, 0, 1, 2]\n        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'macro\')\n        >>> print(results)\n        {\'precision\': 0.2222222222222222}\n        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'micro\')\n        >>> print(results)\n        {\'precision\': 0.3333333333333333}\n        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'weighted\')\n        >>> print(results)\n        {\'precision\': 0.2222222222222222}\n        >>> results = precision_metric.compute(predictions=predictions, references=references, average=None)\n        >>> print([round(res, 2) for res in results[\'precision\']])\n        [0.67, 0.0, 0.0]\n'


_lowerCAmelCase        =       '\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     __UpperCAmelCase(    datasets.Metric				):






 """simple docstring"""




 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

        return datasets.MetricInfo(
            description=_DESCRIPTION ,       citation=_CITATION ,       inputs_description=_KWARGS_DESCRIPTION ,       features=datasets.Features(
                {
                    '''predictions''': datasets.Sequence(datasets.Value('''int32'''      )      ),
                    '''references''': datasets.Sequence(datasets.Value('''int32'''      )      ),
                }
                if self.config_name == '''multilabel'''
                else {
                    '''predictions''': datasets.Value('''int32'''      ),
                    '''references''': datasets.Value('''int32'''      ),
                }      ) ,       reference_urls=['''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html'''] ,       )
 def  UpperCAmelCase   (    self ,       __magic_name__ ,       __magic_name__ ,       __magic_name__=None ,       __magic_name__=1 ,       __magic_name__="binary" ,       __magic_name__=None ,       __magic_name__="warn" ,       ):

        """simple docstring"""

        A_							:       Tuple	      =				precision_score(
            __magic_name__ ,       __magic_name__ ,       labels=__magic_name__ ,       pos_label=__magic_name__ ,       average=__magic_name__ ,       sample_weight=__magic_name__ ,       zero_division=__magic_name__ ,       )
        return {"precision": float(__magic_name__      ) if score.size == 1 else score}



import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
    import torch_xla.core.xla_model as xm  # noqa: F401

    _lowerCAmelCase        =       True
except ImportError:
    _lowerCAmelCase        =       False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_lowerCAmelCase        =       torch.distributed.is_available()


def       a__      (					a							)		->	Optional[Any]:
       # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
       A_							:       str	      =				importlib.util.find_spec(a							) is not None
       if package_exists:
              try:
                     A_							:       str	      =				importlib.metadata.metadata(a							)
                     return True
              except importlib.metadata.PackageNotFoundError:
                     return False


def       a__      (					)		->	bool:
       return _torch_distributed_available


def       a__      (					)		->	int:
       try:
              pass
       except ImportError:
              print(
                  '''Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not'''
                  ''' detected. If you see \"ValueError: Invalid backend: \'ccl\'\" error, please install Intel(R) oneCCL'''
                  ''' Bindings for PyTorch*.'''							)
       return (
           importlib.util.find_spec('''torch_ccl'''							) is not None
           or importlib.util.find_spec('''oneccl_bindings_for_pytorch'''							) is not None
       )


def       a__      (					)		->	List[str]:
       return importlib.metadata.version('''oneccl_bind_pt'''							)


def       a__      (					)		->	List[str]:
       return _is_package_available('''transformer_engine'''							)


@lru_cache
def       a__      (					a=True							)		->	Union[str, Any]:
       # Due to bugs on the amp series GPUs, we disable torch-xla on them
       if torch.cuda.is_available():
              return False
       if _tpu_available and check_device:
              try:
                     # Will raise a RuntimeError if no XLA configuration is found
                     A_							:       Tuple	      =				xm.xla_device()
                     return True
              except RuntimeError:
                     return False
       return _tpu_available


def       a__      (					)		->	Dict:
       return _is_package_available('''deepspeed'''							)


def       a__      (					a=False							)		->	Optional[int]:
       if is_tpu_available():
              return not ignore_tpu
       if torch.cuda.is_available():
              return torch.cuda.is_bfaa_supported()
       if is_npu_available():
              return False
       return True


def       a__      (					)		->	Optional[Any]:
       A_							:       Optional[int]	      =				_is_package_available('''bitsandbytes'''							)
       if package_exists:
              A_							:       Any	      =				version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
              return compare_versions(a  ,   '''>='''  ,   '''0.39.0'''							)
       return False


def       a__      (					)		->	Any:
       A_							:       List[str]	      =				_is_package_available('''bitsandbytes'''							)
       if package_exists:
              A_							:       Tuple	      =				version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
              return compare_versions(a  ,   '''>='''  ,   '''0.37.2'''							)
       return False


def       a__      (					)		->	List[str]:
       return _is_package_available('''bitsandbytes'''							)


def       a__      (					)		->	List[str]:
       if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''  ,   '''False'''							)							) == 1:
              A_							:       str	      =				importlib.util.find_spec('''megatron'''							) is not None
              if package_exists:
                     try:
                            A_							:       Dict	      =				parse(importlib.metadata.version('''megatron-lm'''							)							)
                            return compare_versions(a  ,   '''>='''  ,   '''2.2.0'''							)
                     except Exception as e:
                            warnings.warn(f"""Parse Megatron version failed. Exception:{e}"""							)
                            return False


def       a__      (					)		->	Tuple:
       return _is_package_available('''safetensors'''							)


def       a__      (					)		->	Tuple:
       return _is_package_available('''transformers'''							)


def       a__      (					)		->	int:
       return _is_package_available('''datasets'''							)


def       a__      (					)		->	Optional[int]:
       return _is_package_available('''aim'''							)


def       a__      (					)		->	Optional[Any]:
       return _is_package_available('''tensorboard'''							) or _is_package_available('''tensorboardX'''							)


def       a__      (					)		->	Optional[int]:
       return _is_package_available('''wandb'''							)


def       a__      (					)		->	Tuple:
       return _is_package_available('''comet_ml'''							)


def       a__      (					)		->	Tuple:
       return _is_package_available('''boto3'''							)


def       a__      (					)		->	Tuple:
       if _is_package_available('''rich'''							):
              if "ACCELERATE_DISABLE_RICH" in os.environ:
                     warnings.warn(
                         '''`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`.'''							)
                     return not parse_flag_from_env('''ACCELERATE_DISABLE_RICH'''  ,   a							)
              return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''  ,   a							)
       return False


def       a__      (					)		->	Any:
       return _is_package_available('''sagemaker'''							)


def       a__      (					)		->	Union[str, Any]:
       return _is_package_available('''tqdm'''							)


def       a__      (					)		->	List[str]:
       return _is_package_available('''mlflow'''							)


def       a__      (					)		->	Tuple:
       return is_torch_version('''>='''  ,   '''1.12'''							) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def       a__      (					)		->	Tuple:
       def get_major_and_minor_from_version(a							):
              return str(version.parse(a							).major							) + "." + str(version.parse(a							).minor							)

       A_							:       Tuple	      =				importlib.metadata.version('''torch'''							)
       if importlib.util.find_spec('''intel_extension_for_pytorch'''							) is None:
              return False
       A_							:       Optional[int]	      =				'''N/A'''
       try:
              A_							:       List[Any]	      =				importlib.metadata.version('''intel_extension_for_pytorch'''							)
       except importlib.metadata.PackageNotFoundError:
              return False
       A_							:       Tuple	      =				get_major_and_minor_from_version(_torch_version							)
       A_							:       int	      =				get_major_and_minor_from_version(_ipex_version							)
       if torch_major_and_minor != ipex_major_and_minor:
              warnings.warn(
                  f"""Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"""
                  f""" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."""							)
              return False
       return True


@lru_cache
def       a__      (					a=False							)		->	Optional[int]:
       if importlib.util.find_spec('''torch'''							) is None or importlib.util.find_spec('''torch_npu'''							) is None:
              return False

       import torch
       import torch_npu  # noqa: F401

       if check_device:
              try:
                     # Will raise a RuntimeError if no NPU is found
                     A_							:       Dict	      =				torch.npu.device_count()
                     return torch.npu.is_available()
              except RuntimeError:
                     return False
       return hasattr(a  ,   '''npu'''							) and torch.npu.is_available()


@lru_cache
def       a__      (					a=False							)		->	Optional[Any]:
       if not parse_flag_from_env('''ACCELERATE_USE_XPU'''  ,   default=a							):
              return False
       if is_ipex_available():
              import torch

              if is_torch_version('''<='''  ,   '''1.12'''							):
                     return False
       else:
              return False

       import intel_extension_for_pytorch  # noqa: F401

       if check_device:
              try:
                     # Will raise a RuntimeError if no XPU  is found
                     A_							:       Tuple	      =				torch.xpu.device_count()
                     return torch.xpu.is_available()
              except RuntimeError:
                     return False
       return hasattr(a  ,   '''xpu'''							) and torch.xpu.is_available()


