



"""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       UpperCamelCase__			(   unittest.TestCase      ):

			"""simple docstring"""


			A__	:					str							  =     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			A__	:					Union[str, Any]							  =     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						A__	:					int							  =     {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
			if tf_model_mapping is not None:
						A__	:					Union[str, Any]							  =     {
						    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
						}


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


			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)      ->	Tuple:
				A__											=					classifier("Who are you voting for in 2020?"						,	candidate_labels="politics"		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	{"sequence": ANY(SCREAMING_SNAKE_CASE__		), "labels": [ANY(SCREAMING_SNAKE_CASE__		)], "scores": [ANY(SCREAMING_SNAKE_CASE__		)]}		)

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

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

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

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

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

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

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

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

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

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

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

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

				self.run_entailment_id(SCREAMING_SNAKE_CASE__		)


			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__		)      ->	Optional[Any]:
				A__											=					zero_shot_classifier.model.config
				A__											=					config.labelaid
				A__											=					zero_shot_classifier.entailment_id

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

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

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

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

				A__											=					original_labelaid
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	zero_shot_classifier.entailment_id		)


			@require_torch
			def   snake_case__	(      self		)      ->	List[Any]:
				A__											=					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   snake_case__	(      self		)      ->	Optional[int]:
				A__											=					pipeline(
				    "zero-shot-classification"						,	model="sshleifer/tiny-distilbert-base-cased-distilled-squad"						,	framework="pt"						,	)
				A__											=					zero_shot_classifier(
				    "Who are you voting for in 2020?"						,	candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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   snake_case__	(      self		)      ->	List[Any]:
				A__											=					pipeline(
				    "zero-shot-classification"						,	model="sshleifer/tiny-distilbert-base-cased-distilled-squad"						,	framework="tf"						,	)
				A__											=					zero_shot_classifier(
				    "Who are you voting for in 2020?"						,	candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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   snake_case__	(      self		)      ->	Union[str, Any]:
				A__											=					pipeline("zero-shot-classification"						,	model="roberta-large-mnli"						,	framework="pt"		)
				A__											=					zero_shot_classifier(
				    "Who are you voting for in 2020?"						,	candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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__											=					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=SCREAMING_SNAKE_CASE__						,	)
				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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   snake_case__	(      self		)      ->	List[str]:
				A__											=					pipeline("zero-shot-classification"						,	model="roberta-large-mnli"						,	framework="tf"		)
				A__											=					zero_shot_classifier(
				    "Who are you voting for in 2020?"						,	candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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__											=					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=SCREAMING_SNAKE_CASE__						,	)
				self.assertEqual(
				    nested_simplify(SCREAMING_SNAKE_CASE__		)						,	{
				        "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],
				    }						,	)










def 		lowerCamelCase__       (						):







	'''simple docstring'''





	for n in range(1	,      1000000				):
		yield n * (n + 1) // 2


def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	1
	snake_case_						       =	2
	while i * i <= n:
		snake_case_						       =	0
		while n % i == 0:
			n //= i
			multiplicity += 1
		divisors_count *= multiplicity + 1
		i += 1
	if n > 1:
		divisors_count *= 2
	return divisors_count


def 		lowerCamelCase__       (						):







	'''simple docstring'''





	return next(i for i in triangle_number_generator() if count_divisors(_A				) > 500				)


if __name__ == "__main__":
		print(solution())
