

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__       = {"LayoutLMv2Config", "LayoutLMv3Config"}






@is_pipeline_test
class 						__magic_name__    (       unittest.TestCase    ):
 UpperCAmelCase							    =						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 UpperCAmelCase							    =						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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


 def _UpperCamelCase	(						self		: Any			,						lowerCAmelCase__		: Optional[int]			,						lowerCAmelCase__		: List[Any]			,						lowerCAmelCase__		: Tuple    )    ->      Union[str, Any]:
   UpperCAmelCase					      =  ZeroShotClassificationPipeline(
       model=lowerCAmelCase__			,						tokenizer=lowerCAmelCase__			,						candidate_labels=["polics", "health"]    )
   return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]


 def _UpperCamelCase	(						self		: Union[str, Any]			,						lowerCAmelCase__		: Any			,						lowerCAmelCase__		: Optional[Any]    )    ->      Optional[int]:
   UpperCAmelCase					      =  classifier("Who are you voting for in 2020?"			,						candidate_labels="politics"    )
   self.assertEqual(lowerCAmelCase__			,						{"sequence": ANY(lowerCAmelCase__    ), "labels": [ANY(lowerCAmelCase__    )], "scores": [ANY(lowerCAmelCase__    )]}    )

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

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

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

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

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

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

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

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

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

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

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

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

   self.run_entailment_id(lowerCAmelCase__    )


 def _UpperCamelCase	(						self		: str			,						lowerCAmelCase__		: Pipeline    )    ->      str:
   UpperCAmelCase					      =  zero_shot_classifier.model.config
   UpperCAmelCase					      =  config.labelaid
   UpperCAmelCase					      =  zero_shot_classifier.entailment_id

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

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

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

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

   UpperCAmelCase					      =  original_labelaid
   self.assertEqual(lowerCAmelCase__			,						zero_shot_classifier.entailment_id    )


 @require_torch
 def _UpperCamelCase	(						self		: Optional[Any]    )    ->      Dict:
   UpperCAmelCase					      =  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		: int    )    ->      Tuple:
   UpperCAmelCase					      =  pipeline(
       "zero-shot-classification"			,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"			,						framework="pt"			,						)
   UpperCAmelCase					      =  zero_shot_classifier(
       "Who are you voting for in 2020?"			,						candidate_labels=["politics", "public health", "science"]    )

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


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

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


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

   self.assertEqual(
       nested_simplify(lowerCAmelCase__    )			,						{
           "sequence": "Who are you voting for in 2020?",
           "labels": ["politics", "public health", "science"],
           "scores": [0.976, 0.015, 0.009],
       }			,						)
   UpperCAmelCase					      =  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=lowerCAmelCase__			,						)
   self.assertEqual(
       nested_simplify(lowerCAmelCase__    )			,						{
           "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.817, 0.713, 0.018, 0.018],
       }			,						)


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

   self.assertEqual(
       nested_simplify(lowerCAmelCase__    )			,						{
           "sequence": "Who are you voting for in 2020?",
           "labels": ["politics", "public health", "science"],
           "scores": [0.976, 0.015, 0.009],
       }			,						)
   UpperCAmelCase					      =  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=lowerCAmelCase__			,						)
   self.assertEqual(
       nested_simplify(lowerCAmelCase__    )			,						{
           "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.817, 0.713, 0.018, 0.018],
       }			,						)






lowerCAmelCase__       = "\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

lowerCAmelCase__       = [{"type": "code", "content": INSTALL_CONTENT}]
lowerCAmelCase__       = {
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}



