


"""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.
__UpperCamelCase						=      {'''LayoutLMv2Config''', '''LayoutLMv3Config'''}
@is_pipeline_test
class 					lowerCAmelCase	(					unittest.TestCase    ):




		'''simple docstring'''







		SCREAMING_SNAKE_CASE_						:     Tuple								=     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
		SCREAMING_SNAKE_CASE_						:     Union[str, Any]								=     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Optional[Any]:
								SCREAMING_SNAKE_CASE													=					ZeroShotClassificationPipeline(
								    model=lowerCAmelCase__						,       tokenizer=lowerCAmelCase__						,       candidate_labels=['polics', 'health']				)
								return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







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

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

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

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

								SCREAMING_SNAKE_CASE													=					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
								SCREAMING_SNAKE_CASE													=					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				)
								    ]						,       )
								SCREAMING_SNAKE_CASE													=					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 							__A						(	self						,       lowerCAmelCase__				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					zero_shot_classifier.model.config
								SCREAMING_SNAKE_CASE													=					config.labelaid
								SCREAMING_SNAKE_CASE													=					zero_shot_classifier.entailment_id

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

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

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

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

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







		@require_torch
		def 							__A						(	self				)     ->							Dict:
								SCREAMING_SNAKE_CASE													=					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 							__A						(	self				)     ->							Union[str, Any]:
								SCREAMING_SNAKE_CASE													=					pipeline(
								    'zero-shot-classification'						,       model='sshleifer/tiny-distilbert-base-cased-distilled-squad'						,       framework='pt'						,       )
								SCREAMING_SNAKE_CASE													=					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.3_33, 0.3_33, 0.3_33],
								    }						,       )







		@require_tf
		def 							__A						(	self				)     ->							Optional[Any]:
								SCREAMING_SNAKE_CASE													=					pipeline(
								    'zero-shot-classification'						,       model='sshleifer/tiny-distilbert-base-cased-distilled-squad'						,       framework='tf'						,       )
								SCREAMING_SNAKE_CASE													=					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.3_33, 0.3_33, 0.3_33],
								    }						,       )







		@slow
		@require_torch
		def 							__A						(	self				)     ->							List[Any]:
								SCREAMING_SNAKE_CASE													=					pipeline('zero-shot-classification'						,       model='roberta-large-mnli'						,       framework='pt'				)
								SCREAMING_SNAKE_CASE													=					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.9_76, 0.0_15, 0.0_09],
								    }						,       )
								SCREAMING_SNAKE_CASE													=					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.8_17, 0.7_13, 0.0_18, 0.0_18],
								    }						,       )







		@slow
		@require_tf
		def 							__A						(	self				)     ->							Dict:
								SCREAMING_SNAKE_CASE													=					pipeline('zero-shot-classification'						,       model='roberta-large-mnli'						,       framework='tf'				)
								SCREAMING_SNAKE_CASE													=					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.9_76, 0.0_15, 0.0_09],
								    }						,       )
								SCREAMING_SNAKE_CASE													=					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.8_17, 0.7_13, 0.0_18, 0.0_18],
								    }						,       )






"""simple docstring"""




from typing import TYPE_CHECKING

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


__UpperCamelCase						=      {
    '''configuration_blip''': [
        '''BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BlipConfig''',
        '''BlipTextConfig''',
        '''BlipVisionConfig''',
    ],
    '''processing_blip''': ['''BlipProcessor'''],
}

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__UpperCamelCase						=      ['''BlipImageProcessor''']


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__UpperCamelCase						=      [
	    '''BLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''BlipModel''',
	    '''BlipPreTrainedModel''',
	    '''BlipForConditionalGeneration''',
	    '''BlipForQuestionAnswering''',
	    '''BlipVisionModel''',
	    '''BlipTextModel''',
	    '''BlipForImageTextRetrieval''',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__UpperCamelCase						=      [
	    '''TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''TFBlipModel''',
	    '''TFBlipPreTrainedModel''',
	    '''TFBlipForConditionalGeneration''',
	    '''TFBlipForQuestionAnswering''',
	    '''TFBlipVisionModel''',
	    '''TFBlipTextModel''',
	    '''TFBlipForImageTextRetrieval''',
	]

if TYPE_CHECKING:
	from .configuration_blip import BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipConfig, BlipTextConfig, BlipVisionConfig
	from .processing_blip import BlipProcessor

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .image_processing_blip import BlipImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_blip import (
		    BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    BlipForConditionalGeneration,
		    BlipForImageTextRetrieval,
		    BlipForQuestionAnswering,
		    BlipModel,
		    BlipPreTrainedModel,
		    BlipTextModel,
		    BlipVisionModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_blip import (
		    TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFBlipForConditionalGeneration,
		    TFBlipForImageTextRetrieval,
		    TFBlipForQuestionAnswering,
		    TFBlipModel,
		    TFBlipPreTrainedModel,
		    TFBlipTextModel,
		    TFBlipVisionModel,
		)

else:
	import sys

	__UpperCamelCase						=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


