






import unittest

from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    PreTrainedTokenizer,
    is_vision_available,
)
from transformers.pipelines import ImageClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
		from PIL import Image
else:




		class 							a_ :


									'''simple docstring'''






									@staticmethod
									def      _lowercase       (		*lowercase_			,			**lowercase_   )					->					Dict:
																'''simple docstring'''

																pass




@is_pipeline_test
@require_torch_or_tf
@require_vision
class 							a_ (						unittest.TestCase		):


							'''simple docstring'''






							__a:	str     =    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
							__a:	Tuple     =    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

							def      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_   )					->					Tuple:
														'''simple docstring'''

														lowerCAmelCase_										=     ImageClassificationPipeline(model=lowercase_			,			image_processor=lowercase_			,			top_k=2   )
														lowerCAmelCase_										=     [
														    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   ),
														    'http://images.cocodataset.org/val2017/000000039769.jpg',
														]
														return image_classifier, examples

							def      _lowercase       (		self			,			lowercase_			,			lowercase_   )					->					Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     image_classifier('./tests/fixtures/tests_samples/COCO/000000039769.png'   )

														self.assertEqual(
														    lowercase_			,			[
														        {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														    ]			,			)

														import datasets

														lowerCAmelCase_										=     datasets.load_dataset('hf-internal-testing/fixtures_image_utils'			,			'image'			,			split='test'   )

														# Accepts URL + PIL.Image + lists
														lowerCAmelCase_										=     image_classifier(
														    [
														        Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   ),
														        'http://images.cocodataset.org/val2017/000000039769.jpg',
														        # RGBA
														        dataset[0]['file'],
														        # LA
														        dataset[1]['file'],
														        # L
														        dataset[2]['file'],
														    ]   )
														self.assertEqual(
														    lowercase_			,			[
														        [
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        ],
														        [
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        ],
														        [
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        ],
														        [
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        ],
														        [
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														            {'score': ANY(lowercase_   ), 'label': ANY(lowercase_   )},
														        ],
														    ]			,			)

							@require_torch
							def      _lowercase       (		self   )					->					Optional[int]:
														'''simple docstring'''

														lowerCAmelCase_										=     'hf-internal-testing/tiny-random-vit'
														lowerCAmelCase_										=     pipeline('image-classification'			,			model=lowercase_   )

														lowerCAmelCase_										=     image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'   )
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}]			,			)

														lowerCAmelCase_										=     image_classifier(
														    [
														        'http://images.cocodataset.org/val2017/000000039769.jpg',
														        'http://images.cocodataset.org/val2017/000000039769.jpg',
														    ]			,			top_k=2			,			)
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[
														        [{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}],
														        [{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}],
														    ]			,			)

							@require_tf
							def      _lowercase       (		self   )					->					List[Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     'hf-internal-testing/tiny-random-vit'
														lowerCAmelCase_										=     pipeline('image-classification'			,			model=lowercase_			,			framework='tf'   )

														lowerCAmelCase_										=     image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'   )
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}]			,			)

														lowerCAmelCase_										=     image_classifier(
														    [
														        'http://images.cocodataset.org/val2017/000000039769.jpg',
														        'http://images.cocodataset.org/val2017/000000039769.jpg',
														    ]			,			top_k=2			,			)
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[
														        [{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}],
														        [{'label': 'LABEL_1', 'score': 0.5_74}, {'label': 'LABEL_0', 'score': 0.4_26}],
														    ]			,			)

							def      _lowercase       (		self   )					->					int:
														'''simple docstring'''

														lowerCAmelCase_										=     PreTrainedTokenizer()

														# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
														lowerCAmelCase_										=     pipeline(
														    'image-classification'			,			model='hf-internal-testing/tiny-random-vit'			,			tokenizer=lowercase_   )

														self.assertIs(image_classifier.tokenizer			,			lowercase_   )






							@slow
							@require_torch
							def      _lowercase       (		self   )					->					Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     pipeline('image-classification'			,			model='deepmind/vision-perceiver-conv'   )
														lowerCAmelCase_										=     image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'   )
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[
														        {'score': 0.43_85, 'label': 'tabby, tabby cat'},
														        {'score': 0.3_21, 'label': 'tiger cat'},
														        {'score': 0.05_02, 'label': 'Egyptian cat'},
														        {'score': 0.01_37, 'label': 'crib, cot'},
														        {'score': 0.0_07, 'label': 'radiator'},
														    ]			,			)

														lowerCAmelCase_										=     pipeline('image-classification'			,			model='deepmind/vision-perceiver-fourier'   )
														lowerCAmelCase_										=     image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'   )
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[
														        {'score': 0.56_58, 'label': 'tabby, tabby cat'},
														        {'score': 0.13_09, 'label': 'tiger cat'},
														        {'score': 0.07_22, 'label': 'Egyptian cat'},
														        {'score': 0.07_07, 'label': 'remote control, remote'},
														        {'score': 0.00_82, 'label': 'computer keyboard, keypad'},
														    ]			,			)

														lowerCAmelCase_										=     pipeline('image-classification'			,			model='deepmind/vision-perceiver-learned'   )
														lowerCAmelCase_										=     image_classifier('http://images.cocodataset.org/val2017/000000039769.jpg'   )
														self.assertEqual(
														    nested_simplify(lowercase_			,			decimals=4   )			,			[
														        {'score': 0.30_22, 'label': 'tabby, tabby cat'},
														        {'score': 0.23_62, 'label': 'Egyptian cat'},
														        {'score': 0.18_56, 'label': 'tiger cat'},
														        {'score': 0.03_24, 'label': 'remote control, remote'},
														        {'score': 0.00_96, 'label': 'quilt, comforter, comfort, puff'},
														    ]			,			)











import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


lowerCamelCase_						     =  logging.get_logger(__name__)




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self   )					->					Any:
														'''simple docstring'''

														super().__init__()
														if version.parse(torch.__version__   ) < version.parse('1.12.0'   ):
																					raise ImportError(
																					    f'''You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use '''
																					    'PytorchGELUTanh. Please upgrade torch.'   )






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return nn.functional.gelu(lowercase_			,			approximate='tanh'   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi   ) * (input + 0.04_47_15 * torch.pow(lowercase_			,			3.0   ))   ))




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self			,			lowercase_ = False   )					->					Optional[Any]:
														'''simple docstring'''

														super().__init__()
														if use_gelu_python:
																					lowerCAmelCase_										=     self._gelu_python
														else:
																					lowerCAmelCase_										=     nn.functional.gelu

							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0   )   ))






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return self.act(lowercase_   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return 0.5 * input * (1.0 + torch.tanh(input * 0.79_78_84_56_08 * (1.0 + 0.04_47_15 * input * input)   ))




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return input * torch.sigmoid(1.7_02 * input   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self			,			lowercase_			,			lowercase_   )					->					Optional[int]:
														'''simple docstring'''

														if min > max:
																					raise ValueError(f'''min should be < max (got min: {min}, max: {max})'''   )

														super().__init__()
														lowerCAmelCase_										=     min
														lowerCAmelCase_										=     max






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return torch.clip(gelu(lowercase_   )			,			self.min			,			self.max   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self   )					->					Union[str, Any]:
														'''simple docstring'''

														super().__init__()
														lowerCAmelCase_										=     math.sqrt(2 / math.pi   )






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.04_47_15 * torch.pow(lowercase_			,			3   ))   ))




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return nn.functional.silu(lowercase_   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self   )					->					List[Any]:
														'''simple docstring'''

														super().__init__()
														if version.parse(torch.__version__   ) < version.parse('1.9.0'   ):
																					lowerCAmelCase_										=     self._mish_python
														else:
																					lowerCAmelCase_										=     nn.functional.mish

							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return input * torch.tanh(nn.functional.softplus(lowercase_   )   )






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return self.act(lowercase_   )




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Tensor:
														'''simple docstring'''

														return input




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_			,			lowercase_=0.70_71_07			,			lowercase_=0.28_20_95   )					->					Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     (input - mu).div(sigma * math.sqrt(2.0   )   )
														return 0.5 * (1.0 + torch.erf(lowercase_   ))




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def      _lowercase       (		self			,			lowercase_   )					->					Any:
														'''simple docstring'''

														lowerCAmelCase_										=     nn.functional.relu(lowercase_   )
														lowerCAmelCase_										=     torch.square(lowercase_   )
														return squared




class 							a_ (						a_		):


							'''simple docstring'''






							def __getitem__(		self			,			lowercase_   )					->					Any:
														'''simple docstring'''

														lowerCAmelCase_										=     super().__getitem__(lowercase_   )
														lowerCAmelCase_						,   lowerCAmelCase_										=     content if isinstance(lowercase_			,			lowercase_   ) else (content, {})
														return cls(**lowercase_   )


lowerCamelCase_						     =  {
    """gelu""": GELUActivation,
    """gelu_10""": (ClippedGELUActivation, {"""min""": -1_0, """max""": 1_0}),
    """gelu_fast""": FastGELUActivation,
    """gelu_new""": NewGELUActivation,
    """gelu_python""": (GELUActivation, {"""use_gelu_python""": True}),
    """gelu_pytorch_tanh""": PytorchGELUTanh,
    """gelu_accurate""": AccurateGELUActivation,
    """laplace""": LaplaceActivation,
    """linear""": LinearActivation,
    """mish""": MishActivation,
    """quick_gelu""": QuickGELUActivation,
    """relu""": nn.ReLU,
    """relu2""": ReLUSquaredActivation,
    """relu6""": nn.ReLUa,
    """sigmoid""": nn.Sigmoid,
    """silu""": SiLUActivation,
    """swish""": SiLUActivation,
    """tanh""": nn.Tanh,
}
lowerCamelCase_						     =  ClassInstantier(ACTaCLS)
def      lowerCamelCase					(						a_	)	->			str:
							if activation_string in ACTaFN:
														return ACTaFN[activation_string]
							else:
														raise KeyError(F'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()	)}'''	)


# For backwards compatibility with: from activations import gelu_python
lowerCamelCase_						     =  get_activation("""gelu_python""")
lowerCamelCase_						     =  get_activation("""gelu_new""")
lowerCamelCase_						     =  get_activation("""gelu""")
lowerCamelCase_						     =  get_activation("""gelu_fast""")
lowerCamelCase_						     =  get_activation("""quick_gelu""")
lowerCamelCase_						     =  get_activation("""silu""")
lowerCamelCase_						     =  get_activation("""mish""")



lowerCamelCase_						     =  get_activation("""linear""")



