






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.
lowerCamelCase			:					Any         =	{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}



@is_pipeline_test
class 							_UpperCamelCase			(unittest.TestCase			):
      snake_case_  =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
      snake_case_  =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

      if model_mapping is not None:
            snake_case_  =							{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
      if tf_model_mapping is not None:
            snake_case_  =							{
                config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
            }


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)->	List[Any]:
           __lowerCAmelCase								=					ZeroShotClassificationPipeline(
               model=__UpperCamelCase					,						tokenizer=__UpperCamelCase					,						candidate_labels=["polics", "health"]	)
           return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase	)->	str:
           __lowerCAmelCase								=					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
           __lowerCAmelCase								=					classifier("Who are you voting for in 2020?"					,						["politics"]	)
           self.assertEqual(__UpperCamelCase					,						{"sequence": ANY(__UpperCamelCase	), "labels": [ANY(__UpperCamelCase	)], "scores": [ANY(__UpperCamelCase	)]}	)

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

           __lowerCAmelCase								=					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	)

           __lowerCAmelCase								=					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	)

           __lowerCAmelCase								=					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
           __lowerCAmelCase								=					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	)
               ]					,						)
           __lowerCAmelCase								=					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  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	List[Any]:
           __lowerCAmelCase								=					zero_shot_classifier.model.config
           __lowerCAmelCase								=					config.labelaid
           __lowerCAmelCase								=					zero_shot_classifier.entailment_id

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

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

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

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

           __lowerCAmelCase								=					original_labelaid
           self.assertEqual(__UpperCamelCase					,						zero_shot_classifier.entailment_id	)


      @require_torch
      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					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?" * 1_0_0					,						candidate_labels=["politics", "public health", "science"]	)


      @require_torch
      def  __UpperCAmelCase		(	self	)->	List[str]:
           __lowerCAmelCase								=					pipeline(
               "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="pt"					,						)
           __lowerCAmelCase								=					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_3_3, 0.3_3_3, 0.3_3_3],
               }					,						)


      @require_tf
      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					pipeline(
               "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="tf"					,						)
           __lowerCAmelCase								=					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_3_3, 0.3_3_3, 0.3_3_3],
               }					,						)


      @slow
      @require_torch
      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					pipeline("zero-shot-classification"					,						model="roberta-large-mnli"					,						framework="pt"	)
           __lowerCAmelCase								=					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_7_6, 0.0_1_5, 0.0_0_9],
               }					,						)
           __lowerCAmelCase								=					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_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
               }					,						)


      @slow
      @require_tf
      def  __UpperCAmelCase		(	self	)->	int:
           __lowerCAmelCase								=					pipeline("zero-shot-classification"					,						model="roberta-large-mnli"					,						framework="tf"	)
           __lowerCAmelCase								=					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_7_6, 0.0_1_5, 0.0_0_9],
               }					,						)
           __lowerCAmelCase								=					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_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
               }					,						)














import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor



@require_tokenizers
@require_vision
class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					tempfile.mkdtemp()

           # fmt: off
           __lowerCAmelCase								=					["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
           # fmt: on
           __lowerCAmelCase								=					os.path.join(self.tmpdirname					,						VOCAB_FILES_NAMES["vocab_file"]	)
           with open(self.vocab_file					,						"w"					,						encoding="utf-8"	) as vocab_writer:
                vocab_writer.write("".join([x + "\n" for x in vocab_tokens]	)	)

           __lowerCAmelCase								=					{
               "do_resize": True,
               "size": {"height": 1_8, "width": 1_8},
               "do_normalize": True,
               "image_mean": [0.5, 0.5, 0.5],
               "image_std": [0.5, 0.5, 0.5],
           }
           __lowerCAmelCase								=					os.path.join(self.tmpdirname					,						__UpperCamelCase	)
           with open(self.image_processor_file					,						"w"					,						encoding="utf-8"	) as fp:
                json.dump(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						**__UpperCamelCase	)->	Optional[Any]:
           return BertTokenizer.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						**__UpperCamelCase	)->	Any:
           return ViTImageProcessor.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           shutil.rmtree(self.tmpdirname	)


      def  __UpperCAmelCase		(	self	)->	int:
           __lowerCAmelCase								=					[np.random.randint(2_5_5					,						size=(3, 3_0, 4_0_0)					,						dtype=np.uinta	)]

           __lowerCAmelCase								=					[Image.fromarray(np.moveaxis(__UpperCamelCase					,						0					,						-1	)	) for x in image_inputs]

           return image_inputs


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					self.get_tokenizer()
           __lowerCAmelCase								=					self.get_image_processor()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           processor.save_pretrained(self.tmpdirname	)
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname	)

           self.assertEqual(processor.tokenizer.get_vocab()					,						tokenizer.get_vocab()	)
           self.assertIsInstance(processor.tokenizer					,						(BertTokenizer, BertTokenizerFast)	)

           self.assertEqual(processor.image_processor.to_json_string()					,						image_processor.to_json_string()	)
           self.assertIsInstance(processor.image_processor					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	str:
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(
               tokenizer=self.get_tokenizer()					,						image_processor=self.get_image_processor()	)
           processor.save_pretrained(self.tmpdirname	)

           __lowerCAmelCase								=					self.get_tokenizer(bos_token="(BOS)"					,						eos_token="(EOS)"	)
           __lowerCAmelCase								=					self.get_image_processor(do_normalize=__UpperCamelCase					,						padding_value=1.0	)

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.from_pretrained(
               self.tmpdirname					,						bos_token="(BOS)"					,						eos_token="(EOS)"					,						do_normalize=__UpperCamelCase					,						padding_value=1.0	)

           self.assertEqual(processor.tokenizer.get_vocab()					,						tokenizer_add_kwargs.get_vocab()	)
           self.assertIsInstance(processor.tokenizer					,						(BertTokenizer, BertTokenizerFast)	)

           self.assertEqual(processor.image_processor.to_json_string()					,						image_processor_add_kwargs.to_json_string()	)
           self.assertIsInstance(processor.image_processor					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Union[str, Any]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					image_processor(__UpperCamelCase					,						return_tensors="np"	)
           __lowerCAmelCase								=					processor(images=__UpperCamelCase					,						return_tensors="np"	)

           for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()					,						input_processor[key].sum()					,						delta=1e-2	)


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"

           __lowerCAmelCase								=					processor(text=__UpperCamelCase	)

           __lowerCAmelCase								=					tokenizer(__UpperCamelCase	)

           for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]					,						encoded_processor[key]	)


      def  __UpperCAmelCase		(	self	)->	List[str]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

           self.assertListEqual(list(inputs.keys()	)					,						["input_ids", "token_type_ids", "attention_mask", "pixel_values"]	)

           # test if it raises when no input is passed
           with self.assertRaises(__UpperCamelCase	):
                processor()


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

           __lowerCAmelCase								=					processor.batch_decode(__UpperCamelCase	)
           __lowerCAmelCase								=					tokenizer.batch_decode(__UpperCamelCase	)

           self.assertListEqual(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

           self.assertListEqual(list(inputs.keys()	)					,						processor.model_input_names	)






