



from sklearn.metrics import fa_score

import datasets


_snake_case				=					'\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n'


_snake_case				=					'\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. 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\nReturns:\n    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n    Example 1-A simple binary example\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n        >>> print(results)\n        {\'f1\': 0.5}\n\n    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n        >>> print(round(results[\'f1\'], 2))\n        0.67\n\n    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_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(round(results[\'f1\'], 2))\n        0.35\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 = f1_metric.compute(predictions=predictions, references=references, average="macro")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")\n        >>> print(round(results[\'f1\'], 2))\n        0.33\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n        >>> print(results)\n        {\'f1\': array([0.8, 0. , 0. ])}\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 		lowerCAmelCase_ (			datasets.Metric ):







		"""simple docstring"""
		def 						__lowercase(		self			)     ->  Any:
									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.f1_score.html']     ,    )



		def 						__lowercase(		self     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE=None     ,    _SCREAMING_SNAKE_CASE=1     ,    _SCREAMING_SNAKE_CASE="binary"     ,    _SCREAMING_SNAKE_CASE=None			)     ->  List[str]:
									__UpperCamelCase          =  fa_score(
									    A_     ,    A_     ,    labels=A_     ,    pos_label=A_     ,    average=A_     ,    sample_weight=A_			)
									return {"f1": float(A_			) if score.size == 1 else score}










import inspect
import unittest

from transformers import YolosConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import YolosForObjectDetection, YolosModel
    from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class     snake_case_		:






 '''simple docstring'''





 def __init__(  self,		A_,		A_=13,		A_=[30, 30],		A_=2,		A_=3,		A_=True,		A_=True,		A_=32,		A_=5,		A_=4,		A_=37,		A_="gelu",		A_=0.1,		A_=0.1,		A_=10,		A_=0.02,		A_=3,		A_=None,		A_=8,		A_=10,		)	->       List[str]:
    UpperCAmelCase__						=parent
    UpperCAmelCase__						=batch_size
    UpperCAmelCase__						=image_size
    UpperCAmelCase__						=patch_size
    UpperCAmelCase__						=num_channels
    UpperCAmelCase__						=is_training
    UpperCAmelCase__						=use_labels
    UpperCAmelCase__						=hidden_size
    UpperCAmelCase__						=num_hidden_layers
    UpperCAmelCase__						=num_attention_heads
    UpperCAmelCase__						=intermediate_size
    UpperCAmelCase__						=hidden_act
    UpperCAmelCase__						=hidden_dropout_prob
    UpperCAmelCase__						=attention_probs_dropout_prob
    UpperCAmelCase__						=type_sequence_label_size
    UpperCAmelCase__						=initializer_range
    UpperCAmelCase__						=num_labels
    UpperCAmelCase__						=scope
    UpperCAmelCase__						=n_targets
    UpperCAmelCase__						=num_detection_tokens
    # we set the expected sequence length (which is used in several tests)
    # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
    UpperCAmelCase__						=(image_size[1] // patch_size) * (image_size[0] // patch_size)
    UpperCAmelCase__						=num_patches + 1 + self.num_detection_tokens

 def  __UpperCAmelCase						(  self		)	->       Dict:
    UpperCAmelCase__						=floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]		)

    UpperCAmelCase__						=None
    if self.use_labels:
       # labels is a list of Dict (each Dict being the labels for a given example in the batch)
       UpperCAmelCase__						=[]
       for i in range(self.batch_size		):
          UpperCAmelCase__						={}
          UpperCAmelCase__						=torch.randint(
              high=self.num_labels,		size=(self.n_targets,),		device=A_		)
          UpperCAmelCase__						=torch.rand(self.n_targets,		4,		device=A_		)
          labels.append(A_		)

    UpperCAmelCase__						=self.get_config()

    return config, pixel_values, labels

 def  __UpperCAmelCase						(  self		)	->       Dict:
    return YolosConfig(
        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=A_,		initializer_range=self.initializer_range,		num_detection_tokens=self.num_detection_tokens,		num_labels=self.num_labels,		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       Tuple:
    UpperCAmelCase__						=YolosModel(config=A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_		)
    self.parent.assertEqual(
        result.last_hidden_state.shape,		(self.batch_size, self.expected_seq_len, self.hidden_size)		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       Union[str, Any]:
    UpperCAmelCase__						=YolosForObjectDetection(A_		)
    model.to(A_		)
    model.eval()

    UpperCAmelCase__						=model(pixel_values=A_		)
    UpperCAmelCase__						=model(A_		)

    self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
    self.parent.assertEqual(result.pred_boxes.shape,		(self.batch_size, self.num_detection_tokens, 4)		)

    UpperCAmelCase__						=model(pixel_values=A_,		labels=A_		)

    self.parent.assertEqual(result.loss.shape,		()		)
    self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
    self.parent.assertEqual(result.pred_boxes.shape,		(self.batch_size, self.num_detection_tokens, 4)		)






 def  __UpperCAmelCase						(  self		)	->       Tuple:
    UpperCAmelCase__						=self.prepare_config_and_inputs()
    UpperCAmelCase__			,							UpperCAmelCase__			,							UpperCAmelCase__						=config_and_inputs
    UpperCAmelCase__						={"pixel_values": pixel_values}
    return config, inputs_dict

@require_torch
class     snake_case_		(   a,		a,		unittest.TestCase							):






 '''simple docstring'''





 __UpperCamelCase       =      (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
 __UpperCamelCase       =      (
     {'feature-extraction': YolosModel, 'object-detection': YolosForObjectDetection} if is_torch_available() else {}
 )

 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_=False		)	->       Dict:
    UpperCAmelCase__						=super()._prepare_for_class(A_,		A_,		return_labels=A_		)

    if return_labels:
       if model_class.__name__ == "YolosForObjectDetection":
          UpperCAmelCase__						=[]
          for i in range(self.model_tester.batch_size		):
             UpperCAmelCase__						={}
             UpperCAmelCase__						=torch.ones(
                 size=(self.model_tester.n_targets,),		device=A_,		dtype=torch.long		)
             UpperCAmelCase__						=torch.ones(
                 self.model_tester.n_targets,		4,		device=A_,		dtype=torch.float		)
             labels.append(A_		)
          UpperCAmelCase__						=labels

    return inputs_dict

 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						=YolosModelTester(self		)
    UpperCAmelCase__						=ConfigTester(self,		config_class=A_,		has_text_modality=A_,		hidden_size=37		)

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    self.config_tester.run_common_tests()

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    # YOLOS does not use inputs_embeds
    pass

 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=model_class(A_		)
       self.assertIsInstance(model.get_input_embeddings(),		(nn.Module)		)
       UpperCAmelCase__						=model.get_output_embeddings()
       self.assertTrue(x is None or isinstance(A_,		nn.Linear		)		)

 def  __UpperCAmelCase						(  self		)	->       str:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=model_class(A_		)
       UpperCAmelCase__						=inspect.signature(model.forward		)
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       UpperCAmelCase__						=[*signature.parameters.keys()]

       UpperCAmelCase__						=["pixel_values"]
       self.assertListEqual(arg_names[:1],		A_		)

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*A_		)

 def  __UpperCAmelCase						(  self		)	->       Dict:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase__						=True

    # in YOLOS, the seq_len is different
    UpperCAmelCase__						=self.model_tester.expected_seq_len
    for model_class in self.all_model_classes:
       UpperCAmelCase__						=True
       UpperCAmelCase__						=False
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)
       UpperCAmelCase__						=outputs.attentions
       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)
       UpperCAmelCase__						=outputs.attentions
       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)

       self.assertListEqual(
           list(attentions[0].shape[-3:]		),		[self.model_tester.num_attention_heads, seq_len, seq_len],		)
       UpperCAmelCase__						=len(A_		)

       # Check attention is always last and order is fine
       UpperCAmelCase__						=True
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)

       UpperCAmelCase__						=1
       self.assertEqual(out_len + added_hidden_states,		len(A_		)		)

       UpperCAmelCase__						=outputs.attentions

       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]		),		[self.model_tester.num_attention_heads, seq_len, seq_len],		)

 def  __UpperCAmelCase						(  self		)	->       List[str]:
    def check_hidden_states_output(A_,		A_,		A_		):
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()

       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)

       UpperCAmelCase__						=outputs.hidden_states

       UpperCAmelCase__						=getattr(
           self.model_tester,		"expected_num_hidden_layers",		self.model_tester.num_hidden_layers + 1		)
       self.assertEqual(len(A_		),		A_		)

       # YOLOS has a different seq_length
       UpperCAmelCase__						=self.model_tester.expected_seq_len

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

    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=True
       check_hidden_states_output(A_,		A_,		A_		)

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       UpperCAmelCase__						=True

       check_hidden_states_output(A_,		A_,		A_		)

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_object_detection(*A_		)






 @slow
 def  __UpperCAmelCase						(  self		)	->       Any:
    for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCAmelCase__						=YolosModel.from_pretrained(A_		)
       self.assertIsNotNone(A_		)






def 				_UpperCAmelCase			(    ):




   '''simple docstring'''

   UpperCAmelCase__						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
   return image




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






 '''simple docstring'''





 @cached_property
 def  __UpperCAmelCase						(  self		)	->       Any:
    return AutoImageProcessor.from_pretrained("hustvl/yolos-small"		) if is_vision_available() else None






 @slow
 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						=YolosForObjectDetection.from_pretrained("hustvl/yolos-small"		).to(A_		)

    UpperCAmelCase__						=self.default_image_processor
    UpperCAmelCase__						=prepare_img()
    UpperCAmelCase__						=image_processor(images=A_,		return_tensors="pt"		).to(A_		)

    # forward pass
    with torch.no_grad():
       UpperCAmelCase__						=model(inputs.pixel_values		)

    # verify outputs
    UpperCAmelCase__						=torch.Size((1, 100, 92)		)
    self.assertEqual(outputs.logits.shape,		A_		)

    UpperCAmelCase__						=torch.tensor(
        [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]],		device=A_,		)
    UpperCAmelCase__						=torch.tensor(
        [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]],		device=A_		)
    self.assertTrue(torch.allclose(outputs.logits[0, :3, :3],		A_,		atol=1E-4		)		)
    self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3],		A_,		atol=1E-4		)		)

    # verify postprocessing
    UpperCAmelCase__						=image_processor.post_process_object_detection(
        A_,		threshold=0.3,		target_sizes=[image.size[::-1]]		)[0]
    UpperCAmelCase__						=torch.tensor([0.99_94, 0.97_90, 0.99_64, 0.99_72, 0.98_61]		).to(A_		)
    UpperCAmelCase__						=[75, 75, 17, 63, 17]
    UpperCAmelCase__						=torch.tensor([3_35.06_09, 79.38_48, 3_75.42_16, 1_87.24_95]		).to(A_		)

    self.assertEqual(len(results["scores"]		),		5		)
    self.assertTrue(torch.allclose(results["scores"],		A_,		atol=1E-4		)		)
    self.assertSequenceEqual(results["labels"].tolist(),		A_		)
    self.assertTrue(torch.allclose(results["boxes"][0, :],		A_		)		)



