





import warnings
from typing import Dict

import numpy as np

from ..utils import ExplicitEnum, add_end_docstrings, is_tf_available, is_torch_available
from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline


if is_tf_available():
    from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

if is_torch_available():
    from ..models.auto.modeling_auto import MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING






def 				_UpperCAmelCase			(    A     ):




   '''simple docstring'''

   return 1.0 / (1.0 + np.exp(-_outputs     ))






def 				_UpperCAmelCase			(    A     ):




   '''simple docstring'''

   UpperCAmelCase__						=np.max(_outputs				,							axis=-1				,							keepdims=A     )
   UpperCAmelCase__						=np.exp(_outputs - maxes     )
   return shifted_exp / shifted_exp.sum(axis=-1				,							keepdims=A     )

class     snake_case_		(   a							):






 '''simple docstring'''





 __UpperCamelCase       =      'sigmoid'
 __UpperCamelCase       =      'softmax'
 __UpperCamelCase       =      'none'

@add_end_docstrings(
    a,		R'\n        return_all_scores (`bool`, *optional*, defaults to `False`):\n            Whether to return all prediction scores or just the one of the predicted class.\n        function_to_apply (`str`, *optional*, defaults to `"default"`):\n            The function to apply to the model outputs in order to retrieve the scores. Accepts four different values:\n\n            - `"default"`: if the model has a single label, will apply the sigmoid function on the output. If the model\n              has several labels, will apply the softmax function on the output.\n            - `"sigmoid"`: Applies the sigmoid function on the output.\n            - `"softmax"`: Applies the softmax function on the output.\n            - `"none"`: Does not apply any function on the output.\n    ',		)
class     snake_case_		(   a							):






 '''simple docstring'''





 __UpperCamelCase       =      False
 __UpperCamelCase       =      ClassificationFunction.NONE

 def __init__(  self,		**A_		)	->       Optional[int]:
    super().__init__(**A_		)

    self.check_model_type(
        TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
        if self.framework == "tf"
        else MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING		)

 def  __UpperCAmelCase						(  self,		A_=None,		A_=None,		A_="",		**A_		)	->       Optional[int]:
    # Using "" as default argument because we're going to use `top_k=None` in user code to declare
    # "No top_k"
    UpperCAmelCase__						=tokenizer_kwargs

    UpperCAmelCase__						={}
    if hasattr(self.model.config,		"return_all_scores"		) and return_all_scores is None:
       UpperCAmelCase__						=self.model.config.return_all_scores

    if isinstance(A_,		A_		) or top_k is None:
       UpperCAmelCase__						=top_k
       UpperCAmelCase__						=False
    elif return_all_scores is not None:
       warnings.warn(
           "`return_all_scores` is now deprecated,  if want a similar functionality use `top_k=None` instead of"
           " `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`.",		A_,		)
       if return_all_scores:
          UpperCAmelCase__						=None
       else:
          UpperCAmelCase__						=1

    if isinstance(A_,		A_		):
       UpperCAmelCase__						=ClassificationFunction[function_to_apply.upper()]

    if function_to_apply is not None:
       UpperCAmelCase__						=function_to_apply
    return preprocess_params, {}, postprocess_params

 def __call__(  self,		*A_,		**A_		)	->       str:
    UpperCAmelCase__						=super().__call__(*A_,		**A_		)
    # TODO try and retrieve it in a nicer way from _sanitize_parameters.
    UpperCAmelCase__						="top_k" not in kwargs
    if isinstance(args[0],		A_		) and _legacy:
       # This pipeline is odd, and return a list when single item is run
       return [result]
    else:
       return result

 def  __UpperCAmelCase						(  self,		A_,		**A_		)	->       Dict[str, GenericTensor]:
    UpperCAmelCase__						=self.framework
    if isinstance(A_,		A_		):
       return self.tokenizer(**A_,		return_tensors=A_,		**A_		)
    elif isinstance(A_,		A_		) and len(A_		) == 1 and isinstance(inputs[0],		A_		) and len(inputs[0]		) == 2:
       # It used to be valid to use a list of list of list for text pairs, keeping this path for BC
       return self.tokenizer(
           text=inputs[0][0],		text_pair=inputs[0][1],		return_tensors=A_,		**A_		)
    elif isinstance(A_,		A_		):
       # This is likely an invalid usage of the pipeline attempting to pass text pairs.
       raise ValueError(
           "The pipeline received invalid inputs, if you are trying to send text pairs, you can try to send a"
           " dictionary `{\"text\": \"My text\", \"text_pair\": \"My pair\"}` in order to send a text pair."		)
    return self.tokenizer(A_,		return_tensors=A_,		**A_		)

 def  __UpperCAmelCase						(  self,		A_		)	->       Dict:
    return self.model(**A_		)






 def  __UpperCAmelCase						(  self,		A_,		A_=None,		A_=1,		A_=True		)	->       Any:
    # `_legacy` is used to determine if we're running the naked pipeline and in backward
    # compatibility mode, or if running the pipeline with `pipeline(..., top_k=1)` we're running
    # the more natural result containing the list.
    # Default value before `set_parameters`
    if function_to_apply is None:
       if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1:
          UpperCAmelCase__						=ClassificationFunction.SIGMOID
       elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1:
          UpperCAmelCase__						=ClassificationFunction.SOFTMAX
       elif hasattr(self.model.config,		"function_to_apply"		) and function_to_apply is None:
          UpperCAmelCase__						=self.model.config.function_to_apply
       else:
          UpperCAmelCase__						=ClassificationFunction.NONE

    UpperCAmelCase__						=model_outputs["logits"][0]
    UpperCAmelCase__						=outputs.numpy()

    if function_to_apply == ClassificationFunction.SIGMOID:
       UpperCAmelCase__						=sigmoid(A_		)
    elif function_to_apply == ClassificationFunction.SOFTMAX:
       UpperCAmelCase__						=softmax(A_		)
    elif function_to_apply == ClassificationFunction.NONE:
       UpperCAmelCase__						=outputs
    else:
       raise ValueError(f"""Unrecognized `function_to_apply` argument: {function_to_apply}"""		)

    if top_k == 1 and _legacy:
       return {"label": self.model.config.idalabel[scores.argmax().item()], "score": scores.max().item()}

    UpperCAmelCase__						=[
        {"label": self.model.config.idalabel[i], "score": score.item()} for i, score in enumerate(A_		)
    ]
    if not _legacy:
       dict_scores.sort(key=lambda A_		: x["score"],		reverse=A_		)
       if top_k is not None:
          UpperCAmelCase__						=dict_scores[:top_k]
    return dict_scores










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_		)		)



