






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



@is_pipeline_test
class 							_UpperCamelCase			(unittest.TestCase			):
      snake_case_  =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
      snake_case_  =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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


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


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase	)->	str:
           __lowerCAmelCase								=					classifier("Who are you voting for in 2020?"					,						candidate_labels="politics"	)
           self.assertEqual(__UpperCamelCase					,						{"sequence": ANY(__UpperCamelCase	), "labels": [ANY(__UpperCamelCase	)], "scores": [ANY(__UpperCamelCase	)]}	)

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

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

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

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

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

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

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

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

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

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

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

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

           self.run_entailment_id(__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	List[Any]:
           __lowerCAmelCase								=					zero_shot_classifier.model.config
           __lowerCAmelCase								=					config.labelaid
           __lowerCAmelCase								=					zero_shot_classifier.entailment_id

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

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

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

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

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


      @require_torch
      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					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_0_0					,						candidate_labels=["politics", "public health", "science"]	)


      @require_torch
      def  __UpperCAmelCase		(	self	)->	List[str]:
           __lowerCAmelCase								=					pipeline(
               "zero-shot-classification"					,						model="sshleifer/tiny-distilbert-base-cased-distilled-squad"					,						framework="pt"					,						)
           __lowerCAmelCase								=					zero_shot_classifier(
               "Who are you voting for in 2020?"					,						candidate_labels=["politics", "public health", "science"]	)

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

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

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

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











# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


lowerCamelCase			:					List[str]         =	'''Create a default config file for Accelerate with only a few flags set.'''





def       __lowerCAmelCase      (						__snake_case="no"					, __snake_case = default_json_config_file					, __snake_case = False       ):
     __lowerCAmelCase								=					Path(__snake_case       )
     path.parent.mkdir(parents=__snake_case					, exist_ok=__snake_case       )
     if path.exists():
          print(
              F"""Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`."""       )
          return False
     __lowerCAmelCase								=					mixed_precision.lower()
     if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
          raise ValueError(
              F"""`mixed_precision` should be one of 'no', 'fp16', 'bf16', or 'fp8'. Received {mixed_precision}"""       )
     __lowerCAmelCase								=					{
         "compute_environment": "LOCAL_MACHINE",
         "mixed_precision": mixed_precision,
     }
     if torch.cuda.is_available():
          __lowerCAmelCase								=					torch.cuda.device_count()
          __lowerCAmelCase								=					num_gpus
          __lowerCAmelCase								=					False
          if num_gpus > 1:
               __lowerCAmelCase								=					"MULTI_GPU"
          else:
               __lowerCAmelCase								=					"NO"
     elif is_xpu_available() and use_xpu:
          __lowerCAmelCase								=					torch.xpu.device_count()
          __lowerCAmelCase								=					num_xpus
          __lowerCAmelCase								=					False
          if num_xpus > 1:
               __lowerCAmelCase								=					"MULTI_XPU"
          else:
               __lowerCAmelCase								=					"NO"
     elif is_npu_available():
          __lowerCAmelCase								=					torch.npu.device_count()
          __lowerCAmelCase								=					num_npus
          __lowerCAmelCase								=					False
          if num_npus > 1:
               __lowerCAmelCase								=					"MULTI_NPU"
          else:
               __lowerCAmelCase								=					"NO"
     else:
          __lowerCAmelCase								=					0
          __lowerCAmelCase								=					True
          __lowerCAmelCase								=					1
          __lowerCAmelCase								=					"NO"
     __lowerCAmelCase								=					ClusterConfig(**__snake_case       )
     config.to_json_file(__snake_case       )
     return path





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     __lowerCAmelCase								=					parser.add_parser("default"					, parents=__snake_case					, help=__snake_case					, formatter_class=__snake_case       )
     parser.add_argument(
         "--config_file"					, default=__snake_case					, help=(
             "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
             "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
             "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
             "with 'huggingface'."
         )					, dest="save_location"					, )

     parser.add_argument(
         "--mixed_precision"					, choices=["no", "fp16", "bf16"]					, type=__snake_case					, help="Whether or not to use mixed precision training. "
         "Choose between FP16 and BF16 (bfloat16) training. "
         "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later."					, default="no"					, )
     parser.set_defaults(func=__snake_case       )
     return parser





def       __lowerCAmelCase      (						__snake_case       ):
     __lowerCAmelCase								=					write_basic_config(args.mixed_precision					, args.save_location       )
     if config_file:
          print(F"""accelerate configuration saved at {config_file}"""       )






