


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.
SCREAMING_SNAKE_CASE			: Union[str, Any]				   =					{"LayoutLMv2Config", "LayoutLMv3Config"}






@is_pipeline_test
class _lowerCamelCase(		unittest.TestCase  ):
       lowercase_					:      Tuple       					=     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       lowercase_					:      Union[str, Any]       					=     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

       if model_mapping is not None:
              lowercase_					:      Optional[Any]       					=     {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
       if tf_model_mapping is not None:
              lowercase_					:      Optional[int]       					=     {
                  config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
              }
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase)			->  Union[str, Any]:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						ZeroShotClassificationPipeline(
               model=lowerCamelCase, tokenizer=lowerCamelCase, candidate_labels=['polics', 'health'])
           return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase)			->  str:




           """simple docstring"""

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

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

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

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

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

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

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

           with self.assertRaises(lowerCamelCase):
               classifier('', candidate_labels='politics')

           with self.assertRaises(lowerCamelCase):
               classifier(lowerCamelCase, candidate_labels='politics')

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

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

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

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

           self.run_entailment_id(lowerCamelCase)
       def      UpperCamelCase	(   self, lowerCamelCase)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				Tuple 						=						zero_shot_classifier.model.config
           _lowercase			:				Tuple 						=						config.labelaid
           _lowercase			:				int 						=						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			:				Optional[Any] 						=						{'entailment': 0, 'neutral': 1, 'contradiction': 2}
           self.assertEqual(zero_shot_classifier.entailment_id, 0)

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

           _lowercase			:				Optional[int] 						=						{'ENTAIL': 2, 'NEUTRAL': 1, 'CONTR': 0}
           self.assertEqual(zero_shot_classifier.entailment_id, 2)

           _lowercase			:				Union[str, Any] 						=						original_labelaid
           self.assertEqual(lowerCamelCase, zero_shot_classifier.entailment_id)
       @require_torch
       def      UpperCamelCase	(   self)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				Optional[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?' * 1_00, candidate_labels=['politics', 'public health', 'science'])
       @require_torch
       def      UpperCamelCase	(   self)			->  List[Any]:




           """simple docstring"""

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

           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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)			->  Any:




           """simple docstring"""

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

           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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)			->  List[Any]:




           """simple docstring"""

           _lowercase			:				str 						=						pipeline('zero-shot-classification', model='roberta-large-mnli', framework='pt')
           _lowercase			:				Union[str, Any] 						=						zero_shot_classifier(
               'Who are you voting for in 2020?', candidate_labels=['politics', 'public health', 'science'])

           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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			:				Optional[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=lowerCamelCase, )
           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						pipeline('zero-shot-classification', model='roberta-large-mnli', framework='tf')
           _lowercase			:				Optional[Any] 						=						zero_shot_classifier(
               'Who are you voting for in 2020?', candidate_labels=['politics', 'public health', 'science'])

           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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			:				int 						=						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=lowerCamelCase, )
           self.assertEqual(
               nested_simplify(lowerCamelCase), {
                   '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 argparse

import torch

from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
from transformers.utils import logging


logging.set_verbosity_info()






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase):
   # Initialise PyTorch model
   UpperCamelCase_						=  MobileBertConfig.from_json_file(__lowercase)
   print(f"""Building PyTorch model from configuration: {config}""")
   UpperCamelCase_						=  MobileBertForPreTraining(__lowercase)
   # Load weights from tf checkpoint
   UpperCamelCase_						=  load_tf_weights_in_mobilebert(__lowercase     ,   __lowercase     ,   __lowercase)
   # Save pytorch-model
   print(f"""Save PyTorch model to {pytorch_dump_path}""")
   torch.save(model.state_dict()     ,   __lowercase)


if __name__ == "__main__":
 snake_case__   :						int													=   argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
 )
 parser.add_argument(
     """--mobilebert_config_file""",
     default=None,
     type=str,
     required=True,
     help=(
         """The config json file corresponding to the pre-trained MobileBERT model. \n"""
         """This specifies the model architecture."""
     ),
 )
 parser.add_argument(
     """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
 )
 snake_case__   :						Optional[Any]													=   parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)





