




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__				:     Any 		=						{"LayoutLMv2Config", "LayoutLMv3Config"}
@is_pipeline_test
class 		UpperCAmelCase   (				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        snake_case__						(						self							:     List[str]       ,	__lowercase							:     str       ,	__lowercase							:     List[Any]       ,	__lowercase							:     Tuple						):






							"""simple docstring"""






							snake_case_		    =     ZeroShotClassificationPipeline(
							    model=__lowercase       ,	tokenizer=__lowercase       ,	candidate_labels=["polics", "health"]						)
							return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]






						def        snake_case__						(						self							:     Any       ,	__lowercase							:     Any       ,	__lowercase							:     Union[str, Any]						):






							"""simple docstring"""






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

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

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

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

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

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

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

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

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

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

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

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

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

							self.run_entailment_id(__lowercase						)






						def        snake_case__						(						self							:     List[str]       ,	__lowercase							:     Pipeline						):






							"""simple docstring"""






							snake_case_		    =     zero_shot_classifier.model.config
							snake_case_		    =     config.labelaid
							snake_case_		    =     zero_shot_classifier.entailment_id

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

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

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

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

							snake_case_		    =     original_labelaid
							self.assertEqual(__lowercase       ,	zero_shot_classifier.entailment_id						)






						@require_torch
						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							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?" * 1_00       ,	candidate_labels=["politics", "public health", "science"]						)






						@require_torch
						def        snake_case__						(						self							:     Optional[int]						):






							"""simple docstring"""






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

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






						@require_tf
						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






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

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






						@slow
						@require_torch
						def        snake_case__						(						self							:     int						):






							"""simple docstring"""






							snake_case_		    =     pipeline("zero-shot-classification"       ,	model="roberta-large-mnli"       ,	framework="pt"						)
							snake_case_		    =     zero_shot_classifier(
							    "Who are you voting for in 2020?"       ,	candidate_labels=["politics", "public health", "science"]						)

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






							"""simple docstring"""






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

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






def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





	_enforce_args(_A     ,	_A							)
	if n == 0:
		return 0
	snake_case_		    =     float("-inf"							)
	for i in range(1     ,	n + 1							):
		snake_case_		    =     max(
		    _A     ,	prices[i - 1] + naive_cut_rod_recursive(n - i     ,	_A							)							)

	return max_revue


def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





	_enforce_args(_A     ,	_A							)
	snake_case_		    =     [float("-inf"							) for _ in range(n + 1							)]
	return _top_down_cut_rod_recursive(_A     ,	_A     ,	_A							)


def 						lowerCamelCase__    (		_A     ,	_A     ,	_A							):







	'''simple docstring'''





	if max_rev[n] >= 0:
		return max_rev[n]
	elif n == 0:
		return 0
	else:
		snake_case_		    =     float("-inf"							)
		for i in range(1     ,	n + 1							):
			snake_case_		    =     max(
			    _A     ,	prices[i - 1] + _top_down_cut_rod_recursive(n - i     ,	_A     ,	_A							)     ,	)

		snake_case_		    =     max_revenue

	return max_rev[n]


def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





	_enforce_args(_A     ,	_A							)

	# length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
	# length 0.
	snake_case_		    =     [float("-inf"							) for _ in range(n + 1							)]
	snake_case_		    =     0

	for i in range(1     ,	n + 1							):
		snake_case_		    =     max_rev[i]
		for j in range(1     ,	i + 1							):
			snake_case_		    =     max(_A     ,	prices[j - 1] + max_rev[i - j]							)

		snake_case_		    =     max_revenue_i

	return max_rev[n]


def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





	if n < 0:
		snake_case_		    =     f"n must be greater than or equal to 0. Got n = {n}"
		raise ValueError(_A							)

	if n > len(_A							):
		snake_case_		    =     (
		    "Each integral piece of rod must have a corresponding price. "
		    f"Got n = {n} but length of prices = {len(_A							)}"
		)
		raise ValueError(_A							)


def 						lowerCamelCase__    (		):







	'''simple docstring'''





	snake_case_		    =     [6, 10, 12, 15, 20, 23]
	snake_case_		    =     len(_A							)

	# the best revenue comes from cutting the rod into 6 pieces, each
	# of length 1 resulting in a revenue of 6 * 6 = 36.
	snake_case_		    =     36

	snake_case_		    =     top_down_cut_rod(_A     ,	_A							)
	snake_case_		    =     bottom_up_cut_rod(_A     ,	_A							)
	snake_case_		    =     naive_cut_rod_recursive(_A     ,	_A							)

	assert expected_max_revenue == max_rev_top_down
	assert max_rev_top_down == max_rev_bottom_up
	assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
		main()
