




"""simple docstring"""

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__   :




			@staticmethod
			def 				a_		( *lowercase	:						Tuple   ,     **lowercase	:						str						)       ->			Optional[Any]:
								pass
@is_pipeline_test
@require_torch_or_tf
@require_vision
class      A__   (   unittest.TestCase  ):
	A_				:					Dict      =   MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
	A_				:					str      =   TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING




	def 				a_		( self	:						Dict   ,     lowercase	:						Optional[Any]   ,     lowercase	:						Dict   ,     lowercase	:						str						)       ->			Optional[Any]:
						__snake_case        =						ImageClassificationPipeline(model=lowercase   ,     image_processor=lowercase   ,     top_k=2						)
						__snake_case        =						[
						    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						),
						    """http://images.cocodataset.org/val2017/000000039769.jpg""",
						]
						return image_classifier, examples




	def 				a_		( self	:						Any   ,     lowercase	:						List[str]   ,     lowercase	:						Dict						)       ->			Optional[int]:
						__snake_case        =						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

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

						# Accepts URL + PIL.Image + lists
						__snake_case        =						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 				a_		( self	:						Union[str, Any]						)       ->			int:
						__snake_case        =						"""hf-internal-testing/tiny-random-vit"""
						__snake_case        =						pipeline("""image-classification"""   ,     model=lowercase						)

						__snake_case        =						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}]   ,     )

						__snake_case        =						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 				a_		( self	:						str						)       ->			List[str]:
						__snake_case        =						"""hf-internal-testing/tiny-random-vit"""
						__snake_case        =						pipeline("""image-classification"""   ,     model=lowercase   ,     framework="""tf"""						)

						__snake_case        =						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}]   ,     )

						__snake_case        =						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 				a_		( self	:						List[Any]						)       ->			str:
						__snake_case        =						PreTrainedTokenizer()

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

						self.assertIs(image_classifier.tokenizer   ,     lowercase						)




	@slow
	@require_torch
	def 				a_		( self	:						Optional[Any]						)       ->			Tuple:
						# Perceiver is not tested by `run_pipeline_test` properly.
						# That is because the type of feature_extractor and model preprocessor need to be kept
						# in sync, which is not the case in the current design
						__snake_case        =						pipeline("""image-classification"""   ,     model="""deepmind/vision-perceiver-conv"""						)
						__snake_case        =						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"""},
						    ]   ,     )

						__snake_case        =						pipeline("""image-classification"""   ,     model="""deepmind/vision-perceiver-fourier"""						)
						__snake_case        =						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"""},
						    ]   ,     )

						__snake_case        =						pipeline("""image-classification"""   ,     model="""deepmind/vision-perceiver-learned"""						)
						__snake_case        =						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"""},
						    ]   ,     )








"""simple docstring"""

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__			:     List[Any]			       =				logging.get_logger(__name__)

UpperCamelCase__			:     List[str]			       =				{}
class      A__   (   lowercase_  ):
	A_				:					Dict      =   """fsmt_decoder"""




	def __init__( self	:						List[Any]   ,     lowercase	:						Any=0   ,     lowercase	:						Dict=0						)       ->			str:
						super().__init__()
						__snake_case        =						vocab_size
						__snake_case        =						bos_token_id

class      A__   (   lowercase_  ):
	A_				:					Union[str, Any]      =   """fsmt"""
	A_				:					int      =   {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}




	def __init__( self	:						Optional[Any]   ,     lowercase	:						Any=["en", "de"]   ,     lowercase	:						Optional[int]=42_024   ,     lowercase	:						Optional[int]=42_024   ,     lowercase	:						Tuple="relu"   ,     lowercase	:						Tuple=1_024   ,     lowercase	:						Union[str, Any]=200   ,     lowercase	:						List[str]=1_024   ,     lowercase	:						Tuple=4_096   ,     lowercase	:						int=12   ,     lowercase	:						Any=16   ,     lowercase	:						List[Any]=0.0   ,     lowercase	:						str=4_096   ,     lowercase	:						str=12   ,     lowercase	:						Optional[int]=16   ,     lowercase	:						Dict=0.0   ,     lowercase	:						Any=0.0   ,     lowercase	:						Union[str, Any]=0.1   ,     lowercase	:						Tuple=0.0   ,     lowercase	:						List[str]=0.02   ,     lowercase	:						int=2   ,     lowercase	:						Any=True   ,     lowercase	:						int=True   ,     lowercase	:						int=False   ,     lowercase	:						List[str]=5   ,     lowercase	:						List[Any]=1.0   ,     lowercase	:						Union[str, Any]=False   ,     lowercase	:						Optional[Any]=True   ,     lowercase	:						int=1   ,     lowercase	:						Any=0   ,     lowercase	:						Optional[Any]=2   ,     lowercase	:						Any=2   ,     **lowercase	:						List[Any]   ,     )       ->			Union[str, Any]:
						__snake_case        =						langs
						__snake_case        =						src_vocab_size
						__snake_case        =						tgt_vocab_size
						__snake_case        =						d_model  # encoder_embed_dim and decoder_embed_dim

						__snake_case        =						encoder_ffn_dim
						__snake_case        =						__snake_case        =						encoder_layers
						__snake_case        =						encoder_attention_heads
						__snake_case        =						encoder_layerdrop
						__snake_case        =						decoder_layerdrop
						__snake_case        =						decoder_ffn_dim
						__snake_case        =						decoder_layers
						__snake_case        =						decoder_attention_heads
						__snake_case        =						max_position_embeddings
						__snake_case        =						init_std  # Normal(0, this parameter)
						__snake_case        =						activation_function

						__snake_case        =						DecoderConfig(vocab_size=lowercase   ,     bos_token_id=lowercase						)
						if "decoder" in common_kwargs:
											del common_kwargs["decoder"]

						__snake_case        =						scale_embedding  # scale factor will be sqrt(d_model) if True

						# 3 Types of Dropout
						__snake_case        =						attention_dropout
						__snake_case        =						activation_dropout
						__snake_case        =						dropout

						__snake_case        =						use_cache
						super().__init__(
						    pad_token_id=lowercase   ,     bos_token_id=lowercase   ,     eos_token_id=lowercase   ,     decoder_start_token_id=lowercase   ,     is_encoder_decoder=lowercase   ,     tie_word_embeddings=lowercase   ,     forced_eos_token_id=lowercase   ,     max_length=lowercase   ,     num_beams=lowercase   ,     length_penalty=lowercase   ,     early_stopping=lowercase   ,     **lowercase   ,     )




	def 				a_		( self	:						Union[str, Any]						)       ->			Dict:
						__snake_case        =						copy.deepcopy(self.__dict__						)
						__snake_case        =						self.decoder.to_dict()
						__snake_case        =						self.__class__.model_type
						return output


