






"""simple docstring"""





from sklearn.metrics import fa_score

import datasets


_SCREAMING_SNAKE_CASE   :							List[str]          =		'''
The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
F1 = 2 * (precision * recall) / (precision + recall)
'''


_SCREAMING_SNAKE_CASE   :							Union[str, Any]          =		'''
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    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.
    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.

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

Examples:

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

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

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> f1_metric = datasets.load_metric("f1")
        >>> 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])
        >>> print(round(results[\'f1\'], 2))
        0.35

    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 = f1_metric.compute(predictions=predictions, references=references, average="macro")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
        >>> print(round(results[\'f1\'], 2))
        0.33
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {\'f1\': array([0.8, 0. , 0. ])}
'''


_SCREAMING_SNAKE_CASE   :							int          =		'''
@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 	a		(   datasets.Metric						):






    def   UpperCamelCase			(			self	:				List[str]   )	->						Optional[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   UpperCamelCase			(			self	:				Optional[Any]			,		__SCREAMING_SNAKE_CASE	:				Union[str, Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]			,		__SCREAMING_SNAKE_CASE	:				Any=None			,		__SCREAMING_SNAKE_CASE	:				Tuple=1			,		__SCREAMING_SNAKE_CASE	:				List[str]="binary"			,		__SCREAMING_SNAKE_CASE	:				int=None   )	->						Tuple:
      lowerCamelCase_       	=		fa_score(
          __SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE			,		labels=__SCREAMING_SNAKE_CASE			,		pos_label=__SCREAMING_SNAKE_CASE			,		average=__SCREAMING_SNAKE_CASE			,		sample_weight=__SCREAMING_SNAKE_CASE   )
      return {"f1": float(__SCREAMING_SNAKE_CASE   ) if score.size == 1 else score}












"""simple docstring"""





import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 torch import nn

  from transformers import RegNetForImageClassification, RegNetModel
  from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class 	a		:






    def __init__(			self	:				Union[str, Any]			,		__SCREAMING_SNAKE_CASE	:				str			,		__SCREAMING_SNAKE_CASE	:				List[str]=3			,		__SCREAMING_SNAKE_CASE	:				Optional[int]=32			,		__SCREAMING_SNAKE_CASE	:				int=3			,		__SCREAMING_SNAKE_CASE	:				str=10			,		__SCREAMING_SNAKE_CASE	:				Optional[Any]=[10, 20, 30, 40]			,		__SCREAMING_SNAKE_CASE	:				List[Any]=[1, 1, 2, 1]			,		__SCREAMING_SNAKE_CASE	:				List[str]=True			,		__SCREAMING_SNAKE_CASE	:				Tuple=True			,		__SCREAMING_SNAKE_CASE	:				Optional[int]="relu"			,		__SCREAMING_SNAKE_CASE	:				Tuple=3			,		__SCREAMING_SNAKE_CASE	:				Dict=None			,		)	->						Optional[int]:
      lowerCamelCase_       	=		parent
      lowerCamelCase_       	=		batch_size
      lowerCamelCase_       	=		image_size
      lowerCamelCase_       	=		num_channels
      lowerCamelCase_       	=		embeddings_size
      lowerCamelCase_       	=		hidden_sizes
      lowerCamelCase_       	=		depths
      lowerCamelCase_       	=		is_training
      lowerCamelCase_       	=		use_labels
      lowerCamelCase_       	=		hidden_act
      lowerCamelCase_       	=		num_labels
      lowerCamelCase_       	=		scope
      lowerCamelCase_       	=		len(__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				List[Any]   )	->						Dict:
      lowerCamelCase_       	=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

      lowerCamelCase_       	=		None
      if self.use_labels:
        lowerCamelCase_       	=		ids_tensor([self.batch_size]			,		self.num_labels   )

      lowerCamelCase_       	=		self.get_config()

      return config, pixel_values, labels






    def   UpperCamelCase			(			self	:				List[str]   )	->						str:
      return RegNetConfig(
          num_channels=self.num_channels			,		embeddings_size=self.embeddings_size			,		hidden_sizes=self.hidden_sizes			,		depths=self.depths			,		hidden_act=self.hidden_act			,		num_labels=self.num_labels			,		)






    def   UpperCamelCase			(			self	:				Optional[Any]			,		__SCREAMING_SNAKE_CASE	:				Union[str, Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]			,		__SCREAMING_SNAKE_CASE	:				int   )	->						List[Any]:
      lowerCamelCase_       	=		RegNetModel(config=__SCREAMING_SNAKE_CASE   )
      model.to(__SCREAMING_SNAKE_CASE   )
      model.eval()
      lowerCamelCase_       	=		model(__SCREAMING_SNAKE_CASE   )
      # expected last hidden states: B, C, H // 32, W // 32
      self.parent.assertEqual(
          result.last_hidden_state.shape			,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,		)






    def   UpperCamelCase			(			self	:				List[Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]   )	->						Union[str, Any]:
      lowerCamelCase_       	=		self.num_labels
      lowerCamelCase_       	=		RegNetForImageClassification(__SCREAMING_SNAKE_CASE   )
      model.to(__SCREAMING_SNAKE_CASE   )
      model.eval()
      lowerCamelCase_       	=		model(__SCREAMING_SNAKE_CASE			,		labels=__SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape			,		(self.batch_size, self.num_labels)   )






    def   UpperCamelCase			(			self	:				Optional[Any]   )	->						str:
      lowerCamelCase_       	=		self.prepare_config_and_inputs()
      lowerCamelCase_	,      lowerCamelCase_	,      lowerCamelCase_       	=		config_and_inputs
      lowerCamelCase_       	=		{'pixel_values': pixel_values}
      return config, inputs_dict






@require_torch
class 	a		(   __snake_case    , __snake_case    , unittest.TestCase						):
    SCREAMING_SNAKE_CASE		:	int		=					(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
    SCREAMING_SNAKE_CASE		:	int		=					(
        {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
        if is_torch_available()
        else {}
    )

    SCREAMING_SNAKE_CASE		:	int		=					False
    SCREAMING_SNAKE_CASE		:	Optional[int]		=					False
    SCREAMING_SNAKE_CASE		:	Optional[int]		=					False
    SCREAMING_SNAKE_CASE		:	int		=					False






    def   UpperCamelCase			(			self	:				Optional[int]   )	->						List[Any]:
      lowerCamelCase_       	=		RegNetModelTester(self   )
      lowerCamelCase_       	=		ConfigTester(self			,		config_class=__SCREAMING_SNAKE_CASE			,		has_text_modality=__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				Dict   )	->						Any:
      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()






    def   UpperCamelCase			(			self	:				Any   )	->						Optional[Any]:
      return






    @unittest.skip(reason='RegNet does not use inputs_embeds'   )
    def   UpperCamelCase			(			self	:				List[str]   )	->						Union[str, Any]:
      pass






    @unittest.skip(reason='RegNet does not support input and output embeddings'   )
    def   UpperCamelCase			(			self	:				Any   )	->						Dict:
      pass






    def   UpperCamelCase			(			self	:				Union[str, Any]   )	->						Dict:
      lowerCamelCase_	,      lowerCamelCase_       	=		self.model_tester.prepare_config_and_inputs_for_common()

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

        lowerCamelCase_       	=		['pixel_values']
        self.assertListEqual(arg_names[:1]			,		__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				Tuple   )	->						List[str]:
      lowerCamelCase_       	=		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				Tuple   )	->						Dict:
      lowerCamelCase_	,      lowerCamelCase_       	=		self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowerCamelCase_       	=		model_class(config=__SCREAMING_SNAKE_CASE   )
        for name, module in model.named_modules():
          if isinstance(__SCREAMING_SNAKE_CASE			,		(nn.BatchNormad, nn.GroupNorm)   ):
            self.assertTrue(
                torch.all(module.weight == 1   )			,		msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''			,		)
            self.assertTrue(
                torch.all(module.bias == 0   )			,		msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''			,		)






    def   UpperCamelCase			(			self	:				Union[str, Any]   )	->						Optional[Any]:
      def check_hidden_states_output(__SCREAMING_SNAKE_CASE	:				Dict			,		__SCREAMING_SNAKE_CASE	:				Union[str, Any]			,		__SCREAMING_SNAKE_CASE	:				List[Any]   ):
        lowerCamelCase_       	=		model_class(__SCREAMING_SNAKE_CASE   )
        model.to(__SCREAMING_SNAKE_CASE   )
        model.eval()

        with torch.no_grad():
          lowerCamelCase_       	=		model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )   )

        lowerCamelCase_       	=		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        lowerCamelCase_       	=		self.model_tester.num_stages
        self.assertEqual(len(__SCREAMING_SNAKE_CASE   )			,		expected_num_stages + 1   )

        # RegNet's feature maps are of shape (batch_size, num_channels, height, width)
        self.assertListEqual(
            list(hidden_states[0].shape[-2:]   )			,		[self.model_tester.image_size // 2, self.model_tester.image_size // 2]			,		)

      lowerCamelCase_	,      lowerCamelCase_       	=		self.model_tester.prepare_config_and_inputs_for_common()
      lowerCamelCase_       	=		['basic', 'bottleneck']
      for model_class in self.all_model_classes:
        for layer_type in layers_type:
          lowerCamelCase_       	=		layer_type
          lowerCamelCase_       	=		True
          check_hidden_states_output(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )

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

          check_hidden_states_output(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				List[Any]   )	->						Tuple:
      lowerCamelCase_       	=		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE   )






    @slow
    def   UpperCamelCase			(			self	:				int   )	->						Union[str, Any]:
      for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCamelCase_       	=		RegNetModel.from_pretrained(__SCREAMING_SNAKE_CASE   )
        self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )







def 	lowerCamelCase__			(				) ->							Optional[Any]:
  lowerCamelCase_       	=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
  return image






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






    @cached_property
    def   UpperCamelCase			(			self	:				Optional[int]   )	->						Optional[int]:
      return (
          AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
          if is_vision_available()
          else None
      )






    @slow
    def   UpperCamelCase			(			self	:				Optional[int]   )	->						Dict:
      lowerCamelCase_       	=		RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		self.default_image_processor
      lowerCamelCase_       	=		prepare_img()
      lowerCamelCase_       	=		image_processor(images=__SCREAMING_SNAKE_CASE			,		return_tensors='pt'   ).to(__SCREAMING_SNAKE_CASE   )

      # forward pass
      with torch.no_grad():
        lowerCamelCase_       	=		model(**__SCREAMING_SNAKE_CASE   )

      # verify the logits
      lowerCamelCase_       	=		torch.Size((1, 1000)   )
      self.assertEqual(outputs.logits.shape			,		__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		torch.tensor([-0.4_180, -1.5_051, -3.4_836]   ).to(__SCREAMING_SNAKE_CASE   )

      self.assertTrue(torch.allclose(outputs.logits[0, :3]			,		__SCREAMING_SNAKE_CASE			,		atol=1e-4   )   )




