





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.
lowercase				:	int      						=  {"LayoutLMv2Config", "LayoutLMv3Config"}





@is_pipeline_test
class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   __A       :    Union[str, Any]	  =  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
   __A       :    List[str]	  =  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

   if model_mapping is not None:
      __A       :    List[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       :    Dict	  =  {
          config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
      }

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						List[Any]:







          '''simple docstring'''

          a__						:     Optional[int]			=    ZeroShotClassificationPipeline(
              model=__A ,  tokenizer=__A ,  candidate_labels=['polics', 'health'])
          return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Dict			=    classifier('Who are you voting for in 2020?' ,  candidate_labels='politics')
          self.assertEqual(__A ,  {'sequence': ANY(__A), 'labels': [ANY(__A)], 'scores': [ANY(__A)]})

          # No kwarg
          a__						:     List[Any]			=    classifier('Who are you voting for in 2020?' ,  ['politics'])
          self.assertEqual(__A ,  {'sequence': ANY(__A), 'labels': [ANY(__A)], 'scores': [ANY(__A)]})

          a__						:     int			=    classifier('Who are you voting for in 2020?' ,  candidate_labels=['politics'])
          self.assertEqual(__A ,  {'sequence': ANY(__A), 'labels': [ANY(__A)], 'scores': [ANY(__A)]})

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

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

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

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

          with self.assertRaises(__A):
                 classifier('' ,  candidate_labels='politics')

          with self.assertRaises(__A):
                 classifier(__A ,  candidate_labels='politics')

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

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

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

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

          self.run_entailment_id(__A)

   def 							__lowercase		( self ,  lowercase)      ->						Tuple:







          '''simple docstring'''

          a__						:     Dict			=    zero_shot_classifier.model.config
          a__						:     Optional[Any]			=    config.labelaid
          a__						:     Any			=    zero_shot_classifier.entailment_id

          a__						:     Dict			=    {'''LABEL_0''': 0, '''LABEL_1''': 1, '''LABEL_2''': 2}
          self.assertEqual(zero_shot_classifier.entailment_id ,  -1)

          a__						:     Tuple			=    {'''entailment''': 0, '''neutral''': 1, '''contradiction''': 2}
          self.assertEqual(zero_shot_classifier.entailment_id ,  0)

          a__						:     Dict			=    {'''ENTAIL''': 0, '''NON-ENTAIL''': 1}
          self.assertEqual(zero_shot_classifier.entailment_id ,  0)

          a__						:     List[str]			=    {'''ENTAIL''': 2, '''NEUTRAL''': 1, '''CONTR''': 0}
          self.assertEqual(zero_shot_classifier.entailment_id ,  2)

          a__						:     List[Any]			=    original_labelaid
          self.assertEqual(__A ,  zero_shot_classifier.entailment_id)

   @require_torch
   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          a__						:     str			=    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)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     Optional[int]			=    pipeline(
              'zero-shot-classification' ,  model='sshleifer/tiny-distilbert-base-cased-distilled-squad' ,  framework='pt' ,  )
          a__						:     str			=    zero_shot_classifier(
              'Who are you voting for in 2020?' ,  candidate_labels=['politics', 'public health', 'science'])

          self.assertEqual(
              nested_simplify(__A) ,  {
                  '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)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    pipeline(
              'zero-shot-classification' ,  model='sshleifer/tiny-distilbert-base-cased-distilled-squad' ,  framework='tf' ,  )
          a__						:     List[Any]			=    zero_shot_classifier(
              'Who are you voting for in 2020?' ,  candidate_labels=['politics', 'public health', 'science'])

          self.assertEqual(
              nested_simplify(__A) ,  {
                  '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)      ->						Dict:







          '''simple docstring'''

          a__						:     Optional[int]			=    pipeline('zero-shot-classification' ,  model='roberta-large-mnli' ,  framework='pt')
          a__						:     Union[str, Any]			=    zero_shot_classifier(
              'Who are you voting for in 2020?' ,  candidate_labels=['politics', 'public health', 'science'])

          self.assertEqual(
              nested_simplify(__A) ,  {
                  'sequence': 'Who are you voting for in 2020?',
                  'labels': ['politics', 'public health', 'science'],
                  'scores': [0.9_76, 0.0_15, 0.0_09],
              } ,  )
          a__						:     Dict			=    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=__A ,  )
          self.assertEqual(
              nested_simplify(__A) ,  {
                  '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)      ->						Any:







          '''simple docstring'''

          a__						:     Tuple			=    pipeline('zero-shot-classification' ,  model='roberta-large-mnli' ,  framework='tf')
          a__						:     Tuple			=    zero_shot_classifier(
              'Who are you voting for in 2020?' ,  candidate_labels=['politics', 'public health', 'science'])

          self.assertEqual(
              nested_simplify(__A) ,  {
                  'sequence': 'Who are you voting for in 2020?',
                  'labels': ['politics', 'public health', 'science'],
                  'scores': [0.9_76, 0.0_15, 0.0_09],
              } ,  )
          a__						:     Any			=    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=__A ,  )
          self.assertEqual(
              nested_simplify(__A) ,  {
                  '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],
              } ,  )









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


lowercase				:	List[str]      						=  {
    """configuration_clip""": [
        """CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """CLIPConfig""",
        """CLIPOnnxConfig""",
        """CLIPTextConfig""",
        """CLIPVisionConfig""",
    ],
    """processing_clip""": ["""CLIPProcessor"""],
    """tokenization_clip""": ["""CLIPTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Tuple      						=  ["""CLIPTokenizerFast"""]

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Optional[int]      						=  ["""CLIPFeatureExtractor"""]
    lowercase				:	Union[str, Any]      						=  ["""CLIPImageProcessor"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Dict      						=  [
        """CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """CLIPModel""",
        """CLIPPreTrainedModel""",
        """CLIPTextModel""",
        """CLIPTextModelWithProjection""",
        """CLIPVisionModel""",
        """CLIPVisionModelWithProjection""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	List[str]      						=  [
        """TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFCLIPModel""",
        """TFCLIPPreTrainedModel""",
        """TFCLIPTextModel""",
        """TFCLIPVisionModel""",
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Any      						=  [
        """FlaxCLIPModel""",
        """FlaxCLIPPreTrainedModel""",
        """FlaxCLIPTextModel""",
        """FlaxCLIPTextPreTrainedModel""",
        """FlaxCLIPVisionModel""",
        """FlaxCLIPVisionPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_clip import (
        CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
        CLIPConfig,
        CLIPOnnxConfig,
        CLIPTextConfig,
        CLIPVisionConfig,
    )
    from .processing_clip import CLIPProcessor
    from .tokenization_clip import CLIPTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_clip_fast import CLIPTokenizerFast

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_clip import CLIPFeatureExtractor
        from .image_processing_clip import CLIPImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_clip import (
            CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            CLIPModel,
            CLIPPreTrainedModel,
            CLIPTextModel,
            CLIPTextModelWithProjection,
            CLIPVisionModel,
            CLIPVisionModelWithProjection,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_clip import (
            TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFCLIPModel,
            TFCLIPPreTrainedModel,
            TFCLIPTextModel,
            TFCLIPVisionModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_clip import (
            FlaxCLIPModel,
            FlaxCLIPPreTrainedModel,
            FlaxCLIPTextModel,
            FlaxCLIPTextPreTrainedModel,
            FlaxCLIPVisionModel,
            FlaxCLIPVisionPreTrainedModel,
        )


else:
    import sys

    lowercase				:	List[Any]      						=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


