
"""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     :			Optional[Any]  						=			{"""LayoutLMv2Config""", """LayoutLMv3Config"""}

@is_pipeline_test
class 						a__		( unittest.TestCase		):
   __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      __magic_name__     (     self      ,       _a      ,       _a      ,       _a							):
          lowercase       :							Any									=				ZeroShotClassificationPipeline(
              model=_a      ,       tokenizer=_a      ,       candidate_labels=["polics", "health"]							)
          return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]
   def      __magic_name__     (     self      ,       _a      ,       _a							):
          lowercase       :							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
          lowercase       :							Optional[Any]									=				classifier("Who are you voting for in 2020?"      ,       ["politics"]							)
          self.assertEqual(_a      ,       {"sequence": ANY(_a							), "labels": [ANY(_a							)], "scores": [ANY(_a							)]}							)

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

          lowercase       :							Tuple									=				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							)

          lowercase       :							int									=				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							)

          lowercase       :							str									=				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
          lowercase       :							Tuple									=				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							)
              ]      ,       )
          lowercase       :							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      __magic_name__     (     self      ,       _a							):
          lowercase       :							List[Any]									=				zero_shot_classifier.model.config
          lowercase       :							Tuple									=				config.labelaid
          lowercase       :							Any									=				zero_shot_classifier.entailment_id

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

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

          lowercase       :							Optional[int]									=				{"ENTAIL": 0, "NON-ENTAIL": 1}
          self.assertEqual(zero_shot_classifier.entailment_id      ,       0							)

          lowercase       :							List[str]									=				{"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
          self.assertEqual(zero_shot_classifier.entailment_id      ,       2							)

          lowercase       :							Any									=				original_labelaid
          self.assertEqual(_a      ,       zero_shot_classifier.entailment_id							)
   @require_torch
   def      __magic_name__     (     self							):
          lowercase       :							List[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      __magic_name__     (     self							):
          lowercase       :							int									=				pipeline(
              "zero-shot-classification"      ,       model="sshleifer/tiny-distilbert-base-cased-distilled-squad"      ,       framework="pt"      ,       )
          lowercase       :							Optional[int]									=				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.3_3_3, 0.3_3_3, 0.3_3_3],
              }      ,       )
   @require_tf
   def      __magic_name__     (     self							):
          lowercase       :							Union[str, Any]									=				pipeline(
              "zero-shot-classification"      ,       model="sshleifer/tiny-distilbert-base-cased-distilled-squad"      ,       framework="tf"      ,       )
          lowercase       :							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.3_3_3, 0.3_3_3, 0.3_3_3],
              }      ,       )
   @slow
   @require_torch
   def      __magic_name__     (     self							):
          lowercase       :							Any									=				pipeline("zero-shot-classification"      ,       model="roberta-large-mnli"      ,       framework="pt"							)
          lowercase       :							str									=				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.9_7_6, 0.0_1_5, 0.0_0_9],
              }      ,       )
          lowercase       :							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.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
              }      ,       )

   @slow
   @require_tf
   def      __magic_name__     (     self							):
          lowercase       :							Optional[Any]									=				pipeline("zero-shot-classification"      ,       model="roberta-large-mnli"      ,       framework="tf"							)
          lowercase       :							Tuple									=				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.9_7_6, 0.0_1_5, 0.0_0_9],
              }      ,       )
          lowercase       :							Any									=				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.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
              }      ,       )




"""simple docstring"""




def     __magic_name__      ( __snake_case							:			int	,					__snake_case							:			int    )					->							Any:
       if b == 0:
              return 1
       if (b % 2) == 0:
              return actual_power(__snake_case	,					int(b / 2    )    ) * actual_power(__snake_case	,					int(b / 2    )    )
       else:
              return a * actual_power(__snake_case	,					int(b / 2    )    ) * actual_power(__snake_case	,					int(b / 2    )    )


def     __magic_name__      ( __snake_case							:			int	,					__snake_case							:			int    )					->							float:
       if b < 0:
              return 1 / actual_power(__snake_case	,					__snake_case    )
       return actual_power(__snake_case	,					__snake_case    )


if __name__ == "__main__":
   print(power(-2, -3))


