


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



@is_pipeline_test
class 	__lowerCamelCase			(unittest.TestCase						):
       _lowercase											=     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       _lowercase											=     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







       def 		snake_case_	(			self: Tuple,A_: List[str],A_: str,A_: str					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: Optional[Any],A_: Tuple,A_: List[Any]					):






            '''simple docstring'''




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

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

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

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

            __UpperCamelCase =			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
            __UpperCamelCase =			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					)
                ],)
            __UpperCamelCase =			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 		snake_case_	(			self: List[str],A_: Pipeline					):






            '''simple docstring'''




            __UpperCamelCase =			zero_shot_classifier.model.config
            __UpperCamelCase =			config.labelaid
            __UpperCamelCase =			zero_shot_classifier.entailment_id

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

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

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

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

            __UpperCamelCase =			original_labelaid
            self.assertEqual(A_,zero_shot_classifier.entailment_id					)







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






            '''simple docstring'''




            __UpperCamelCase =			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: str					):






            '''simple docstring'''




            __UpperCamelCase =			pipeline(
                'zero-shot-classification',model='sshleifer/tiny-distilbert-base-cased-distilled-squad',framework='pt',)
            __UpperCamelCase =			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 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            __UpperCamelCase =			pipeline(
                'zero-shot-classification',model='sshleifer/tiny-distilbert-base-cased-distilled-squad',framework='tf',)
            __UpperCamelCase =			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 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




            __UpperCamelCase =			pipeline('zero-shot-classification',model='roberta-large-mnli',framework='pt'					)
            __UpperCamelCase =			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],
                },)
            __UpperCamelCase =			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 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




            __UpperCamelCase =			pipeline('zero-shot-classification',model='roberta-large-mnli',framework='tf'					)
            __UpperCamelCase =			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],
                },)
            __UpperCamelCase =			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],
                },)








import operator as op


__UpperCamelCase   :			Optional[Any]          = "scaler.pt"
__UpperCamelCase   :			Optional[Any]          = "pytorch_model"
__UpperCamelCase   :			str          = "random_states"
__UpperCamelCase   :			Optional[int]          = "optimizer"
__UpperCamelCase   :			Optional[int]          = "scheduler"
__UpperCamelCase   :			str          = "pytorch_model.bin"
__UpperCamelCase   :			List[str]          = "pytorch_model.bin.index.json"
__UpperCamelCase   :			List[str]          = "model.safetensors"
__UpperCamelCase   :			Optional[int]          = "model.safetensors.index.json"
__UpperCamelCase   :			List[str]          = "1.10.2"
__UpperCamelCase   :			Dict          = "py38"
__UpperCamelCase   :			List[str]          = "4.17.0"
__UpperCamelCase   :			Any          = ["ml.p3.16xlarge", "ml.p3dn.24xlarge", "ml.p4dn.24xlarge"]
__UpperCamelCase   :			Any          = ["FULL_SHARD", "SHARD_GRAD_OP", "NO_SHARD", "HYBRID_SHARD", "HYBRID_SHARD_ZERO2"]
__UpperCamelCase   :			int          = ["TRANSFORMER_BASED_WRAP", "SIZE_BASED_WRAP", "NO_WRAP"]
__UpperCamelCase   :			Dict          = ["BACKWARD_PRE", "BACKWARD_POST", "NO_PREFETCH"]
__UpperCamelCase   :			str          = ["FULL_STATE_DICT", "LOCAL_STATE_DICT", "SHARDED_STATE_DICT"]
__UpperCamelCase   :			List[Any]          = "2.0.1"
__UpperCamelCase   :			int          = ["pdsh", "standard", "openmpi", "mvapich"]
__UpperCamelCase   :			List[str]          = ["default", "reduce-overhead", "max-autotune"]

__UpperCamelCase   :			List[Any]          = {">": op.gt, ">=": op.ge, "==": op.eq, "!=": op.ne, "<=": op.le, "<": op.lt}

# These are the args for `torch.distributed.launch` for pytorch < 1.9
__UpperCamelCase   :			List[Any]          = [
    "nnodes",
    "nproc_per_node",
    "rdzv_backend",
    "rdzv_endpoint",
    "rdzv_id",
    "rdzv_conf",
    "standalone",
    "max_restarts",
    "monitor_interval",
    "start_method",
    "role",
    "module",
    "m",
    "no_python",
    "run_path",
    "log_dir",
    "r",
    "redirects",
    "t",
    "tee",
    "node_rank",
    "master_addr",
    "master_port",
]

__UpperCamelCase   :			List[str]          = ["DEEPSPEED", "MULTI_GPU", "FSDP", "MEGATRON_LM"]
__UpperCamelCase   :			int          = ["DEEPSPEED", "MULTI_XPU", "FSDP"]

