





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




@is_pipeline_test
class 			__lowercase     (     unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
					__lowerCAmelCase					=					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  Union[str, Any]         =					ZeroShotClassificationPipeline(
									    model=_UpperCAmelCase		,     tokenizer=_UpperCAmelCase		,     candidate_labels=['''polics''', '''health''']       )
									return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







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

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

									__a	:  List[str]         =					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       )

									__a	:  Union[str, Any]         =					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       )

									__a	:  str         =					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
									__a	:  List[Any]         =					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       )
									    ]		,     )
									__a	:  str         =					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 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									__a	:  Union[str, Any]         =					zero_shot_classifier.model.config
									__a	:  Any         =					config.labelaid
									__a	:  str         =					zero_shot_classifier.entailment_id

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

									__a	:  Optional[Any]         =					{'''entailment''': 0, '''neutral''': 1, '''contradiction''': 2}
									self.assertEqual(zero_shot_classifier.entailment_id		,     0       )

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

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

									__a	:  Dict         =					original_labelaid
									self.assertEqual(_UpperCAmelCase		,     zero_shot_classifier.entailment_id       )







					@require_torch
					def 	_lowerCamelCase						(  self       ):
									__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 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					pipeline(
									    '''zero-shot-classification'''		,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''		,     framework='''pt'''		,     )
									__a	:  List[Any]         =					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 	_lowerCamelCase						(  self       ):
									__a	:  Union[str, Any]         =					pipeline(
									    '''zero-shot-classification'''		,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''		,     framework='''tf'''		,     )
									__a	:  List[str]         =					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 	_lowerCamelCase						(  self       ):
									__a	:  List[str]         =					pipeline('''zero-shot-classification'''		,     model='''roberta-large-mnli'''		,     framework='''pt'''       )
									__a	:  List[Any]         =					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],
									    }		,     )
									__a	:  Optional[int]         =					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 	_lowerCamelCase						(  self       ):
									__a	:  Dict         =					pipeline('''zero-shot-classification'''		,     model='''roberta-large-mnli'''		,     framework='''tf'''       )
									__a	:  Dict         =					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],
									    }		,     )
									__a	:  Tuple         =					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],
									    }		,     )






"""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 ViTImageProcessor




class 			__lowercase     (     unittest.TestCase							):







					'''simple docstring'''




					def __init__(  self		,     _UpperCAmelCase		,     _UpperCAmelCase=13		,     _UpperCAmelCase=3		,     _UpperCAmelCase=224		,     _UpperCAmelCase=30		,     _UpperCAmelCase=400		,     _UpperCAmelCase=True		,     _UpperCAmelCase=None		,     _UpperCAmelCase=True		,     _UpperCAmelCase=[0.5, 0.5, 0.5]		,     _UpperCAmelCase=[0.5, 0.5, 0.5]		,     ):
									__a	:  int         =					size if size is not None else {'''height''': 18, '''width''': 18}
									__a	:  List[Any]         =					parent
									__a	:  Dict         =					batch_size
									__a	:  Dict         =					num_channels
									__a	:  int         =					image_size
									__a	:  Optional[Any]         =					min_resolution
									__a	:  Optional[int]         =					max_resolution
									__a	:  Dict         =					do_resize
									__a	:  List[Any]         =					size
									__a	:  int         =					do_normalize
									__a	:  Optional[Any]         =					image_mean
									__a	:  int         =					image_std







					def 	_lowerCamelCase						(  self       ):
									return {
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_normalize": self.do_normalize,
									    "do_resize": self.do_resize,
									    "size": self.size,
									}






@require_torch
@require_vision
class 			__lowercase     (     _UpperCamelCase				, unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					ViTImageProcessor if is_vision_available() else None







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					EfficientFormerImageProcessorTester(self       )







					@property
					def 	_lowerCamelCase						(  self       ):
									return self.image_proc_tester.prepare_image_processor_dict()







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[str]         =					self.image_processing_class(**self.image_processor_dict       )
									self.assertTrue(hasattr(_UpperCAmelCase		,     '''image_mean'''       )       )
									self.assertTrue(hasattr(_UpperCAmelCase		,     '''image_std'''       )       )
									self.assertTrue(hasattr(_UpperCAmelCase		,     '''do_normalize'''       )       )
									self.assertTrue(hasattr(_UpperCAmelCase		,     '''do_resize'''       )       )
									self.assertTrue(hasattr(_UpperCAmelCase		,     '''size'''       )       )







					def 	_lowerCamelCase						(  self       ):
									pass







					def 	_lowerCamelCase						(  self       ):
									# Initialize image_processor
									__a	:  Any         =					self.image_processing_class(**self.image_processor_dict       )
									# create random PIL images
									__a	:  int         =					prepare_image_inputs(self.image_proc_tester		,     equal_resolution=_UpperCAmelCase       )
									for image in image_inputs:
													self.assertIsInstance(_UpperCAmelCase		,     Image.Image       )

									# Test not batched input
									__a	:  Dict         =					image_processor(image_inputs[0]		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        1,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )

									# Test batched
									__a	:  Any         =					image_processor(_UpperCAmelCase		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        self.image_proc_tester.batch_size,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )







					def 	_lowerCamelCase						(  self       ):
									# Initialize image_processor
									__a	:  Tuple         =					self.image_processing_class(**self.image_processor_dict       )
									# create random numpy tensors
									__a	:  int         =					prepare_image_inputs(self.image_proc_tester		,     equal_resolution=_UpperCAmelCase		,     numpify=_UpperCAmelCase       )
									for image in image_inputs:
													self.assertIsInstance(_UpperCAmelCase		,     np.ndarray       )

									# Test not batched input
									__a	:  Optional[int]         =					image_processor(image_inputs[0]		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        1,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )

									# Test batched
									__a	:  str         =					image_processor(_UpperCAmelCase		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        self.image_proc_tester.batch_size,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )







					def 	_lowerCamelCase						(  self       ):
									# Initialize image_processor
									__a	:  int         =					self.image_processing_class(**self.image_processor_dict       )
									# create random PyTorch tensors
									__a	:  List[Any]         =					prepare_image_inputs(self.image_proc_tester		,     equal_resolution=_UpperCAmelCase		,     torchify=_UpperCAmelCase       )
									for image in image_inputs:
													self.assertIsInstance(_UpperCAmelCase		,     torch.Tensor       )

									# Test not batched input
									__a	:  str         =					image_processor(image_inputs[0]		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        1,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )

									# Test batched
									__a	:  Tuple         =					image_processor(_UpperCAmelCase		,     return_tensors='''pt'''       ).pixel_values
									self.assertEqual(
									    encoded_images.shape		,     (
									        self.image_proc_tester.batch_size,
									        self.image_proc_tester.num_channels,
									        self.image_proc_tester.size['''height'''],
									        self.image_proc_tester.size['''width'''],
									    )		,     )