
'''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.
__lowerCAmelCase         =    {"""LayoutLMv2Config""", """LayoutLMv3Config"""}







@is_pipeline_test
class UpperCAmelCase__	( unittest.TestCase	):





  """simple docstring"""

  __UpperCAmelCase				:				int   =					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  __UpperCAmelCase				:				Any   =					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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


  def   __lowercase		(		self      :     Optional[int]							,_a      :     Optional[Any]							,_a      :     Optional[Any]							,_a      :     List[str]       ):


     '''simple docstring'''






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


  def   __lowercase		(		self      :     List[Any]							,_a      :     Optional[int]							,_a      :     Optional[Any]       ):


     '''simple docstring'''






     _a				:	Tuple			=   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				:	str			=   classifier('Who are you voting for in 2020?'							,candidate_labels=['politics']       )
     self.assertEqual(_a							,{'sequence': ANY(_a       ), 'labels': [ANY(_a       )], 'scores': [ANY(_a       )]}       )

     _a				:	Any			=   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				:	Optional[Any]			=   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				:	int			=   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				:	Optional[Any]			=   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				:	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      :     str							,_a      :     Pipeline       ):


     '''simple docstring'''






     _a				:	Tuple			=   zero_shot_classifier.model.config
     _a				:	Optional[Any]			=   config.labelaid
     _a				:	List[str]			=   zero_shot_classifier.entailment_id

     _a				:	List[str]			=   {'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				:	str			=   {'ENTAIL': 0, 'NON-ENTAIL': 1}
     self.assertEqual(zero_shot_classifier.entailment_id							,0       )

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

     _a				:	Any			=   original_labelaid
     self.assertEqual(_a							,zero_shot_classifier.entailment_id       )


  @require_torch
  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     _a				:	Union[str, Any]			=   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				:	Any			=   pipeline(
         'zero-shot-classification'							,model='sshleifer/tiny-distilbert-base-cased-distilled-squad'							,framework='pt'							,)
     _a				:	Optional[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.333, 0.333, 0.333],
         }							,)


  @require_tf
  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	List[Any]			=   pipeline(
         'zero-shot-classification'							,model='sshleifer/tiny-distilbert-base-cased-distilled-squad'							,framework='tf'							,)
     _a				:	Dict			=   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.333, 0.333, 0.333],
         }							,)


  @slow
  @require_torch
  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   pipeline('zero-shot-classification'							,model='roberta-large-mnli'							,framework='pt'       )
     _a				:	Optional[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.976, 0.015, 0.009],
         }							,)
     _a				:	List[str]			=   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.817, 0.713, 0.018, 0.018],
         }							,)


  @slow
  @require_tf
  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     _a				:	Dict			=   pipeline('zero-shot-classification'							,model='roberta-large-mnli'							,framework='tf'       )
     _a				:	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.976, 0.015, 0.009],
         }							,)
     _a				:	List[str]			=   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.817, 0.713, 0.018, 0.018],
         }							,)





'''simple docstring'''







import warnings

from ...utils import logging
from .image_processing_videomae import VideoMAEImageProcessor


__lowerCAmelCase         =    logging.get_logger(__name__)







class UpperCAmelCase__	( lowercase__	):





  """simple docstring"""

  def __init__(		self      :     Tuple							,*_a      :     List[str]							,**_a      :     Any       ):


     '''simple docstring'''






     warnings.warn(
         'The class VideoMAEFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
         ' Please use VideoMAEImageProcessor instead.'							,_a							,)
     super().__init__(*_a							,**_a       )



