

'''simple docstring'''
import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
					import jax
					import jax.numpy as jnp

					from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor
class 					_snake_case		(unittest.TestCase):






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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

				UpperCAmelCase_     :      List[str]						=  self.get_config()

				return config, pixel_values






			def 		UpperCamelCase__							(  self     ):
				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			,image_size=self.image_size			,)






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case     ):
				UpperCAmelCase_     :      int						=  FlaxRegNetModel(config=_snake_case     )
				UpperCAmelCase_     :      int						=  model(_snake_case     )

				# Output shape (b, c, h, w)
				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			,_snake_case			,_snake_case     ):
				UpperCAmelCase_     :      str						=  self.num_labels
				UpperCAmelCase_     :      int						=  FlaxRegNetForImageClassification(config=_snake_case     )
				UpperCAmelCase_     :      Optional[Any]						=  model(_snake_case     )
				self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_labels)     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  self.prepare_config_and_inputs()
				UpperCAmelCase_					,					UpperCAmelCase_     :      Union[str, Any]						=  config_and_inputs
				UpperCAmelCase_     :      Union[str, Any]						=  {"pixel_values": pixel_values}
				return config, inputs_dict




@require_flax
class 					_snake_case		(__SCREAMING_SNAKE_CASE			,			unittest.TestCase):
			__A  :	Union[str, Any]        =(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

			__A  :	Any        =False
			__A  :	List[str]        =False
			__A  :	Union[str, Any]        =False






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Union[str, Any]						=  FlaxRegNetModelTester(self     )
				UpperCAmelCase_     :      Tuple						=  ConfigTester(self			,config_class=_snake_case			,has_text_modality=_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				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     ):
				return






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Tuple						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Tuple						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_snake_case     )






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






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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_					,					UpperCAmelCase_     :      Optional[int]						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					UpperCAmelCase_     :      Tuple						=  model_class(_snake_case     )
					UpperCAmelCase_     :      Tuple						=  inspect.signature(model.__call__     )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					UpperCAmelCase_     :      Union[str, Any]						=  [*signature.parameters.keys()]

					UpperCAmelCase_     :      Union[str, Any]						=  ["pixel_values"]
					self.assertListEqual(arg_names[:1]			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				def check_hidden_states_output(_snake_case			,_snake_case			,_snake_case     ):
					UpperCAmelCase_     :      str						=  model_class(_snake_case     )

					UpperCAmelCase_     :      Any						=  model(**self._prepare_for_class(_snake_case			,_snake_case     )     )

					UpperCAmelCase_     :      Dict						=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

					UpperCAmelCase_     :      Tuple						=  self.model_tester.num_stages
					self.assertEqual(len(_snake_case     )			,expected_num_stages + 1     )

				UpperCAmelCase_					,					UpperCAmelCase_     :      int						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					UpperCAmelCase_     :      Tuple						=  True
					check_hidden_states_output(_snake_case			,_snake_case			,_snake_case     )

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					UpperCAmelCase_     :      List[str]						=  True

					check_hidden_states_output(_snake_case			,_snake_case			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_					,					UpperCAmelCase_     :      Union[str, Any]						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					with self.subTest(model_class.__name__     ):
						UpperCAmelCase_     :      Optional[Any]						=  self._prepare_for_class(_snake_case			,_snake_case     )
						UpperCAmelCase_     :      Union[str, Any]						=  model_class(_snake_case     )

						@jax.jit
						def model_jitted(_snake_case			,**_snake_case     ):
							return model(pixel_values=_snake_case			,**_snake_case     )

						with self.subTest("JIT Enabled"     ):
							UpperCAmelCase_     :      Tuple						=  model_jitted(**_snake_case     ).to_tuple()

						with self.subTest("JIT Disabled"     ):
							with jax.disable_jit():
								UpperCAmelCase_     :      Optional[int]						=  model_jitted(**_snake_case     ).to_tuple()

						self.assertEqual(len(_snake_case     )			,len(_snake_case     )     )
						for jitted_output, output in zip(_snake_case			,_snake_case     ):
							self.assertEqual(jitted_output.shape			,output.shape     )




def  a__       (    )     ->					str:


	"""simple docstring"""





	UpperCAmelCase_     :      List[Any]						=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
	return image





@require_flax
class 					_snake_case		(unittest.TestCase):






			@cached_property
			def 		UpperCamelCase__							(  self     ):
				return AutoImageProcessor.from_pretrained("facebook/regnet-y-040"     ) if is_vision_available() else None






			@slow
			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Union[str, Any]						=  FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040"     )

				UpperCAmelCase_     :      Dict						=  self.default_image_processor
				UpperCAmelCase_     :      List[Any]						=  prepare_img()
				UpperCAmelCase_     :      Tuple						=  image_processor(images=_snake_case			,return_tensors="np"     )

				UpperCAmelCase_     :      int						=  model(**_snake_case     )

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

				UpperCAmelCase_     :      Any						=  jnp.array([-0.4180, -1.5051, -3.4836]     )

				self.assertTrue(jnp.allclose(outputs.logits[0, :3]			,_snake_case			,atol=1E-4     )     )










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 SCREAMING_SNAKE_CASE							(			lowercase_		)  ->			int:



       """simple docstring"""

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







def SCREAMING_SNAKE_CASE							(			lowercase_		)  ->			Union[str, Any]:



       """simple docstring"""

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


class 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = '''sigmoid'''
    UpperCAmelCase__				    = '''softmax'''
    UpperCAmelCase__				    = '''none'''


@add_end_docstrings(
    UpperCAmelCase__						,   R'''
        return_all_scores (`bool`, *optional*, defaults to `False`):
            Whether to return all prediction scores or just the one of the predicted class.
        function_to_apply (`str`, *optional*, defaults to `"default"`):
            The function to apply to the model outputs in order to retrieve the scores. Accepts four different values:

            - `"default"`: if the model has a single label, will apply the sigmoid function on the output. If the model
              has several labels, will apply the softmax function on the output.
            - `"sigmoid"`: Applies the sigmoid function on the output.
            - `"softmax"`: Applies the softmax function on the output.
            - `"none"`: Does not apply any function on the output.
    '''						,   )
class 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = False
    UpperCAmelCase__				    = ClassificationFunction.NONE


    def __init__(     self :      Any   ,					**UpperCAmelCase__ :      Optional[Any])		->str:





           '''simple docstring'''

           super().__init__(**UpperCAmelCase__)

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


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str]   ,					UpperCAmelCase__ :      Tuple=None   ,					UpperCAmelCase__ :      Any=None   ,					UpperCAmelCase__ :      int=""   ,					**UpperCAmelCase__ :      Any)		->int:





           '''simple docstring'''

           A__ 					=       tokenizer_kwargs

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

           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__) or top_k is None:
                  A__ 					=       top_k
                  A__ 					=       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`.'''   ,					UpperCAmelCase__   ,					)
                  if return_all_scores:
                         A__ 					=       None
                  else:
                         A__ 					=       1

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

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


    def __call__(     self :      str   ,					*UpperCAmelCase__ :      List[Any]   ,					**UpperCAmelCase__ :      Optional[int])		->Union[str, Any]:





           '''simple docstring'''

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


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple   ,					UpperCAmelCase__ :      Any   ,					**UpperCAmelCase__ :      str)		->Dict[str, GenericTensor]:





           '''simple docstring'''

           A__ 					=       self.framework
           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  return self.tokenizer(**UpperCAmelCase__   ,					return_tensors=UpperCAmelCase__   ,					**UpperCAmelCase__)
           elif isinstance(UpperCAmelCase__   ,					UpperCAmelCase__) and len(UpperCAmelCase__) == 1 and isinstance(inputs[0]   ,					UpperCAmelCase__) 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=UpperCAmelCase__   ,					**UpperCAmelCase__)
           elif isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  # 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(UpperCAmelCase__   ,					return_tensors=UpperCAmelCase__   ,					**UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str]   ,					UpperCAmelCase__ :      Tuple)		->Tuple:





           '''simple docstring'''

           return self.model(**UpperCAmelCase__)





    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      Optional[int]=None   ,					UpperCAmelCase__ :      List[Any]=1   ,					UpperCAmelCase__ :      str=True)		->Dict:





           '''simple docstring'''

           if function_to_apply is None:
                  if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1:
                         A__ 					=       ClassificationFunction.SIGMOID
                  elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1:
                         A__ 					=       ClassificationFunction.SOFTMAX
                  elif hasattr(self.model.config   ,					'''function_to_apply''') and function_to_apply is None:
                         A__ 					=       self.model.config.function_to_apply
                  else:
                         A__ 					=       ClassificationFunction.NONE

           A__ 					=       model_outputs['''logits'''][0]
           A__ 					=       outputs.numpy()

           if function_to_apply == ClassificationFunction.SIGMOID:
                  A__ 					=       sigmoid(UpperCAmelCase__)
           elif function_to_apply == ClassificationFunction.SOFTMAX:
                  A__ 					=       softmax(UpperCAmelCase__)
           elif function_to_apply == ClassificationFunction.NONE:
                  A__ 					=       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()}

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


