
'''simple docstring'''







import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_snake_case				:   Any     =				{"""LayoutLMv2Config""", """LayoutLMv3Config"""}


@is_pipeline_test
class 			lowerCAmelCase (				unittest.TestCase			):
		a							:					Dict       =					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
		a							:					Any       =					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

		if model_mapping is not None:
				a							:					Optional[Any]       =					{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
		if tf_model_mapping is not None:
				a							:					str       =					{
				    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
				}




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= ZeroShotClassificationPipeline(
								    model=UpperCamelCase					,						tokenizer=UpperCamelCase					,						candidate_labels=["polics", "health"]      )
								return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= classifier("Who are you voting for in 2020?"					,						candidate_labels="politics"      )
								self.assertEqual(UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      )]}      )

								# No kwarg
								_SCREAMING_SNAKE_CASE				= classifier("Who are you voting for in 2020?"					,						["politics"]      )
								self.assertEqual(UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      )]}      )

								_SCREAMING_SNAKE_CASE				= classifier("Who are you voting for in 2020?"					,						candidate_labels=["politics"]      )
								self.assertEqual(UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      )]}      )

								_SCREAMING_SNAKE_CASE				= classifier("Who are you voting for in 2020?"					,						candidate_labels="politics, public health"      )
								self.assertEqual(
								    UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )]}      )
								self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]      )      )					,						1.0      )

								_SCREAMING_SNAKE_CASE				= classifier("Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health"]      )
								self.assertEqual(
								    UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )]}      )
								self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]      )      )					,						1.0      )

								_SCREAMING_SNAKE_CASE				= classifier(
								    "Who are you voting for in 2020?"					,						candidate_labels="politics"					,						hypothesis_template="This text is about {}"      )
								self.assertEqual(UpperCamelCase					,						{"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      )]}      )

								# https://github.com/huggingface/transformers/issues/13846
								_SCREAMING_SNAKE_CASE				= classifier(["I am happy"]					,						["positive", "negative"]      )
								self.assertEqual(
								    UpperCamelCase					,						[
								        {"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )]}
								        for i in range(1      )
								    ]					,						)
								_SCREAMING_SNAKE_CASE				= classifier(["I am happy", "I am sad"]					,						["positive", "negative"]      )
								self.assertEqual(
								    UpperCamelCase					,						[
								        {"sequence": ANY(UpperCamelCase      ), "labels": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )], "scores": [ANY(UpperCamelCase      ), ANY(UpperCamelCase      )]}
								        for i in range(2      )
								    ]					,						)

								with self.assertRaises(UpperCamelCase      ):
														classifier(""					,						candidate_labels="politics"      )

								with self.assertRaises(UpperCamelCase      ):
														classifier(UpperCamelCase					,						candidate_labels="politics"      )

								with self.assertRaises(UpperCamelCase      ):
														classifier("Who are you voting for in 2020?"					,						candidate_labels=""      )

								with self.assertRaises(UpperCamelCase      ):
														classifier("Who are you voting for in 2020?"					,						candidate_labels=UpperCamelCase      )

								with self.assertRaises(UpperCamelCase      ):
														classifier(
														    "Who are you voting for in 2020?"					,						candidate_labels="politics"					,						hypothesis_template="Not formatting template"					,						)

								with self.assertRaises(UpperCamelCase      ):
														classifier(
														    "Who are you voting for in 2020?"					,						candidate_labels="politics"					,						hypothesis_template=UpperCamelCase					,						)

								self.run_entailment_id(UpperCamelCase      )




		def     lowercase       (				self					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier.model.config
								_SCREAMING_SNAKE_CASE				= config.labelaid
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier.entailment_id

								_SCREAMING_SNAKE_CASE				= {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
								self.assertEqual(zero_shot_classifier.entailment_id					,						-1      )

								_SCREAMING_SNAKE_CASE				= {"entailment": 0, "neutral": 1, "contradiction": 2}
								self.assertEqual(zero_shot_classifier.entailment_id					,						0      )

								_SCREAMING_SNAKE_CASE				= {"ENTAIL": 0, "NON-ENTAIL": 1}
								self.assertEqual(zero_shot_classifier.entailment_id					,						0      )

								_SCREAMING_SNAKE_CASE				= {"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
								self.assertEqual(zero_shot_classifier.entailment_id					,						2      )

								_SCREAMING_SNAKE_CASE				= original_labelaid
								self.assertEqual(UpperCamelCase					,						zero_shot_classifier.entailment_id      )




		@require_torch
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= pipeline(
								    "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="pt"					,						)
								# There was a regression in 4.10 for this
								# Adding a test so we don't make the mistake again.
								# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
								zero_shot_classifier(
								    "Who are you voting for in 2020?" * 100					,						candidate_labels=["politics", "public health", "science"]      )




		@require_torch
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= pipeline(
								    "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="pt"					,						)
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health", "science"]      )

								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["science", "public health", "politics"],
								        "scores": [0.3_33, 0.3_33, 0.3_33],
								    }					,						)




		@require_tf
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= pipeline(
								    "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="tf"					,						)
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health", "science"]      )

								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["science", "public health", "politics"],
								        "scores": [0.3_33, 0.3_33, 0.3_33],
								    }					,						)




		@slow
		@require_torch
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= pipeline("zero-shot-classification"					,						model="roberta-large-mnli"					,						framework="pt"      )
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health", "science"]      )

								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["politics", "public health", "science"],
								        "scores": [0.9_76, 0.0_15, 0.0_09],
								    }					,						)
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
								    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
								    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
								    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
								    " machine translation tasks show these models to be superior in quality while being more parallelizable"
								    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
								    " English-to-German translation task, improving over the existing best results, including ensembles by"
								    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
								    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
								    " fraction of the training costs of the best models from the literature. We show that the Transformer"
								    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
								    " large and limited training data."					,						candidate_labels=["machine learning", "statistics", "translation", "vision"]					,						multi_label=UpperCamelCase					,						)
								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": (
								            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
								            " networks in an encoder-decoder configuration. The best performing models also connect the"
								            " encoder and decoder through an attention mechanism. We propose a new simple network"
								            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
								            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
								            " superior in quality while being more parallelizable and requiring significantly less time to"
								            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
								            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
								            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
								            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
								            " costs of the best models from the literature. We show that the Transformer generalizes well to"
								            " other tasks by applying it successfully to English constituency parsing both with large and"
								            " limited training data."
								        ),
								        "labels": ["translation", "machine learning", "vision", "statistics"],
								        "scores": [0.8_17, 0.7_13, 0.0_18, 0.0_18],
								    }					,						)




		@slow
		@require_tf
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= pipeline("zero-shot-classification"					,						model="roberta-large-mnli"					,						framework="tf"      )
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health", "science"]      )

								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["politics", "public health", "science"],
								        "scores": [0.9_76, 0.0_15, 0.0_09],
								    }					,						)
								_SCREAMING_SNAKE_CASE				= zero_shot_classifier(
								    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
								    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
								    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
								    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
								    " machine translation tasks show these models to be superior in quality while being more parallelizable"
								    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
								    " English-to-German translation task, improving over the existing best results, including ensembles by"
								    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
								    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
								    " fraction of the training costs of the best models from the literature. We show that the Transformer"
								    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
								    " large and limited training data."					,						candidate_labels=["machine learning", "statistics", "translation", "vision"]					,						multi_label=UpperCamelCase					,						)
								self.assertEqual(
								    nested_simplify(UpperCamelCase      )					,						{
								        "sequence": (
								            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
								            " networks in an encoder-decoder configuration. The best performing models also connect the"
								            " encoder and decoder through an attention mechanism. We propose a new simple network"
								            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
								            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
								            " superior in quality while being more parallelizable and requiring significantly less time to"
								            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
								            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
								            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
								            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
								            " costs of the best models from the literature. We show that the Transformer generalizes well to"
								            " other tasks by applying it successfully to English constituency parsing both with large and"
								            " limited training data."
								        ),
								        "labels": ["translation", "machine learning", "vision", "statistics"],
								        "scores": [0.8_17, 0.7_13, 0.0_18, 0.0_18],
								    }					,						)

'''simple docstring'''







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import GLPNImageProcessor


class 			lowerCAmelCase (				unittest.TestCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase=7					,						UpperCamelCase=3					,						UpperCamelCase=18					,						UpperCamelCase=30					,						UpperCamelCase=400					,						UpperCamelCase=True					,						UpperCamelCase=32					,						UpperCamelCase=True					,						):
								_SCREAMING_SNAKE_CASE				= parent
								_SCREAMING_SNAKE_CASE				= batch_size
								_SCREAMING_SNAKE_CASE				= num_channels
								_SCREAMING_SNAKE_CASE				= image_size
								_SCREAMING_SNAKE_CASE				= min_resolution
								_SCREAMING_SNAKE_CASE				= max_resolution
								_SCREAMING_SNAKE_CASE				= do_resize
								_SCREAMING_SNAKE_CASE				= size_divisor
								_SCREAMING_SNAKE_CASE				= do_rescale




		def     lowercase       (				self      ):
								return {
								    "do_resize": self.do_resize,
								    "size_divisor": self.size_divisor,
								    "do_rescale": self.do_rescale,
								}


@require_torch
@require_vision
class 			lowerCAmelCase (				__UpperCAmelCase		,     unittest.TestCase			):
		a							:					Dict       =					GLPNImageProcessor if is_vision_available() else None




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= GLPNImageProcessingTester(self      )




		@property
		def     lowercase       (				self      ):
								return self.image_processor_tester.prepare_image_processor_dict()




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.image_processing_class(**self.image_processor_dict      )
								self.assertTrue(hasattr(UpperCamelCase					,						"do_resize"      )      )
								self.assertTrue(hasattr(UpperCamelCase					,						"size_divisor"      )      )
								self.assertTrue(hasattr(UpperCamelCase					,						"resample"      )      )
								self.assertTrue(hasattr(UpperCamelCase					,						"do_rescale"      )      )




		def     lowercase       (				self      ):
								pass




		def     lowercase       (				self      ):
								# Initialize image_processing
								_SCREAMING_SNAKE_CASE				= self.image_processing_class(**self.image_processor_dict      )
								# create random PIL images
								_SCREAMING_SNAKE_CASE				= prepare_image_inputs(self.image_processor_tester					,						equal_resolution=UpperCamelCase      )
								for image in image_inputs:
														self.assertIsInstance(UpperCamelCase					,						Image.Image      )

								# Test not batched input (GLPNImageProcessor doesn't support batching)
								_SCREAMING_SNAKE_CASE				= image_processing(image_inputs[0]					,						return_tensors="pt"      ).pixel_values
								self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0      )
								self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0      )




		def     lowercase       (				self      ):
								# Initialize image_processing
								_SCREAMING_SNAKE_CASE				= self.image_processing_class(**self.image_processor_dict      )
								# create random numpy tensors
								_SCREAMING_SNAKE_CASE				= prepare_image_inputs(self.image_processor_tester					,						equal_resolution=UpperCamelCase					,						numpify=UpperCamelCase      )
								for image in image_inputs:
														self.assertIsInstance(UpperCamelCase					,						np.ndarray      )

								# Test not batched input (GLPNImageProcessor doesn't support batching)
								_SCREAMING_SNAKE_CASE				= image_processing(image_inputs[0]					,						return_tensors="pt"      ).pixel_values
								self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0      )
								self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0      )




		def     lowercase       (				self      ):
								# Initialize image_processing
								_SCREAMING_SNAKE_CASE				= self.image_processing_class(**self.image_processor_dict      )
								# create random PyTorch tensors
								_SCREAMING_SNAKE_CASE				= prepare_image_inputs(self.image_processor_tester					,						equal_resolution=UpperCamelCase					,						torchify=UpperCamelCase      )
								for image in image_inputs:
														self.assertIsInstance(UpperCamelCase					,						torch.Tensor      )

								# Test not batched input (GLPNImageProcessor doesn't support batching)
								_SCREAMING_SNAKE_CASE				= image_processing(image_inputs[0]					,						return_tensors="pt"      ).pixel_values
								self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0      )
								self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0      )