



"""simple docstring"""







import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    EfficientFormerForImageClassification,
		    EfficientFormerForImageClassificationWithTeacher,
		    EfficientFormerModel,
		)
		from transformers.models.efficientformer.modeling_efficientformer import (
		    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		)


if is_vision_available():
		from PIL import Image

		from transformers import EfficientFormerImageProcessor





class    UpperCamelCase     :




	"""simple docstring"""






	def __init__(			self							,UpperCAmelCase_							,UpperCAmelCase_ = 13							,UpperCAmelCase_ = 64							,UpperCAmelCase_ = 2							,UpperCAmelCase_ = 3							,UpperCAmelCase_ = 3							,UpperCAmelCase_ = True							,UpperCAmelCase_ = True							,UpperCAmelCase_ = 1_28							,UpperCAmelCase_=[16, 32, 64, 1_28]							,UpperCAmelCase_ = 7							,UpperCAmelCase_ = 4							,UpperCAmelCase_ = 37							,UpperCAmelCase_ = "gelu"							,UpperCAmelCase_ = 0.1							,UpperCAmelCase_ = 0.1							,UpperCAmelCase_ = 10							,UpperCAmelCase_ = 0.02							,UpperCAmelCase_ = 2							,UpperCAmelCase_ = 1							,UpperCAmelCase_ = 1_28							,UpperCAmelCase_ = [2, 2, 2, 2]							,UpperCAmelCase_ = 2							,UpperCAmelCase_ = 2							,):
			_lowercase							:      Optional[int]			=					parent
			_lowercase							:      List[str]			=					batch_size
			_lowercase							:      Optional[int]			=					image_size
			_lowercase							:      Optional[Any]			=					patch_size
			_lowercase							:      List[Any]			=					num_channels
			_lowercase							:      Union[str, Any]			=					is_training
			_lowercase							:      int			=					use_labels
			_lowercase							:      Optional[int]			=					hidden_size
			_lowercase							:      str			=					num_hidden_layers
			_lowercase							:      List[str]			=					num_attention_heads
			_lowercase							:      Tuple			=					intermediate_size
			_lowercase							:      str			=					hidden_act
			_lowercase							:      str			=					hidden_dropout_prob
			_lowercase							:      Any			=					attention_probs_dropout_prob
			_lowercase							:      Dict			=					type_sequence_label_size
			_lowercase							:      Optional[Any]			=					initializer_range
			_lowercase							:      Optional[int]			=					encoder_stride
			_lowercase							:      Tuple			=					num_attention_outputs
			_lowercase							:      str			=					embed_dim
			_lowercase							:      Any			=					embed_dim + 1
			_lowercase							:      Union[str, Any]			=					resolution
			_lowercase							:      Tuple			=					depths
			_lowercase							:      Dict			=					hidden_sizes
			_lowercase							:      str			=					dim
			_lowercase							:      Union[str, Any]			=					mlp_expansion_ratio






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      int			=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

			_lowercase							:      Any			=					None
			if self.use_labels:
					_lowercase							:      Tuple			=					ids_tensor([self.batch_size]							,self.type_sequence_label_size					)

			_lowercase							:      str			=					self.get_config()
			return config, pixel_values, labels






	def 					lowerCamelCase__ (			self					):
			return EfficientFormerConfig(
			    image_size=self.image_size							,patch_size=self.patch_size							,num_channels=self.num_channels							,hidden_size=self.hidden_size							,num_hidden_layers=self.num_hidden_layers							,num_attention_heads=self.num_attention_heads							,intermediate_size=self.intermediate_size							,hidden_act=self.hidden_act							,hidden_dropout_prob=self.hidden_dropout_prob							,attention_probs_dropout_prob=self.attention_probs_dropout_prob							,is_decoder=UpperCAmelCase_							,initializer_range=self.initializer_range							,encoder_stride=self.encoder_stride							,resolution=self.resolution							,depths=self.depths							,hidden_sizes=self.hidden_sizes							,dim=self.dim							,mlp_expansion_ratio=self.mlp_expansion_ratio							,)






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      List[Any]			=					EfficientFormerModel(config=UpperCAmelCase_					)
			model.to(UpperCAmelCase_					)
			model.eval()
			_lowercase							:      Any			=					model(UpperCAmelCase_					)
			self.parent.assertEqual(result.last_hidden_state.shape							,(self.batch_size, self.seq_length, self.hidden_size)					)






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      Tuple			=					self.type_sequence_label_size
			_lowercase							:      Any			=					EfficientFormerForImageClassification(UpperCAmelCase_					)
			model.to(UpperCAmelCase_					)
			model.eval()
			_lowercase							:      Dict			=					model(UpperCAmelCase_							,labels=UpperCAmelCase_					)
			self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.type_sequence_label_size)					)

			# test greyscale images
			_lowercase							:      List[str]			=					1
			_lowercase							:      Any			=					EfficientFormerForImageClassification(UpperCAmelCase_					)
			model.to(UpperCAmelCase_					)
			model.eval()

			_lowercase							:      Optional[Any]			=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
			_lowercase							:      Optional[Any]			=					model(UpperCAmelCase_					)
			self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.type_sequence_label_size)					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Dict			=					self.prepare_config_and_inputs()
			(
			    (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   (
			    _lowercase
			)			,   
			)							:      Tuple			=					config_and_inputs
			_lowercase							:      Dict			=					{"""pixel_values""": pixel_values}
			return config, inputs_dict







@require_torch
class    UpperCamelCase     (			snake_case ,					snake_case ,					unittest.TestCase    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Optional[Any]		    =   (
	    (
	        EfficientFormerModel,
	        EfficientFormerForImageClassificationWithTeacher,
	        EfficientFormerForImageClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE_				:    str		    =   (
	    {
	        "feature-extraction": EfficientFormerModel,
	        "image-classification": (
	            EfficientFormerForImageClassification,
	            EfficientFormerForImageClassificationWithTeacher,
	        ),
	    }
	    if is_torch_available()
	    else {}
	)
	SCREAMING_SNAKE_CASE_				:    List[str]		    =   False

	SCREAMING_SNAKE_CASE_				:    Dict		    =   False
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   False
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   False






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Optional[int]			=					EfficientFormerModelTester(self					)
			_lowercase							:      Union[str, Any]			=					ConfigTester(
			    self							,config_class=UpperCAmelCase_							,has_text_modality=UpperCAmelCase_							,hidden_size=37					)






	def 					lowerCamelCase__ (			self					):
			self.config_tester.run_common_tests()






	@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""					)
	def 					lowerCamelCase__ (			self					):
			pass






	@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""					)
	def 					lowerCamelCase__ (			self					):
			pass






	def 					lowerCamelCase__ (			self					):
			_lowercase			,   _lowercase							:      int			=					self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					_lowercase							:      List[str]			=					model_class(UpperCAmelCase_					)
					_lowercase							:      Optional[Any]			=					inspect.signature(model.forward					)
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					_lowercase							:      str			=					[*signature.parameters.keys()]

					_lowercase							:      List[Any]			=					["""pixel_values"""]
					self.assertListEqual(arg_names[:1]							,UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			def check_hidden_states_output(UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
					_lowercase							:      Union[str, Any]			=					model_class(UpperCAmelCase_					)
					model.to(UpperCAmelCase_					)
					model.eval()

					with torch.no_grad():
							_lowercase							:      List[str]			=					model(**self._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_					)					)

					_lowercase							:      Union[str, Any]			=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

					_lowercase							:      Any			=					getattr(
					    self.model_tester							,"""expected_num_hidden_layers"""							,self.model_tester.num_hidden_layers + 1					)
					self.assertEqual(len(UpperCAmelCase_					)							,UpperCAmelCase_					)

					if hasattr(self.model_tester							,"""encoder_seq_length"""					):
							_lowercase							:      List[Any]			=					self.model_tester.encoder_seq_length
							if hasattr(self.model_tester							,"""chunk_length"""					) and self.model_tester.chunk_length > 1:
									_lowercase							:      Optional[Any]			=					seq_length * self.model_tester.chunk_length
					else:
							_lowercase							:      Dict			=					self.model_tester.seq_length

					self.assertListEqual(
					    list(hidden_states[-1].shape[-2:]					)							,[seq_length, self.model_tester.hidden_size]							,)

					if config.is_encoder_decoder:
							_lowercase							:      Tuple			=					outputs.decoder_hidden_states

							self.assertIsInstance(UpperCAmelCase_							,(list, tuple)					)
							self.assertEqual(len(UpperCAmelCase_					)							,UpperCAmelCase_					)
							_lowercase							:      List[Any]			=					getattr(self.model_tester							,"""seq_length"""							,UpperCAmelCase_					)
							_lowercase							:      Optional[int]			=					getattr(self.model_tester							,"""decoder_seq_length"""							,UpperCAmelCase_					)

							self.assertListEqual(
							    list(hidden_states[-1].shape[-2:]					)							,[decoder_seq_length, self.model_tester.hidden_size]							,)

			_lowercase			,   _lowercase							:      List[Any]			=					self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					_lowercase							:      List[Any]			=					True
					check_hidden_states_output(UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					_lowercase							:      Optional[int]			=					True

					check_hidden_states_output(UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_=False					):
			_lowercase							:      Optional[Any]			=					super()._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_							,return_labels=UpperCAmelCase_					)

			if return_labels:
					if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
							del inputs_dict["labels"]

			return inputs_dict






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      List[Any]			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*UpperCAmelCase_					)






	@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""					)
	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Tuple			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Dict			=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			if not self.model_tester.is_training:
					return

			_lowercase			,   _lowercase							:      Optional[Any]			=					self.model_tester.prepare_config_and_inputs_for_common()
			_lowercase							:      str			=					True

			for model_class in self.all_model_classes:
					# EfficientFormerForImageClassificationWithTeacher supports inference-only
					if (
					    model_class in get_values(UpperCAmelCase_					)
					    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
					):
							continue
					_lowercase							:      Union[str, Any]			=					model_class(UpperCAmelCase_					)
					model.to(UpperCAmelCase_					)
					model.train()
					_lowercase							:      List[str]			=					self._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_							,return_labels=UpperCAmelCase_					)
					_lowercase							:      Tuple			=					model(**UpperCAmelCase_					).loss
					loss.backward()






	def 					lowerCamelCase__ (			self					):
			_lowercase			,   _lowercase							:      Any			=					self.model_tester.prepare_config_and_inputs_for_common()

			_lowercase							:      Tuple			=					[
			    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
			    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
			    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
			]

			for model_class in self.all_model_classes:
					if (
					    model_class
					    not in [
					        *get_values(UpperCAmelCase_					),
					    ]
					    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
					):
							continue

					for problem_type in problem_types:
							with self.subTest(msg=f"""Testing {model_class} with {problem_type["title"]}"""					):
									_lowercase							:      Union[str, Any]			=					problem_type["""title"""]
									_lowercase							:      List[Any]			=					problem_type["""num_labels"""]

									_lowercase							:      List[str]			=					model_class(UpperCAmelCase_					)
									model.to(UpperCAmelCase_					)
									model.train()

									_lowercase							:      Tuple			=					self._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_							,return_labels=UpperCAmelCase_					)

									if problem_type["num_labels"] > 1:
											_lowercase							:      List[str]			=					inputs["""labels"""].unsqueeze(1					).repeat(1							,problem_type["""num_labels"""]					)

									_lowercase							:      int			=					inputs["""labels"""].to(problem_type["""dtype"""]					)

									# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
									# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
									# they have the same size." which is a symptom something in wrong for the regression problem.
									# See https://github.com/huggingface/transformers/issues/11780
									with warnings.catch_warnings(record=UpperCAmelCase_					) as warning_list:
											_lowercase							:      List[Any]			=					model(**UpperCAmelCase_					).loss
									for w in warning_list:
											if "Using a target size that is different to the input size" in str(w.message					):
													raise ValueError(
													    f"""Something is going wrong in the regression problem: intercepted {w.message}"""					)

									loss.backward()






	@slow
	def 					lowerCamelCase__ (			self					):
			for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowercase							:      Union[str, Any]			=					EfficientFormerModel.from_pretrained(UpperCAmelCase_					)
					self.assertIsNotNone(UpperCAmelCase_					)






	def 					lowerCamelCase__ (			self					):
			_lowercase			,   _lowercase							:      Optional[int]			=					self.model_tester.prepare_config_and_inputs_for_common()
			_lowercase							:      Union[str, Any]			=					True

			_lowercase							:      List[str]			=					getattr(self.model_tester							,"""seq_length"""							,UpperCAmelCase_					)
			_lowercase							:      str			=					getattr(self.model_tester							,"""encoder_seq_length"""							,UpperCAmelCase_					)
			_lowercase							:      List[str]			=					getattr(self.model_tester							,"""key_length"""							,UpperCAmelCase_					)
			_lowercase							:      List[Any]			=					getattr(self.model_tester							,"""chunk_length"""							,UpperCAmelCase_					)

			if chunk_length is not None and hasattr(self.model_tester							,"""num_hashes"""					):
					_lowercase							:      List[str]			=					encoder_seq_length * self.model_tester.num_hashes

			for model_class in self.all_model_classes:
					_lowercase							:      Any			=					True
					_lowercase							:      List[Any]			=					False
					_lowercase							:      Optional[int]			=					True
					_lowercase							:      str			=					model_class(UpperCAmelCase_					)
					model.to(UpperCAmelCase_					)
					model.eval()
					with torch.no_grad():
							_lowercase							:      List[str]			=					model(**self._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_					)					)
					_lowercase							:      Tuple			=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
					self.assertEqual(len(UpperCAmelCase_					)							,self.model_tester.num_attention_outputs					)

					# check that output_attentions also work using config
					del inputs_dict["output_attentions"]
					_lowercase							:      Dict			=					True
					_lowercase							:      Optional[int]			=					model_class(UpperCAmelCase_					)
					model.to(UpperCAmelCase_					)
					model.eval()
					with torch.no_grad():
							_lowercase							:      Any			=					model(**self._prepare_for_class(UpperCAmelCase_							,UpperCAmelCase_					)					)
					_lowercase							:      str			=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
					self.assertEqual(len(UpperCAmelCase_					)							,self.model_tester.num_attention_outputs					)

					if chunk_length is not None:
							self.assertListEqual(
							    list(attentions[0].shape[-4:]					)							,[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]							,)
					else:
							self.assertListEqual(
							    list(attentions[0].shape[-3:]					)							,[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]							,)







def       __SCREAMING_SNAKE_CASE      (   ):
		_lowercase							:      Optional[int]			=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
		return image





@require_torch
@require_vision
class    UpperCamelCase     (			unittest.TestCase    ):




	"""simple docstring"""






	@cached_property
	def 					lowerCamelCase__ (			self					):
			return (
			    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""					)
			    if is_vision_available()
			    else None
			)






	@slow
	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Union[str, Any]			=					EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""					).to(
			    UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					self.default_image_processor
			_lowercase							:      List[str]			=					prepare_img()
			_lowercase							:      str			=					image_processor(images=UpperCAmelCase_							,return_tensors="""pt"""					).to(UpperCAmelCase_					)

			# forward pass
			with torch.no_grad():
					_lowercase							:      int			=					model(**UpperCAmelCase_					)

			# verify the logits
			_lowercase							:      List[str]			=					(1, 10_00)
			self.assertEqual(outputs.logits.shape							,UpperCAmelCase_					)

			_lowercase							:      Tuple			=					torch.tensor([-0.0555, 0.4825, -0.0852]					).to(UpperCAmelCase_					)
			self.assertTrue(torch.allclose(outputs.logits[0][:3]							,UpperCAmelCase_							,atol=1E-4					)					)






	@slow
	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Optional[Any]			=					EfficientFormerForImageClassificationWithTeacher.from_pretrained(
			    """snap-research/efficientformer-l1-300"""					).to(UpperCAmelCase_					)

			_lowercase							:      List[str]			=					self.default_image_processor
			_lowercase							:      Optional[int]			=					prepare_img()
			_lowercase							:      Dict			=					image_processor(images=UpperCAmelCase_							,return_tensors="""pt"""					).to(UpperCAmelCase_					)

			# forward pass
			with torch.no_grad():
					_lowercase							:      List[str]			=					model(**UpperCAmelCase_					)

			# verify the logits
			_lowercase							:      str			=					(1, 10_00)
			self.assertEqual(outputs.logits.shape							,UpperCAmelCase_					)

			_lowercase							:      List[str]			=					torch.tensor([-0.1312, 0.4353, -1.0499]					).to(UpperCAmelCase_					)
			self.assertTrue(torch.allclose(outputs.logits[0][:3]							,UpperCAmelCase_							,atol=1E-4					)					)








"""simple docstring"""







from sklearn.metrics import precision_score

import datasets


UpperCAmelCase:   Optional[Any]       			=							"""
Precision 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:
Precision = TP / (TP + FP)
where 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).
"""


UpperCAmelCase:   Union[str, Any]       			=							"""
Args:
    predictions (`list` of `int`): Predicted class labels.
    references (`list` of `int`): Actual class labels.
    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.
    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
    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'`.

        - '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.
        - 'micro': Calculate metrics globally by counting the total true positives, false negatives and false positives.
        - 'macro': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
        - '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.
        - 'samples': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
    sample_weight (`list` of `float`): Sample weights Defaults to None.
    zero_division (`int` or `string`): Sets the value to return when there is a zero division. Defaults to 'warn'.

        - 0: Returns 0 when there is a zero division.
        - 1: Returns 1 when there is a zero division.
        - 'warn': Raises warnings and then returns 0 when there is a zero division.

Returns:
    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.

Examples:

    Example 1-A simple binary example
        >>> precision_metric = datasets.load_metric(\"precision\")
        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
        >>> print(results)
        {'precision': 0.5}

    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
        >>> precision_metric = datasets.load_metric(\"precision\")
        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
        >>> print(round(results['precision'], 2))
        0.67

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> precision_metric = datasets.load_metric(\"precision\")
        >>> 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])
        >>> print(results)
        {'precision': 0.23529411764705882}

    Example 4-A multiclass example, with different values for the `average` input.
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = precision_metric.compute(predictions=predictions, references=references, average='macro')
        >>> print(results)
        {'precision': 0.2222222222222222}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average='micro')
        >>> print(results)
        {'precision': 0.3333333333333333}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average='weighted')
        >>> print(results)
        {'precision': 0.2222222222222222}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average=None)
        >>> print([round(res, 2) for res in results['precision']])
        [0.67, 0.0, 0.0]
"""


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





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




	"""simple docstring"""






	def 					lowerCamelCase__ (			self					):
			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 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_=None							,UpperCAmelCase_=1							,UpperCAmelCase_="binary"							,UpperCAmelCase_=None							,UpperCAmelCase_="warn"							,):
			_lowercase							:      int			=					precision_score(
			    UpperCAmelCase_							,UpperCAmelCase_							,labels=UpperCAmelCase_							,pos_label=UpperCAmelCase_							,average=UpperCAmelCase_							,sample_weight=UpperCAmelCase_							,zero_division=UpperCAmelCase_							,)
			return {"precision": float(UpperCAmelCase_					) if score.size == 1 else score}



